AI agent screen recording now runs in both directions. Agents could already read a Clipy recording as text and frames. With the free Clipy CLI, they can also make one: an agent records the app it just built in a headless browser, narrates it with timestamped notes, and hands you a share link with a real transcript.

Disclosure: Clipy is our product. Everything below is shipped and runnable today; commands are copy-pasteable.

AI agent screen recording: the missing half of agentic coding

Coding agents finish a task and give you prose: "I fixed the checkout button and verified it works." You then open the app yourself to check, which erases half the point of delegating. What you actually want is the agent equivalent of a pull-request screenshot: watchable proof.

That proof has to be a video for humans and a document for other agents, because the reviewer of an agent's work is increasingly another agent. We wrote about the reading half in what an agent-readable screen recording is. This post is the writing half: the agent as camera operator.

The whole loop, in agent terms:

  1. The agent finishes a change and starts the app locally.
  2. It runs one CLI command that loads the app in a headless Chromium, records it, and uploads the result to Clipy.
  3. While recording, it drops timestamped notes ("clicked Add to cart", "form validation appears"). Those notes become the transcript of the silent recording, so the summary, key moments, and Q&A all work as if a human had narrated it.
  4. It pastes the share link in its final message. You watch the video. Another agent reads the machine-readable context behind the same link.

Setup: one command if you use Claude Code

The fastest path installs the Clipy skill and signs you in at the same time:

npx @clipy/cli agents install claude   # or: codex / cursor

That opens your browser to approve the device (like gh auth login, no key to copy) and writes the Clipy skill into ~/.claude/skills/clipy/, so Claude Code knows every read and write command without you explaining them.

Recording needs two extras beyond the tiny base install. First, Playwright with its bundled Chromium:

npm install -g playwright && npx playwright install chromium

Second, an API key with the "Record & upload" (ingest) permission. If you used the browser login above you are done; if you mint keys by hand, create one at clipy.online/settings/api-keys and tick "Record & upload". Read-only keys can list and read recordings but cannot create them, which is the safe default for keys you paste into many tools.

Run clipy doctor at any point to check the key, Playwright, and install state in one shot.

One-shot recording: clipy record

The simplest form records a running web app for a fixed duration and prints the links:

clipy record --url http://localhost:3000 --for 20 --wait \
  --title "Checkout fix demo" \
  --note "3: landing page loads" \
  --note "10: added an item to the cart" \
  --type demo

What each part does:

  • --for 20 records for 20 seconds after the page loads. The capture is headless Chromium, so this works in CI, cloud sandboxes, and SSH boxes with no display.
  • --note "10: added an item to the cart" attaches a narration note at the 10-second mark. Notes are repeatable.
  • --type demo declares what the recording is (also bug, walkthrough, feedback and friends), so the AI summary reads it with the right intent. A demo is not a bug report, and the summary should not pretend otherwise.
  • --wait blocks until the transcript is ready, then prints the share URL and the agent-context URL. Add --json when an agent is the caller and wants {id, shareUrl, contextUrl} to parse.

The headless capture has no microphone, so there is no speech to transcribe. This is where the notes matter: Clipy uses the agent's timestamped notes as the transcript. The share page shows a real transcript and the summary is generated from it, and in the agent-readable context the transcript's source is explicitly marked as agent narration rather than speech-to-text, so a reading agent knows exactly where it came from.

Interactive recording: session start, mark, session stop

clipy record is fire-and-forget. When the agent needs to drive the app while recording (clicking through a flow, reproducing a bug), the session mode records in the background while the agent works:

clipy session start --url http://localhost:3000
# ...the agent interacts with the app, and narrates as it goes:
clipy mark "reproduced the bug: cart total shows NaN"
clipy mark "applied the fix, total now correct"
clipy session stop   # uploads, marks become the transcript, prints the link

Marks are stamped live against the recording clock, so "reproduced the bug" lands at the exact second it happened. Navigation events and console errors are also marked automatically, which means a crash during the session shows up in the transcript even if the agent forgot to mention it. clipy session abort throws the recording away; nothing uploads.

Every session has a maximum duration (default 10 minutes) and stops itself cleanly if the agent wanders off, uploading what it captured instead of leaking a zombie browser. Agents hang sometimes. The recorder should not.

What the person on the other end gets

The agent's final message contains one link. From that link:

  • A teammate watches the video, with the summary, key moments, and transcript alongside, and no sign-up to watch.
  • Claude Code, Cursor, or any MCP-capable agent reads the same recording as structured text and frames through the Clipy skill or the MCP server. The MCP server also exposes the write side (start_recording, add_marker, stop_recording), so an agent wired up through MCP can run this whole loop without shell access.

That two-audience link is the point. A raw .webm attached to a ticket serves neither audience well; see how agents consume recordings in a debugging workflow for the receiving side.

A prompt you can paste into Claude Code

After you finish the fix, start the dev server, then use the clipy skill to
record proof: clipy record --url http://localhost:3000 --for 20 --wait
--type demo, with --note entries for each step you show. Put the share
link in your final summary.

With the skill installed, Claude Code already knows the flags; the prompt just tells it when to record. Pin a variant of this in your repo instructions and every agent-made change ends with watchable proof. If you want the same loop for recordings a human made, that is the older direction: give Claude Code a screen recording.

Limits, honestly

  • Headless capture records the browser viewport only. It cannot record your desktop, native apps, or another monitor. Recording the real screen runs through the Clipy apps.
  • No microphone in headless mode; narration comes from notes and marks. If a human later records a voiceover version, real speech always wins over notes in the transcript.
  • Playwright and Chromium are a one-time install kept out of the base package on purpose, so the read-only CLI stays small.

FAQ

How do AI agents record their screen?

Agents do not screenshot a desktop. The Clipy CLI launches a headless Chromium, loads the target URL, records the viewport, and uploads it as a normal Clipy recording with a share link. The agent supplies narration as timestamped notes, which become the recording's transcript.

Does the recording have a transcript if nothing was spoken?

Yes. Notes passed with --note or clipy mark are stored as agent narration, and Clipy uses them as the transcript when a recording has no speech. The transcript's source is recorded as agent narration and exposed in the agent-readable context and the API, so its origin is explicit to any agent reading it.

Can Claude Code do this through MCP instead of the CLI?

Yes. The Clipy MCP server (npx -y @clipy/mcp) exposes start_recording, add_marker, stop_recording, and abort_recording alongside the read tools, so agents in MCP-only environments can record without a shell.

Is this free?

Recording, the share link, the transcript, the summary, and the agent-readable context are on Clipy's free tier, and recipients never need an account to watch.

What happens if the agent crashes mid-recording?

The session has a hard maximum duration and auto-stops with an upload of what it captured. An explicit clipy session abort discards the recording entirely.