FOR CURSOR
Screen Recorder for Cursor
Clipy is the agent-readable screen recorder for Cursor. Record the issue once and hand Cursor the share link — via the Clipy skill or MCP server, Cursor reads the recording as structured context: summary, key moments with frames, click targets, cursor paths, and the transcript.
The whole loop in under a minute. Tap for sound.
One recorder, every workflow
Clipy is for every use case
Same loop, whatever your team does: record once, share one link, and an AI agent reads it and acts. Switch roles to see it play out.
Agent-ready fast
Chunks stream to the server while you record, so the moment you stop the summary, key-moment frames, and transcript are already building — a short clip is agent-ready in seconds.
Our own pipeline
On-device transcription and key-moment fusion we built ourselves — not a third-party API bolted on — tuned for speed and for the exact context an agent needs to act.
Fastest agent loop
The fastest agent-ready screen recorder: one link a teammate watches and an AI agent reads. No ticket, no repro write-up, no re-explaining.
Describing a bug in the Composer is lossy
You hit a UI bug in the app you’re building, switch to Cursor, and start typing it into the Composer. “The filter dropdown doesn’t close when I click outside it.” Cursor guesses which dropdown, in which component, across a repo it has indexed but never watched you use. You paste a screenshot — one static frame, no click, no order of steps — and the agent still asks which element you meant. The bug lived inside your editor the whole time. The description is where it got lost.
How it works
- 1
Record the issue
Capture the broken flow with your voice over it. The click you make is the click the agent gets — with coordinates.
- 2
Hand Cursor the link
Connect the Clipy MCP server or use the skill convention; Cursor pulls the recording's structured context in one call.
- 3
Let the agent act
Cursor maps the frames to your components, reproduces the failure, and proposes the fix in your working tree.
Connect Clipy to Cursor once
Clipy is the agent-readable screen recorder built for the editor. Add the Clipy MCP server to Cursor a single time — npx -y @clipy/mcp in your MCP config — and Cursor can pull any recording in your library as structured context with one tool call. For a one-off public link you don’t even need that: every clipy.online/video/<id> link has a markdown twin the agent can fetch directly, no API key.
Reach for MCP when the recording is private or you want Cursor to search your library by what was said or shown. Reach for the plain link when you just want to drop one recording into a Composer session. Either path hands the agent the same document — an AI summary, key moments, and the full timestamped transcript.
MCP server
Add npx -y @clipy/mcp to Cursor’s MCP config. Cursor gets tool-call access to your whole library — private recordings included — and can search it by content.
Public link
Paste a clipy.online/video link into the Composer. Cursor fetches its .md twin — the same summary, key moments, and transcript — with no key and no setup.
Frames and click targets, mapped to your open files
Cursor can’t watch an MP4 — no agent can. So Clipy translates the recording into the two formats an agent does read: text and images. Server-side, its proprietary on-device pipeline fuses the transcript with key moments — timestamped frames of exactly what you pointed at or clicked.
That context arrives in an editor that already has your repo indexed. Each key moment carries the extracted frame as a real image and, on Mac-app and Chrome-extension recordings, the actual click coordinates. When your narration says “this Save button,” Cursor has the frame and the coordinate to resolve “this” to a component in your open workspace — not an inference from a lone screenshot.
“This button” becomes a file
A click target plus the frame lets Cursor match the element you clicked to the component that renders it, then open the file.
Narration becomes intent
The timestamped transcript tells Cursor what you were trying to do at each frame, so the change targets the behavior you described, not the symptom it guessed.
The fix lands in your working tree
Because Cursor runs inside the editor, the recording turns straight into a proposed change. Cursor reproduces the failure against your real files, writes the fix, and puts the diff in Composer to review inline — accept it, tweak it, or send it back with a follow-up. No copying a code block out of a chat window, no re-pasting the bug into a fresh session.
The recording stays the source of truth. If the first pass isn’t right, the frames and transcript are still there for the next one — you don’t re-record and you don’t re-explain.
One recording, from bug to in-tree diff
Your settings modal has a toggle that flips in the UI but doesn’t survive a reload. You record fifteen seconds: open Settings, flip “Email notifications,” hit Save, reload, watch it snap back off — narrating each step. You stop, and within seconds the recording is agent-readable. In Cursor you ask the agent to fix it and point at the recording; through the Clipy MCP server it pulls the document in one call. It reads the key moment where you clicked Save, uses the click target to land on SettingsModal.tsx, and finds the handler updates local state but never calls the mutation. It proposes the diff in Composer — the missing await savePreferences() — and you read it against your own file before applying.
Set up once, use in every repo
Add the Clipy MCP server to Cursor a single time. After that, any project you open can pull recordings as context — no per-project wiring, no re-auth.
Context meets an indexed codebase
Cursor already knows your files. Clipy gives it the frames and clicks; the agent maps them to the components it has indexed, inside the editor you’re already in.
Deixis resolves to a component
“This one,” “right here,” “that button” — spoken pointers that die in a text ticket. With the frame and click coordinate, Cursor knows which element you meant.
Review the fix in-editor
The change arrives as a diff in your working tree, not a snippet to copy. You review it inline in Composer and apply — the whole loop stays inside Cursor.
Composer chat vs an agent-readable recording
| The old way | With an agent-readable recording | |
|---|---|---|
| Handing over the bug | Type a description into the Composer and hope Cursor pictures the right screen | Record it once; Cursor pulls the summary, frames, and transcript in one MCP call |
| Which element | “The dropdown” — Cursor guesses across the components it has indexed | The click target and frame resolve “this” to the exact element and its file |
| Reproducing the failure | Cursor works from your prose and misses the order of steps | Timestamped key moments give the agent the real sequence you performed |
| Getting the fix | Copy a code block out of chat and paste it into your file | The diff is proposed in Composer against your working tree, ready to apply |
| A second attempt | Re-describe the bug in a fresh chat and hope it lands this time | The recording is still there — the agent re-reads it, you don’t re-explain |
Common questions
How do I connect Clipy to Cursor?
Add the Clipy MCP server to Cursor’s MCP config — npx -y @clipy/mcp — and Cursor gets tool-call access to your recordings, private ones included. For a single public recording you can skip setup entirely and paste the clipy.online/video link; the agent fetches its markdown twin directly.
MCP server or the public link — which should I use in Cursor?
Use the MCP server when the recording is private or you want Cursor to search your library. Use the plain public link for a quick one-off — it resolves to the same .md document with no API key. Both hand Cursor the same summary, key moments, and transcript.
Can Cursor see the actual frames from the recording?
Yes. Each key moment includes the extracted video frame as a real image, so Cursor’s vision reads what was on screen at that instant. On Mac-app and Chrome-extension recordings it also gets the click coordinates, which is how “this button” resolves to a specific element.
How does Cursor map the recording to my code?
Cursor already has your repo indexed. Clipy supplies the frame and, where captured, the click target for each key moment; the agent matches the clicked element to the component that renders it and opens the file. The transcript tells it what behavior you expected there.
Does the fix show up in my working tree?
That part is Cursor doing what Cursor does — running in the editor, it proposes the change as an in-tree diff in Composer. Clipy’s job is to give it accurate context so that diff is grounded in the frames and clicks you actually recorded, not a guess from a screenshot.
How fast is a recording ready for Cursor?
Chunks stream to the server while you record, so a short clip is agent-ready within seconds of hitting stop — best case under ten seconds. Clipy is built to be the fastest agent-ready screen recorder, so the loop from bug to Composer stays tight.
Can Cursor read a private recording?
Yes, through the Clipy MCP server, which authenticates with your account. Public links work with no key; private recordings and library search go through MCP (@clipy/mcp).
Is Clipy free for this?
Yes. Recording, the share links, transcripts, summaries, key moments, the markdown documents, and the MCP server are all free. A teammate who opens the same link just watches the video, with no sign-up.