Start free
For agents

Lampo for agents

Your agent doesn't need another paragraph. It needs the frame: its number, the drawing in video pixels, the marked picture, the stretch, the words, and the team's rules before it renders.

Connect your agent to Lampo Cloud

Its address is https://app.lampo.video/mcp. The first time your agent connects, it opens Lampo’s sign-in in your browser: sign in and allow it, with no token to copy.

In a terminal:

claude mcp add --transport http lampo https://app.lampo.video/mcp

Then sign in: run /mcp in Claude Code and follow the steps in your browser (or claude mcp login lampo).

In ~/.codex/config.toml:

[mcp_servers.lampo]
url = "https://app.lampo.video/mcp"
tool_timeout_sec = 330

Then sign in once: codex mcp login lampo.

In ~/.cursor/mcp.json (or .cursor/mcp.json in a project):

{
  "mcpServers": {
    "lampo": {
      "url": "https://app.lampo.video/mcp"
    }
  }
}

Cursor offers to connect: sign in when it asks.

In .vscode/mcp.json (or "MCP: Open User Configuration"):

{
  "servers": {
    "lampo": {
      "type": "http",
      "url": "https://app.lampo.video/mcp"
    }
  }
}

VS Code asks you to sign in the first time.

In ~/.gemini/config/mcp_config.json (or .agents/mcp_config.json in a project):

{
  "mcpServers": {
    "lampo": {
      "serverUrl": "https://app.lampo.video/mcp"
    }
  }
}

Antigravity signs in by itself the first time. Its config opens from the MCP Servers panel: ⋯ → Manage MCP Servers → View raw config.

In ~/.config/devin/mcp_config.json (Cascade panel ⋯ → Open MCP config file):

{
  "mcpServers": {
    "lampo": {
      "url": "https://app.lampo.video/mcp"
    }
  }
}

Windsurf is Devin Desktop now; it signs in the first time it uses the server.

In ~/.gemini/settings.json:

{
  "mcpServers": {
    "lampo": {
      "httpUrl": "https://app.lampo.video/mcp"
    }
  }
}

Gemini CLI signs in by itself when the server asks; /mcp auth lampo signs in again.

In ~/.config/zed/settings.json (or .zed/settings.json in a project):

{
  "context_servers": {
    "lampo": {
      "url": "https://app.lampo.video/mcp",
      "timeout": 330
    }
  }
}

Zed asks you to sign in.

In Claude on the web or the desktop: Customize → Connectors → + Add → Add custom connector. Give it a name and the address, then sign in when asked. On Team and Enterprise plans an owner adds it for the organization first.

On the web, with Plus, Pro, Business, Enterprise or Education: turn on Developer mode under Settings → Security and login, then open ChatGPT’s plugins, select + and create a developer-mode app with the address. It signs in through Lampo.

In the client's MCP config:

{
  "mcpServers": {
    "lampo": {
      "type": "http",
      "url": "https://app.lampo.video/mcp"
    }
  }
}

A client that speaks MCP over HTTP takes the address and signs in when Lampo asks.

Then tell it one sentence: Use Lampo for "Spring launch". That is the whole loop: it finds the project, puts up V1 itself, works your notes and waits for the next ones until you approve.

On your own machine or server, Settings → Connect an agent gives the same for its address, and lampo mcp config <client> prints it.

Everything people and agents type is Lampo: the repository lampo-vr/lampo, the lampo command (and lampo-mcp), the LAMPO_* settings, the MCP server's key lampo, the lampo:// resources and the npm package @lampo-vr/lampo. Setups from before keep working: vr and vr-mcp run the same commands, VR_* settings are still read, and vr:// addresses and the key video-review still answer. It is listed in awesome-mcp-servers, under multimedia processing.

Connect your agent, then tell it one sentence: "Use Lampo for <project>". That is the whole loop: Lampo's MCP server tells every agent that connects what to do, in its first read. The full reference is docs/agents.md (every command, the MCP tools, the data format).

The loop

  1. The project: list_folders, the one the person named or the work belongs to (none: a new name becomes the project with V1; several fit: ask once, with options).
  2. V1: no version there yet, the agent puts it up itself. It is its video from then on.
  3. Read the playbook and the taste (get_playbook, get_taste), then the open notes (get_open_notes; drawn notes come with their frame, cropped).
  4. Fix, put up the next version, mark_fixed each note with what changed. Never verify: people do.
  5. Wait in wait_for_feedback with the last cursor, again after every answer, until the person approves (sign-off is theirs) or says stop.

Every answer says what comes next: a hand-off ends with Now call wait_for_feedback with since "<cursor>"…, a read that leaves nothing to do with Nothing waiting for you: …. The person sees the agent from its first call, in the sidebar's Agents and in Settings → Connect an agent, and its work on a video as one line with the Agent view behind it, built from the calls it makes anyway (no status calls needed, no tokens spent). If the person presses Stop, the agent's next Lampo answer says so, once: it stops there. Claude Code's /lampo:watch is a shortcut for the same loop.

One way per kind of agent

The agentLampo throughA version goes up with
Claude, ChatGPT, Cursor's chat, any MCP clientMCP onlyrequest_upload (one PUT)
Claude Code, CodexMCPlampo render --to <video> --out <file> -- <render command> (--folder <project> for V1): the person sees the progress
the agent on the machine Lampo runs onMCP (stdio or the app)track_video, then re-renders to the same path
scripts without MCPlampo (npm run link; --json on every read)lampo render, lampo push

  • Connect: Settings → Connect an agent gives each client its one snippet (or a chat app its connector address); lampo mcp config <client> prints the same (docs/mcp.md): stdio (bin/lampo-mcp) or Streamable HTTP at /mcp (the local app, or a hosted server by signing in or with an API token).

    claude mcp add lampo -- /path/to/lampo/bin/lampo-mcp
lampo mcp config codex   # or claude, cursor, vscode, antigravity, windsurf, gemini, zed, json

  • Few tokens: pictures only for notes with a drawing, cropped to it; only what changed when an agent hands back what it was told (since, known); a lean tool set on request (LAMPO_MCP_TOOLS=lean). Measured in bench/tokens.

  • An Agent Skill teaches the same loop to agents that load skills.

  • A hosted server: lampo login <url> once, then every lampo command and the stdio MCP server work against it. Screenshots are downloaded, so the printed paths still open like local files. show_review shows the review inline in hosts that render MCP Apps.

On your machine, data/INBOX.md is the one file for "what did the reviewer say since last time": the newest 150 events from people, newest first, tagged → <session>. lampo inbox --mine [--since <iso>] gives the same as lines, also against a hosted server.

The data contract

data/
  INBOX.md                  newest human feedback across all videos
  events.jsonl              append-only log of every event (what `lampo watch` tails)
  <slug>/review.json        source of truth for one video: versions, notes, replies, approvals
  <slug>/review.md          the same, readable
  <slug>/<id>_clean.png     the exact frame, full resolution
  <slug>/<id>_marked.png    the same frame with the drawing burned in
versions/<slug>/vN.<ext>    the bytes of every registered render

slug is the video's absolute path with every / replaced by __ (shortened with a hash when that would exceed 255 bytes, see data-format.md). Frames are 0-based at the render's fps, timecodes mm:ss:ff, drawings in video pixels. lampo and the MCP server lock and write atomically, so don't hand-edit review.json, and never move or modify the renders under review: the tool only reads them. Field by field: docs/data-format.md.