OpenAI · Builds and renders the video

Make a product launch video with Codex

Codex can edit files and run commands, which is what turning a reference video into your own takes: write the scenes, render, compare, fix. Kuchi gives Codex the reference and the plan.

Ask Codex for a launch video and it gets a short list of fitting templates from Kuchi, studies the one you choose shot by shot, asks you for your logo and screenshots, and builds to the reference's exact frame timings.

By Founder & Research Lead, Kalaris Labs · Updated

Step by step: Remotion with OpenAI Codex: build and render a product video

Connect Kuchi to Codex

No sign-in, no API key. The server is https://kuchi.kalarislabs.com/mcp.

  1. In a terminal, add the server to Codex CLI. No sign-in or API key is needed.

    codex mcp add kuchi --url https://kuchi.kalarislabs.com/mcp
  2. In the Codex app, open a new task with the setup prompt filled in.

    Open in Codex
  3. Optional: install the Kuchi skill so Codex knows the workflow before it calls a tool.

    npx skills add kalarislabs/kuchi

Why use Codex for your launch video

  • Runs the build, render and check loop without you copying files around.
  • Works in the CLI and the desktop app with the same server URL.
  • Pairs with Kuchi components, installed into the project with one command each.

How it works

  1. 1

    Choose a template

    A short list of real launch videos ranked for your product, with posters and links.

    kuchi_suggest_templates
  2. 2

    Study it

    Every shot's exact frames, how it enters, how much moves, its colours and a sheet of real frames.

    kuchi_get_breakdown
  3. 3

    Plan the remake

    Your product details mapped onto the reference's frames, with a list of anything still missing.

    kuchi_plan_remake
  4. 4

    Build

    Codex writes the scenes shot by shot, using Kuchi components where they fit, and renders the video.

    kuchi_get_component
  5. 5

    Check

    Compare your frames with the reference at the times it returns, and fix what differs.

    kuchi_check_remake

Prompts to try in Codex

  • Use Kuchi to suggest launch video templates for a B2B SaaS dashboard. Show me each poster and link.

  • Plan a remake of the template I picked with my product details, and list everything you still need from me.

  • Render the remake, then compare your frames with the reference at the times kuchi_check_remake gives you.

How Codex loads the MCP server

Codex stores MCP servers in ~/.codex/config.toml, shared by the CLI and the IDE extension. codex mcp add kuchi --url https://kuchi.kalarislabs.com/mcp writes an [mcp_servers.kuchi] table with a url key, which is how Codex knows the server is remote over Streamable HTTP rather than a local command. codex mcp list prints what is configured.

Because the file is plain TOML you can also edit it by hand, and the same entry works wherever Codex reads that config. The Codex app opens a task with the setup prompt filled in from the button on this page, so it knows the workflow from the first message.

Codex runs commands under an approval policy and, depending on how you start it, inside a sandbox. Tool calls to this server are read-only on the server side; the commands that matter for approval are the local ones, such as npm install and npx remotion render.

A full run in Codex, step by step

In a run, Codex calls kuchi_suggest_templates, shows the posters and waits for your choice, then calls kuchi_get_breakdown. You can attach a frame of the reference as an image if you want it to look closer at one shot. It writes the shot analysis, calls kuchi_plan_remake, and asks you once for anything in missing_inputs.

With the blueprint, Codex writes the Remotion project: a Root.tsx registering one composition at the blueprint's fps and total frames, and one <Sequence> per shot using start_frame and the shot's length in frames. It renders, calls kuchi_check_remake with the shot list (each shot keeps its reference_shot so timing can be compared), and fixes what is flagged.

AGENTS.md is the place for project rules: composition size, brand colours, where assets live, and "never round frame numbers". Codex reads it at the start of every task.

What Codex sends to the server

The server is a remote MCP server over Streamable HTTP at https://kuchi.kalarislabs.com/mcp. Every message is a JSON-RPC 2.0 request sent as an HTTP POST to that one endpoint. It is stateless: there is no session to keep alive, no cookie and no Authorization header, so Codex can reconnect at any time without losing anything.

When Codex connects it sends initialize and receives the server's name, version, instructions and capabilities (tools, resources and argument completion), then calls tools/list. The tool list carries a one-hour cache hint, because it only changes when the server is deployed. Each tool call is a tools/call whose arguments are checked against a strict schema: unknown fields are rejected and every string has a length limit, so a malformed call fails with a clear message instead of a half-right answer.

Results come back as text, Markdown by default or JSON when the call passes response_format: "json", and JSON results also arrive as structuredContent. Media is never inlined: the reference MP4, the poster and the storyboard sheets come as resource_link entries pointing at the CDN, which Codex can open or fetch itself. A result is capped at 25,000 characters; a long blueprint arrives in pages of up to 40 shots, with shot_offset and shot_limit to fetch the next page.

Every tool is annotated readOnlyHint: true, destructiveHint: false, idempotentHint: true and openWorldHint: false: nothing changes on the server, the same call returns the same answer, and no tool reaches out to the wider web. The server also offers resources (kuchi://workflow, kuchi://videos/{id}, kuchi://breakdowns/{id} and kuchi://components/{name}) with autocompletion, for clients that let you attach a resource to a message.

The 13 tools, and when Codex calls them

ToolWhat it returnsWhen Codex uses it
kuchi_get_workflowThe remake method, whole or one step (find, study, plan, build, check) with the rules that hold for all steps. Markdown.Read once before the first remake, or one step at a time to keep context small.
kuchi_suggest_templatesA short numbered list of launch videos ranked for a product description, each with poster, link, what fits, what differs, what you would need to supply and one recommendation.First call of a job; the agent shows the posters and waits for your pick.
kuchi_search_videosSearches the whole library by keyword, style, category, format, aspect ratio, length, pace or theme, a page at a time.When you ask for something specific ("vertical, fast, terminal style").
kuchi_get_videoOne video by id, slug, site link or original X link: file, poster, storyboard, length and measured rhythm, with resource links to the MP4 and images.When you paste a link from the site instead of choosing by number.
kuchi_list_filtersEvery valid style, category, format, aspect ratio, pace and theme with counts, plus the 14 shot kinds an agent classifies shots into.Before a filtered search, so it never guesses a filter value.
kuchi_get_breakdownThe frame-by-frame measurement of one video: each shot's start and end, entrance, amount of motion and colour roles, a per-second motion and loudness curve, and storyboard sheets of real frames.Study step; the agent looks at the storyboard and writes its own shot analysis.
kuchi_plan_remakeTakes your product details, assets and the agent's shot analysis; returns a blueprint re-timed to your length on whole frames, with your content per shot, plus missing_inputs and ready.Called until ready=true; the blueprint becomes the shot list in code.
kuchi_check_remakeChecks a shot list against the reference: reused brand text, assets taken from the reference, generated logos or UI, placeholders, timing gaps and drift. Returns passed and compare_frames.Before delivery; the agent renders stills at the compare_frames times and fixes drift.
kuchi_list_componentsLists the copy-paste Remotion components (kinetic type, captions, UI screens, cursors, logos, transitions) with dependencies and shadcn install commands.While building, to find a ready-made component for a shot.
kuchi_get_componentOne component's full source, files, dependencies, install command and usage notes, split into parts when long.To read a component's source before installing or adapting it.
kuchi_send_feedbackReports a failure or a missing capability to the maintainers. The only tool that records what the agent writes.When a tool fails or misleads.
searchThe generic search tool some clients expect: returns up to 10 video ids, titles and URLs.Rarely; the kuchi_ tools are richer.
fetchThe generic fetch tool: one video by the id from search, with notes, links and metadata.Rarely.

How the blueprint times your video

A reference video is measured shot by shot: where each shot starts and ends, how it enters and how much of the frame moves. kuchi_plan_remake maps those shots onto your target length, between 5 and 180 seconds, at the frame rate you will render (12 to 120 fps, the reference's own by default).

If your length is at least 75% of the reference's, every shot is kept and re-timed by the same factor (mode retimed). If it is much shorter, speeding everything up would wreck the rhythm, so the plan keeps an evenly spaced subset of shots, at least three, and re-times those instead (mode condensed). Either way every shot starts on a whole frame and lasts at least one, so start_frame and end_frame are exact integers Codex can place directly; no rounding happens later.

Each shot also carries compare_at_s: the moment in your video that matches the reference frame shown on the storyboard, so the side-by-side check compares like with like. precision says whether every shot was classified (analysed), some were (partly_analysed) or none were (timing_only); shots without a kind keep their timing and get placeholder content until Codex classifies them. One shot from a blueprint:

{
  "shot": 3,
  "start_s": 4.2,
  "end_s": 6.533,
  "start_frame": 126,
  "end_frame": 195,
  "reference_shot": 3,
  "reference_start_s": 3.9,
  "reference_end_s": 6.07,
  "compare_at_s": 5.1,
  "enters": "transition",
  "motion": "medium",
  "kind": "ui_screen",
  "reference_shows": "Product UI. Dashboard centered, cursor moves to a button",
  "your_content": "Acme: \"Live sync\". A screenshot or recording of the user's product..."
}

In Remotion the blueprint maps one to one onto a composition and a <Sequence> per shot. Saving the plan as plan.json and reading the frames from it means Codex never retypes a number:

// src/Root.tsx: one composition at the blueprint's fps and length
import { Composition } from 'remotion';
import plan from '../plan.json';
import { Launch } from './Launch';

export const Root = () => (
  <Composition id="Launch" component={Launch}
    fps={plan.blueprint.fps} durationInFrames={plan.blueprint.frames}
    width={1920} height={1080} />
);

// src/Launch.tsx: one <Sequence> per blueprint shot, on its exact frames
import { AbsoluteFill, Sequence } from 'remotion';
import plan from '../plan.json';
import { shots } from './shots';

export const Launch = () => (
  <AbsoluteFill>
    {plan.blueprint.shots.map((s) => {
      const Shot = shots[s.shot];
      return (
        <Sequence key={s.shot} from={s.start_frame}
          durationInFrames={s.end_frame - s.start_frame + 1}>
          <Shot />
        </Sequence>
      );
    })}
  </AbsoluteFill>
);

Use 1080×1920 for 9:16 and 1080×1080 for 1:1. Inside a <Sequence>, useCurrentFrame() starts at 0, so each shot's entrance animation is written relative to the shot, not to the whole video.

The 14 shot kinds Codex classifies

While studying the storyboard, Codex gives every reference shot one kind. The kind decides what of yours replaces it.

KindIn the referenceIn your video
title_cardWords on a plain or lightly textured backgroundA short line in your words
kinetic_typeWords that are the motion: typing, sliding, scalingYour headline, animated the same way
logoA brand mark on its own, usually a revealYour logo
ui_screenA whole product screen, flat to the cameraA screenshot or recording of your product
ui_closeupOne part of a screen enlarged: a button, a field, a cursorThe matching detail of your UI
deviceA screen inside a phone, laptop or browser frameYour screen in the same frame
chartA graph, counter or data graphic drawing inYour real numbers, never invented ones
characterA mascot, illustrated figure or avatarYour own mascot, or a placeholder
product_renderA physical product, photographed or in 3DYour product photo or render
live_actionFilmed footage of people or placesYour own footage, or a placeholder
collageSeveral images, cards or screens arranged togetherSeveral of your screens
abstractShapes, gradients, particles or lightThe same motion in your colours
end_cardThe closing frame: logo with a call to actionYour logo and call to action
blankAn empty frame held as a pauseThe same pause, nothing on screen

Entrances and motion

ValueMeaning
enters: cutHard cut: the whole picture changes in one frame.
enters: transitionAnimated transition: several frames of heavy change join two pictures (wipe, zoom, morph or dissolve).
enters: holdSame scene: motion resumes after the picture held still.
enters: blank_blackPasses through an empty black frame.
enters: blank_whitePasses through an empty white frame.
motion: stillUnder 0.4% of the frame moves.
motion: lowUnder 3%.
motion: mediumUnder 12%.
motion: high12% or more.

What the check catches before you ship

kuchi_check_remake takes the shot list Codex built: each shot's start and end in seconds, the reference_shot it rebuilds, how it enters, every line of on-screen text, and where each asset came from (user, generated, stock, placeholder or reference). It returns passed, errors and warnings by shot, and compare_frames.

  • Text that carries over the reference's brand, product names or slogans.
  • Any asset taken from the reference video: footage, UI, characters or music.
  • Generated logos or generated product UI, which should always come from you.
  • Placeholders still on screen.
  • Gaps or overlaps in the timeline, and shots whose length or entrance drifted from the reference shot they rebuild.

The check reads the shot list, not the file: the video never leaves your machine. Codex then renders a still at each compare_frames time and sets it beside the reference storyboard, which catches layout drift a quick watch misses.

Troubleshooting Codex

SymptomFix
npm install fails with a network errorThe sandbox has no network access for that command. Approve network for the step, or run the install yourself.
Codex lists no tools from the serverCheck ~/.codex/config.toml has url (not command) under [mcp_servers.kuchi], then start a new session.
The app and the CLI behave differentlyBoth read the same config file; make sure both were restarted after adding the server.
The plan keeps returning ready=falseRead missing_inputs: usually target length, a logo, or shots without a kind. Answer them and call kuchi_plan_remake again.
The tool list is empty or the connection times outCheck that nothing on your network (a proxy, VPN or firewall) blocks HTTPS to kuchi.kalarislabs.com, and that the URL ends in /mcp.
A tool says the catalog is temporarily unavailableThe library is refreshing. Retry in a minute; nothing on your side needs to change.

Launch video templates to start from

All launch videos →
00:37
Launch date ·
57.2K Impressions
15.9KVideo plays

Components Codex can install

All components →

Codex and Kuchi: questions

Does Kuchi work with Codex CLI and the Codex app?

Yes, both. The CLI adds it with codex mcp add kuchi --url https://kuchi.kalarislabs.com/mcp; the app opens a task with the setup prompt from the button on this page.

What does Codex build the video with?

Whatever your project uses. The Kuchi workflow suggests Remotion, and Kuchi serves ready-made Remotion components for kinetic type, captions, UI screens, cursors and logos.

Is Kuchi free to use with Codex?

Yes. The Kuchi MCP server is open: no account, no API key and no payment. Your own agent plan applies as usual.

Will my video copy the reference?

No. A remake borrows the reference's timing, motion and layout. Every logo, screen, line of copy and asset on screen comes from your product.