How to Make a Changelog Video Automatically with Claude Code or Codex (MCP)

You can make a changelog video automatically by connecting Claude Code or Codex to a video MCP server and asking the agent to turn your latest release into a video. The agent reads the commits, writes a short JSON spec (screenshots, title, script, look, captions, format), checks a preview frame, and renders an MP4 for the release notes and a GIF for the README. A 12-second clip per feature takes a few minutes, and nobody opens a timeline editor.

Below is the setup with Lumora's MCP server (ours), with a full example spec. The spec is illustrative: field names match our create_video tool, but the values are made up. The agent docs have the full reference.

#Why make changelog videos at all?

Release notes are text, and most users skim them. A short clip of the new screen, with one sentence of narration, shows the change faster than a paragraph. The same clip works on X, LinkedIn and in the in-app changelog.

Most teams don't make them because each one costs an hour in an editor. Once an agent can produce a decent first cut from the code it just shipped, that cost drops to reviewing a preview.

#How does an agent make a video over MCP?

The Model Context Protocol lets an AI client call tools on a server. Over the Streamable HTTP transport, each message is an HTTP POST to a single endpoint. Our hosted server lives at /mcp on your account's address and takes a Bearer API key.

The tools the agent gets:

The loop is: list_styles → upload_media → create_video → preview_frame → (update_video) → render_video.

#How do you connect Claude Code?

First create an API key in your account settings, under API keys for agents. Then run:

claude mcp add --transport http lumora https://lumora.video/mcp \
  --header "Authorization: Bearer lum_..."

That's the documented Claude Code syntax for remote HTTP servers. By default the server is added for you in the current project only. Add --scope project to write it to .mcp.json so the whole team gets it. Keep the key out of the committed file: .mcp.json expands environment variables in url and headers, so each person sets their own.

{
  "mcpServers": {
    "lumora": {
      "type": "http",
      "url": "https://lumora.video/mcp",
      "headers": { "Authorization": "Bearer ${LUMORA_API_KEY}" }
    }
  }
}

Claude Code asks for approval before using servers from .mcp.json.

#How do you connect Codex?

Codex reads MCP servers from ~/.codex/config.toml. Per the Codex MCP docs, a Streamable HTTP server needs a url, and bearer_token_env_var names the environment variable that holds your key:

[mcp_servers.lumora]
url = "https://lumora.video/mcp"
bearer_token_env_var = "LUMORA_API_KEY"

Then export LUMORA_API_KEY=lum_... before starting Codex. There's also a plugin for Claude Code and Codex that bundles the server config with a skill for choosing styles. The agent docs cover installing it.

#What goes in the video spec?

Here's an illustrative spec for one feature in a release. Field names are exact. The values, product and URLs are examples.

{
  "name": "Pulse 2.4 release",
  "media": { "url": "/uploads/pulse-churn-alerts.png" },
  "brief": "Pulse now alerts you when churn spikes",
  "title": "Churn alerts",
  "tagline": "Know the day an account starts slipping",
  "look": "Launch day",
  "format": "landscape",
  "duration": 12,
  "script": "Pulse 2.4 adds churn alerts. Set a threshold, pick a channel, and Pulse pings you the day an account's usage drops.",
  "voice": true,
  "captions": "pop",
  "device": "macbook",
  "cta": { "text": "Try Pulse", "url": "https://example.com" }
}

What each field does:

The 12-second clip above has a 21-word script, which leaves room for the end card.

#What do you ask the agent?

Here is a prompt you can keep in the repo and reuse every release:

Make a changelog video for the release we just tagged.

1. Read the commits and merged PRs since the previous tag. Pick the one
   user-facing feature that matters most.
2. Use the screenshot in docs/screens/ for that feature. Upload it.
3. Call list_styles, then create_video with look "Launch day",
   format landscape, 10–15 seconds, captions "pop", device "macbook",
   and a script under 30 words in plain language (no internal names).
4. Call preview_frame at 2s and 8s. If the callouts cover the wrong
   element or text is cut off, fix it with update_video.
5. Render an MP4 and a GIF. Put both links in the release notes draft.

Two habits make the output better:

• Give it real screenshots. The agent can't invent your UI. Keep a folder of current screens, or capture them in the same PR that changes them.
• Make it look before it renders. preview_frame returns an image, so the agent can see whether the callout points at the right button. That one check catches most bad first cuts.

#How do you render and publish?

render_video with "format": "mp4" gives a download URL, a public share link with view analytics, and an .srt caption file when the video has a script. Run it again with "format": "gif" for the README or changelog page. If a render takes longer than about 50 seconds, the tool returns a renderId, and the agent polls render_status.

Where the outputs go:

1. GitHub release notes: the GIF inline, linked to the MP4. Check the GitHub size limits first: 10MB for GIFs.
2. In-app changelog: the MP4 or WebM.
3. X and LinkedIn: run update_video with "format": "vertical" and render again for a 9:16 cut.

Rendering needs an account. On the free plan exports are 720p with a watermark (3 a month). Pro removes the watermark, renders 1080p and includes AI direction. Details are on the homepage.

#What are the limits?

• It doesn't record your screen. You supply screenshots or a recording.
• It doesn't zoom from recorded clicks. Zooms and callouts come from the spec or the AI direction.
• It's a video, not an interactive demo. There are no clickable hotspots.
• Review before publishing. Treat the agent's cut as a draft. Check names, numbers and anything customer-facing.

For a full launch video rather than a release clip, the product demo video guide covers structure and scripting, and the Product Hunt launch video post covers launch-day specs.