Agent-Driven Demo Recording

Fraime.it can hand an agent the whole production chain. You describe the video you want in plain language. The agent works out the steps, drives the app on screen, records it, cuts the dead air, frames the shots, checks the result, and exports a finished MP4.

This is the agent track. For AI editing inside the app, without connecting anything, see AI Editing With The Timeline Assistant.

Who writes what

Most demo tools work the other way round: you write the steps, and the tool replays them. Here the split is:

• You write a sentence. "Record a 45 second walkthrough of the pricing page, ending on the enterprise tier." That is the whole input. No selectors, no coordinates, no step list, no timings.
• The agent writes the script. The bundled record-fraimeit-demo skill turns your sentence into an ordered set of beats, each with a label, a plain-language instruction, the visible state that proves it worked, and an estimated on-camera duration.
• Fraime.it saves that script into the project package as demo.script.json, so the intent behind the video stays with it.

demo.script.json is the agent's output, not your input. You never have to open it. It is there so a later run can rebuild or revise the same demo.

What an agent can record

Any app you can put in a window:

• A web flow. Fraime.it launches and owns an isolated Chrome window, so your real profile, tabs, cookies, extensions, and bookmarks stay out of the recording, and there is no automation banner.
• A terminal or CLI session. The agent stages the window and records the commands running.
• An IDE walkthrough. Pair it with the editor extension so the timeline knows which files and functions were on screen.
• A coding agent recording its own work. See Recording Claude Code Sessions.
• Two windows together, either swapping between them or side by side. See Two-window layouts.

Browser control is the only part that needs an extra download.

Before you start

Browser Automation is optional and off by default. Only install it if you want an agent driving a browser. In Recording Settings → Advanced → Browser Automation, choose Download & Install, then enable it. Fraime.it downloads a pinned, checksum-verified Node runtime for this Mac only after that explicit action. Ordinary recording, editing, and the non-browser agent tools never require it.

The demo skill teaches your agent the workflow. Install it from Recording Settings → Advanced → Agent Demo Skill for Cursor, Claude Code, or Codex.

For Codex, also copy the Codex MCP config from Fraime.it into ~/.codex/config.toml. The skill installs to ~/.codex/skills/record-fraimeit-demo/SKILL.md. Restart Codex afterwards so it picks the skill up. Older Codex builds also need skills = true under [features] in that same config file.

You will also need the MCP connection itself. See Agent API And MCP Setup.

The chain

1. Prompt

You describe the outcome. The agent asks a question only when the answer would change the story or when an instruction has more than one plausible reading.

2. Script

The agent drafts 4 to 8 beats. Each beat says what the viewer should see, never how the page is built. It estimates the on-camera time per beat and checks the total against the length you asked for.

3. Rehearse

The agent walks the route once without recording. It inspects the live page, confirms every destination and expected state, and finds the things that ruin a clean take: cookie banners, lazy-loaded sections, sticky navigation, links that open new tabs, separate scroll containers.

It then rewrites the script into the shortest coherent route and restores the starting state. Nothing is discovered for the first time on camera.

Rehearsal stays read-only. The agent does not submit forms, create or delete data, sign in, or buy anything while exploring.

4. Stage

The window is resized once to the target preset and verified to the pixel. From this point the geometry is frozen. If anything moves or resizes, the run stops rather than producing a subtly broken recording.

5. Record

Capture starts paused, and stays paused by default. Each visible action resumes capture immediately before it happens and pauses again once it settles.

That is why agent-recorded video has no dead air in it. The model's thinking time, the snapshots it takes to decide what to click, and the tool latency between steps are never captured at all.

The agent marks each beat just before acting, so Fraime.it knows the target, the intended duration, and which cursor to draw. The real pointer stays out of the captured pixels and a smooth synthetic cursor is reconstructed afterwards.

6. Cut

Agent pacing removes what is left. Because every action was timestamped on the capture clock, the cuts come from exact recorded spans rather than from guessing at video frames. It keeps the beats and the zoom holds, removes the gaps between them, and trims the tail after the final beat.

7. Polish

Beats become chapters and zoom framing automatically. From there the agent can add title cards, callouts, spotlights, overlays, and imported images through the same typed edit operations the editor uses, previewing each plan before applying it.

8. Verify and ship

The agent renders individual composited frames to PNG and looks at them, checking framing, legibility, overlays, redactions, and cursor styling before committing. It never re-exports the video just to see whether an edit worked.

Then it exports to the path you asked for and reports the duration, the chapters, and anything it changed from your original idea.

Asking for a demo

Prompts that work, across three different surfaces:

• "Record a 45 second walkthrough of our pricing page that ends on the enterprise tier."
• "Record a terminal demo of installing the CLI and running the first command, about 30 seconds."
• "Record a two-window demo: run the build in the terminal, then swap to Chrome to show the deployed page."

Say the length, the audience, and where the video should end. Skip the selectors and the coordinates, since the agent is told to ignore them and resolve elements live.

Two-window layouts

For a story involving two windows, the agent stages both at fixed geometry first, then picks a layout:

• swap captures one window at a time and cuts between them. Both windows are sized identically. Each swap becomes its own editable timeline clip, and seams are left as clean cuts so you can add transitions later.
• splitHorizontal or splitVertical keeps both windows visible in a single frame.

A split records the visible pixels of that screen region, so clear notifications, floating panels, and private windows before recording.

Sound and subtitles

An agent-driven demo is silent by design. The skill does not generate narration, voice-over, or synthetic speech, and it records with the microphone and system audio off. You get clean footage to narrate later, or to ship as-is with chapters and callouts.

Subtitles come from real speech. When a recording does have audio, such as a narrated walkthrough or a coding session you talked through, the agent can run transcription and place subtitles like any other timeline element. See Subtitles And Transcription.

Where the agent stops

The skill is written to fail loudly rather than improvise. A run stops and comes back to you on:

• A login screen, a CAPTCHA, or anything requiring credentials
• A destructive confirmation, a purchase, or a publish action
• Unexpected private data appearing on screen
• An instruction that two different elements could plausibly satisfy
• An action that failed, or one whose result could not be confirmed
• Any window drifting from its staged geometry

It will not fall back to shell commands or another browser-control extension when a Fraime.it tool is unavailable.

Some interactions have no tool behind them: hover, drag-and-drop, dragging a slider to a precise value, arbitrary keyboard shortcuts, file upload, clicking inside a canvas or WebGL surface, and Chrome's own UI. The agent is required to say so rather than fake it.

What you still own

Agent-driven recording is opt-in per run and stays visible while it happens. Everything lands in an ordinary Fraime.it project, so you can undo, retime, recut, or throw it away.

Two things stay yours. Watch the export before you publish it, and check the redactions yourself. Credential detection is an on-device analysis tool you run deliberately; it is not part of this pipeline, and no agent should be your final privacy reviewer. See Redaction And Text Replacement.

Troubleshooting

If the agent reports that browser tools are unavailable, install and enable Browser Automation in Recording Settings rather than reaching for another tool.

If your client never uses the skill, confirm it installed for that specific client and restart it. On Codex, check ~/.codex/config.toml for both the MCP entry and skills = true.

If a run stops partway, the recording up to that point still opens as a normal project. Fix the blocker, or ask for a shorter route, and record again.

If the finished video is right but the pacing is not, the timeline is fully editable. Trim it yourself, or ask the agent for a smaller follow-up edit.