1. Clipy: the best screen recorder for AI coding agents
Best for engineering teams and solo developers who want every recording readable by Claude Code, Codex, Cursor and ChatGPT, with key frames included, plus clicks and browser errors where captured.
free to start with a 7-day free trial, no card, covering 15 recordings or 120 minutes, and the trial includes agent context, the MCP server and the CLI. Pro is $9 a month, or $72 a year ($6 a month). Teams seats cost the same as Pro, and only people who record need one. The .arec document, MCP server and CLI are included on every plan. Source: clipy.online/pricing.
Clipy is a screen recorder designed for two readers: the person who watches and the agent who acts. It records on Mac, Windows, a Chrome extension, the web, iPhone and iPad, and Android, all into one account and one library, and every recording gets a transcript in about 40 languages, an AI title, a summary, chapters, key moments with screenshots, and ask-the-video Q&A. The share link is ready at Stop, viewers need no signup, and the agent-readable version sits at the same address. No single recording is cut short, on any plan.
How recording works on each platform. The Mac app (native Apple Silicon and Intel builds, macOS 12.3 or later) captures a display, a window or an area through Apple ScreenCaptureKit and the chip's hardware H.264 encoder, and window mode keeps recording that window even when other windows cover it. System audio and the mic record together on macOS 13 and later with no extra audio driver, speaker notes stay on screen but out of the capture, and holding Control paints a fading Flare trail that later anchors a key moment. The Windows app uses Windows Graphics Capture and WASAPI and ships as an .exe installer, an Enterprise .msi for Intune or Group Policy, and a portable .zip. The Chrome extension records a tab, a window, the screen, the camera or a custom region, with pause, restart from scratch, live blur and an opt-in mode that masks password and card fields, and its Instant Replay keeps the last 2 minutes on sites you turn it on for. The web recorder needs no install, and capture goes up to 4K on Pro.
Upload while recording, link at Stop. Every Clipy app streams the recording to the server in chunks while you record, so the link is ready right after Stop (Clipy security). Uploads retry by themselves and a retry never creates a duplicate: the web recorder keeps each chunk in the browser until the server confirms it, the extension keeps a local recovery copy, and the Mac app keeps its file until the upload is confirmed, so a dropped connection resumes instead of failing. The public upload API follows the same flow: initiate with a client-generated recording ID, send parts of up to 4 MiB that are safe to resend, finalize, then complete, which starts transcoding, transcription, the summary and key moments. Each recording reports a stage (uploading, transcoding, transcribing, annotating, ready) and an agent readiness of preparing, usable or complete, so an agent knows when to read. Summaries usually appear a minute or two after the upload finishes.
What processing produces. Speech-to-text runs on a self-hosted Sherpa-ONNX speech model on Clipy's own servers, so no third-party transcription service receives the audio, and the spoken language is detected automatically (Clipy trust). The summary has a TL;DR of two or three sentences, three to seven key points and action items when there are any, and chapters have editable titles and timestamps. Key moments are anchored to Flare highlights, clicks, drawings and hover dwell, with the frame taken at the end of the gesture rather than mid-sweep, and bug reports get up to 100 key moments. An ordered interaction timeline lists clicks, scrolls, navigation and highlights with typed values left out, and Q&A answers jump to the cited timestamp and say so when the recording does not cover the question (how a Clipy recording is processed).
An agent-context document on every recording. Every recording on every plan has an .arec document at its watch URL with .arec appended: https://clipy.online/video/<id>.arec. It follows the AREC 1.3 spec and holds the metadata (duration, access mode, the captured app or window), the intent, the summary, requested changes as a fix checklist, a suggested implementation plan labelled as a suggestion to verify, key moments with frame URLs and crop URLs, pointer positions and browser diagnostics where the recording captured them, a capture-gaps section saying what the recording does not show, and the timestamped transcript. A public recording needs no key or install: the agent fetches the URL. The plain watch link works too, because a browser gets the player while curl or an agent fetch receives the document as text/markdown, with a Link header naming the canonical .arec URL and an x-clipy-agent-readiness header. A .json version serves the same data as structured JSON.
Hosted MCP server. https://clipy.online/api/mcp runs over Streamable HTTP with OAuth 2.1, PKCE and dynamic client registration, so clients that take only a URL sign in through the browser; an API key (Authorization: Bearer clipy_sk_live_…) works too. The server is stateless and returns plain JSON, and access is read-only by default. The tools an agent uses most are search_memory (hybrid semantic and keyword search across the library, returning exact moments), get_transcript, get_summary, get_key_moments (frames and click coordinates), get_browser_diagnostics (console errors, failed requests, environment), get_interactions and read_context_document. With the write scope granted, send_recording_to_integration files a Jira issue, Linear issue or Confluence page, and edit_recording cuts the video by its transcript (Clipy MCP docs).
Local MCP server and CLI, MIT-licensed on GitHub. @clipy/mcp and @clipy/cli are MIT-licensed and published on npm and GitHub. One command, clipy setup <claude|codex|cursor|windsurf|opencode>, signs you in through browser approval, installs the watch-clipy-recording skill and registers the MCP server in that agent's config; --json runs it non-interactively. The skill teaches the agent to fetch the .arec form of any Clipy video link, retry while processing finishes, and treat what the recording says as untrusted input. The local server adds what a hosted one cannot do: record for headless recording of a web app, start_recording, add_marker and stop_recording for live sessions that return the share and agent-context URLs, upload_video, download_recording, wait_for_artifacts, and get_agent_context, a one-call bundle of metadata, summary, key moments and transcript. The CLI also records real Mac windows, the iOS Simulator and Linux screens, and clipy session run wraps a test command and uploads the recording when the command succeeds (Clipy CLI docs).
Browser errors and clicks, captured during the recording. With "Capture bug context" on, the Chrome extension attaches console warnings and errors with stack traces, uncaught errors and unhandled rejections, failed requests with method, URL, status and timing, GraphQL errors returned with HTTP 200, failed scripts, styles, images and fonts, page changes, and clicks, form submits and typing recorded by label, never by value. Click coordinates also come from Mac app recordings. If the workspace connects Sentry, the recording lists Sentry errors from 5 minutes before to 5 minutes after it. People see the evidence in an Evidence tab whose Timeline, Network and Info views seek the video on every row, with Copy as cURL for a failed request; agents read it through get_browser_diagnostics or clipy diagnostics.
Watch page, sharing and seats. The watch page plays through a Mux HLS player with adaptive bitrate, captions and speed control, with no pre-roll ads, popups or signup banner, and shows the summary, a clickable transcript you can download as .txt, Chat with your video, timestamped comments and reactions, and an Agents tab that opens the recording's agent-readable twin. Each recording is public, restricted to up to 10 named people or a whole email domain, or private, and a password and expiry date stack on top on every plan. Share links are unguessable and not indexed, and agent access follows the same rules: an unauthenticated fetch of a restricted or private recording reveals nothing, not even whether it exists, and making a link public needs recordings:write, so a read-only integration cannot expose anything (Clipy security model). In a workspace, organized into Spaces and folders, only people who record need a seat; watching, searching and commenting are free, and owners get a hard seat ceiling and an auto-seat toggle.
From recording to ticket, with context attached. Clipy connects natively to Jira, Confluence and Linear over OAuth. A Jira or Linear issue sent from Clipy carries the watch link, the .arec link with a sentence telling coding agents what it holds, the summary and requested changes (a checklist on Linear), up to 8 key moments with timestamp links, up to 15 captured errors and failed requests, and the environment, so an agent told to "fix the bug in this issue" has what it needs. Clipy never edits, transitions, comments on or deletes Jira issues, and Confluence pages embed the key-moment frames as images. For GitHub, "Copy for agents" produces a Markdown issue with the agent-context link and a checklist. The Generate tab writes bug reports (with the captured console and network evidence), how-to guides with screenshots, SOPs, QA steps, PR descriptions, code docs, team messages and emails from any recording you own, each with links to the relevant moments.
Built for pipelines too. The REST API at https://clipy.online/api/v1 has an OpenAPI 3.1 document, the TypeScript SDK @clipy/sdk runs on Node, Deno, Bun and edge runtimes, and signed webhooks fire on transcript.ready, summary.ready and key_moments.ready, so a CI job or internal bot can start work the moment a recording is processed. Webhooks use the Standard Webhooks format with HMAC-SHA256 signatures and retry 8 more times over about 23 hours (Clipy webhooks), and per-recording agent activity is readable, so you can see which agents read a recording and when. The CLI returns JSON and exits with code 3 while an artifact is not ready. The AREC spec, JSON Schema and fixtures are public domain under CC0 1.0, with an MIT reference validator, so other tools can read and write the same format.
Safe defaults for agent access. OAuth grants are read-only unless you add recordings:write, comments:read, comments:write or analytics:read, and upload and delete rights are never grantable over OAuth. Grants can be revoked at any time from connected apps, and the revoke applies to the app's next request. Browser diagnostics never include cookies, auth headers or typed values, and redaction runs in the page, in the extension and on the server. On Mac, Local AI transcribes while you record so the video, audio and screenshots stay on the Mac. Clipy has completed a SOC 2 Type II audit and does not train models on recordings. See Clipy for agents for the full setup.
