Does aidemo work on localhost or apps behind a login?

Yes. aidemo drives your system Chrome locally, so it works against localhost and auth-walled apps using your own logged-in profile. Nothing is uploaded anywhere.

aidemo — your coding agent makes the demo video

How it works

Authoring is slow and happens once. Recording is a fast, deterministic replay — no LLM in the loop during capture, so the video is smooth, not an AI clicking around and waiting between screenshots.

You type one prompt

In your repo, with the bundled record-demo skill installed:

terminal

$ claude "record a 45s demo of the checkout flow we shipped this week"

The agent writes a readable artifact

One storyboard.json: the script, a per-scene voice & music plan, and a declarative browser action-spec. It's plain JSON — review it, edit a narration line, keep it in git.

storyboard.json

{ "id": "s2",
  "narration": "Search results come back instantly — let's compare the top two.",
  "actions": [
    { "op": "type",  "target": "#search", "text": "running shoes" },
    { "op": "click", "target": "text=Compare" } ] }

The engine renders the video

Drives your system Chrome with a smooth animated cursor, narrates each scene with realistic TTS, aligns word-level captions, trims the dead time, auto-zooms on interactions, and muxes a final MP4.

aidemo render

$ aidemo render demos/checkout
  voice     ✓ 6 scenes (cache hit: 4)
  record    ✓ 52.3s raw + timeline.json
  captions  ✓ word-aligned (whisper)
  compose   ✓ trim · sync · zoom · captions · music
  → output/final-demo.mp4  (45.1s, 1080p)

Tweak without re-recording

Edit one narration line → aidemo voice --scene s3 && aidemo compose regenerates just that scene's audio and the final cut. Bad zoom? Recompose, never re-record. That's the determinism payoff.

Why it's built this way

Deterministic replay

The recording runs a fixed action-spec at full speed. The agent authors the storyboard once; it's never in the loop during capture. Same input, same video.

Private by design

Your system Chrome, your logged-in profile — localhost, staging, and auth-walled apps all work, no cloud browser. The only network calls are voice and captions, and even those can hit a local OpenAI-compatible server for a fully offline render. No telemetry.

Cinematic by default

Screen-Studio-style auto-zoom on clicks and typing, eased smooth-scrolling, sidechain music ducking under narration, PNG-rendered captions that work on any ffmpeg.

Re-render, don't re-record

Per-scene TTS hash cache and compose-time zoom choreography mean edits are seconds, not another recording session.

What teams render with it

Five jobs, one engine. Each starts as a prompt or a one-liner in your repo — the agent authors, the engine renders, you ship the file.

GitHub README demos

The autoplaying GIF at the top of the readme. Render once, export, commit — no screen-recording session.

readme demo

$ aidemo render demos/onboarding --headless && aidemo gif demos/onboarding
  → demos/onboarding/output/final-demo.gif  # embed it in README.md

Landing-page hero videos

A muted, autoplaying MP4 for the marketing site. The hero video at the top of this page is aidemo output.

hero video

$ claude "record a 45s hero demo of the app for the landing page"
  → demos/hero/output/final-demo.mp4  # <video autoplay muted loop playsinline>

Release & what-shipped demos

Walk through what's new in the version you're cutting and attach the video to the release notes your customers actually read.

what shipped

$ claude "record a walkthrough of what's new in v1.4.0"
$ gh release upload v1.4.0 demos/whats-new/output/final-demo.mp4

Customer & prospect demos

Personalized walkthroughs against your real app. The replay runs in your own logged-in Chrome — localhost, staging, and auth-walled flows all work, and nothing is uploaded anywhere.

customer demo

$ claude "record the reporting flow on staging, logged in as the Acme sandbox account"
  → demos/acme-reporting/output/final-demo.mp4  # your Chrome, your profile

Progress demos

The end-of-sprint "what we built this week" clip. One prompt — the agent authors the storyboard and renders in the background while you keep working.

sprint review

$ claude "demo what we built this week for the sprint review"
  → demos/sprint-42/output/final-demo.mp4  # rendered while you kept working

Made with aidemo

aidemo's first customers — real products, not staged fixtures: live sites with auth walls, nested iframes, and production checkouts, demoed by a coding agent end to end.

MaxFit — shopping in a ChatGPT app

A 75-second shopping flow inside MaxFit's ChatGPT app — an auth-walled widget in nested iframes, through to a live checkout. Claude Code authored the storyboard.json; the engine recorded it as a deterministic replay.

Watch the narrated demo ▶ · maxfit.ee ↗

Turg — a live marketplace

A fitness-gear marketplace running in production. Its walkthrough is the next demo on this page — the same record-demo skill, pointed at the live site. The finished video will land here.

turg.fitness.ee ↗

Use it from your coding agent

aidemo ships as a CLI plus a Claude Code skill. The engine itself is agent-neutral — anything that writes a storyboard.json and runs aidemo render gets a video. Codex CLI (ChatGPT) and Gemini CLI adapters are on the roadmap.

claude — works today

$ npx -y github:tandryukha/aidemo#stable repo-init   # one-time: installs the record-demo skill
$ claude "record a 45s demo of our new checkout"
  storyboard  ✓ demos/checkout/storyboard.json — plain JSON, review it, commit it
  render      ✓ voice → record → captions → compose
  → demos/checkout/output/final-demo.mp4  (45.1s, 1080p)

$ codex "record a demo of what we shipped this sprint"   # planned
  # roadmap: agent-neutral authoring doc (AGENTS.md adapter) + MCP server
  # the engine already runs agent-neutral — storyboard.json in, MP4 out:
$ npx -y github:tandryukha/aidemo#stable render demos/sprint
  → demos/sprint/output/final-demo.mp4

$ gemini "record our onboarding flow"   # planned
  # roadmap: GEMINI.md adapter + MCP server exposing author / probe / render
$ npx -y github:tandryukha/aidemo#stable render demos/onboarding
  → demos/onboarding/output/final-demo.mp4

Integrations

Built on the APIs and tools you already use — each layer is swappable.

Authoring — Claude

Claude Code today, via the bundled record-demo skill: it writes the storyboard, confirms selectors, and runs the render. Codex CLI and Gemini CLI are planned via an agent-neutral authoring doc + MCP server.

Voice — OpenAI TTS

Realistic narration via OpenAI TTS (gpt-4o-mini-tts) — or any OpenAI-compatible local server (speaches, Kokoro-FastAPI) via OPENAI_BASE_URL, no API key needed. Synthesis sits behind a swappable VoiceProvider interface, so other providers can plug in too.

Captions — OpenAI Whisper

Word-level timestamps from Whisper keep captions in sync with the narration — from OpenAI, a local OpenAI-compatible server (LocalAI, speaches), or with no STT at all via aidemo captions --offline. Exported as SRT/VTT plus styled on-video overlays.

Record & render — Chrome + ffmpeg

Playwright drives your system Chrome; ffmpeg composes the final cut (trim, auto-zoom, music ducking, mux). All local — no cloud rendering.

Quickstart

A bundled fixture store renders a finished demo with zero external dependencies — under 5 minutes on a clean machine. Prereqs: Node 20+, Google Chrome, ffmpeg, an OpenAI API key (or a local OpenAI-compatible server).

quickstart

$ git clone https://github.com/tandryukha/aidemo && cd aidemo
$ npm install && cp .env.example .env   # add OPENAI_API_KEY
$ node examples/local-demo/serve.mjs     # terminal 1: fixture on :8787
$ node bin/aidemo.mjs render examples/local-demo --headless
$ open examples/local-demo/output/final-demo.mp4

What it produces: quickstart-demo.mp4 ▶

FAQ

What would I use aidemo for?

Anywhere your product needs a video: the hero demo on your landing page, a walkthrough GIF/MP4 in your GitHub README, a "here's what shipped" video attached to release notes for customers, onboarding clips for docs. Because the agent authors the storyboard from your repo's context, regenerating the video after a release is a one-line prompt.

Can aidemo make a GIF for a GitHub README?

Yes. Render the demo, then export it: aidemo render demos/onboarding --headless && aidemo gif demos/onboarding writes an autoplaying final-demo.gif next to the MP4 — commit it and embed it at the top of the readme. Regenerating after a release is re-running those two commands.

Can Claude Code record a demo video?

Yes — with aidemo's bundled record-demo skill, Claude Code writes the storyboard.json (script, per-scene voice plan, browser actions) and runs aidemo render. The engine does the rest: recording, voiceover, captions, final MP4.

How is aidemo different from Screen Studio or Clueso?

Those tools require a human to record raw footage first. With aidemo, your coding agent authors the demo and a deterministic player records it — no screen-recording session, no cloud upload. And it's MIT-licensed open source.

Does it work on localhost or apps behind a login?

Yes. aidemo drives your system Chrome locally with your own profile, so localhost, staging environments, and auth-walled apps all work. Nothing leaves your machine except the two narration/caption API calls — and those can go to a local OpenAI-compatible server instead of OpenAI.

What leaves your machine?

Two API calls, nothing else: text-to-speech for the narration and speech-to-text for caption timing, sent with your own OpenAI key — or to any OpenAI-compatible local server (speaches, Kokoro-FastAPI, LocalAI) via OPENAI_BASE_URL, which makes the whole render offline with no API key at all. aidemo captions --offline skips speech-to-text entirely. No telemetry, no analytics: music is synthesized locally, captions and cards are rasterized locally, and the output MP4 never leaves your disk.

Which coding agents work with aidemo?

Claude Code today, via the bundled skill. Codex CLI and Gemini CLI are planned via an agent-neutral authoring doc and an MCP server. Any human or agent that can write a storyboard.json and run aidemo render can use it.

Is it free?

Yes — MIT-licensed open source. The only runtime cost is your own OpenAI API key for narration and caption timing — and even that is optional: point OPENAI_BASE_URL at any OpenAI-compatible local server (speaches, Kokoro-FastAPI, LocalAI) and the render is free, key-free, and fully offline.