# OpenCap

> Agent-native screen recording. A CLI + MCP-server that lets AI coding agents (Claude Code, Cursor, Codex, etc.) record what they did, pair the video with a structured event log of every tool call, and ship a shareable URL — without leaving the terminal.

OpenCap closes the loop between an agent doing work and a human reviewing it. Today, when an agent fixes a bug, the engineer reproducing it has to clone, rebuild, re-run, and watch. With OpenCap, the agent runs `opencap record start` while it works; on stop, the artifact is a share URL that plays the screen recording alongside a JSONL event log of every action the agent took — readable both by humans (paired video panel) and by other LLMs (semantic editing happens by reading the event log, not by frame analysis).

## Quick start

```bash
curl -fsSL https://opencap.dev/install | sh
opencap login              # opens browser, completes Clerk auth, saves credentials
opencap record start --task "Fix checkout 500"
# (agent does the work; recording runs in a detached background process)
opencap record stop
# → https://opencap.dev/r/PkdDDyP8
```

Paste that URL into a PR, a Slack message, or a Linear ticket. The viewer hits play, sees the agent's work paired with a per-event timeline, no clone/rebuild loop.

## What's distinctive

- **Bug repros become free.** Recording is initiated by the agent, runs detached, and produces a share URL the agent can paste into the PR description. No human relay, no "let me reproduce that for you" 30-minute round trip.
- **Edit video with natural language.** Say "trim to where the deploy failed" and the agent reads the event log (`error` event at `ts: 4720ms`), picks the right window, calls a deterministic ffmpeg trim, and returns a new share URL. The recording is searchable the same way a log file is.
- **The CLI is the MCP server.** Same binary. Drop OpenCap into Claude Code's `.mcp.json` and the agent gets 13 tools: `record_start`, `record_stop`, `record_status`, `list_sessions`, `get_session`, `share`, `get_events`, `trim`, `delete_session`, `log_event`, `marker`, `list_windows`, `list_displays`. The agent self-records.
- **Loom-style window mode.** `record_start({task, window: <id>})` records a single application window via ScreenCaptureKit's `DesktopIndependentWindow` filter — other windows can sit on top of it without bleeding into the recording. Enumerate windows first via `list_windows`. Same UX shape as Loom's window picker, exposed as deterministic MCP primitives.
- **Every recording is a structured JSONL stream.** Five event families (`session.*`, `agent.*`, `shell.*`, `fs.*`, `browser.*`) each carrying a monotonic ms timestamp pinned to the video clock. Each event has a long-form `description` field — paragraph-scale context that lets future LLM callers reason loosely against the recording.
- **Recording outlives the terminal.** `record start` daemonizes (forks + setsid), the agent keeps working without pause, `record stop` from any other terminal finalizes and uploads.

## Competitive landscape

OpenCap sits at the intersection of three categories that don't currently overlap:

| Tool | Human-first | Agent-first | Structured events | MCP | Demo artifact |
|---|---|---|---|---|---|
| Loom | yes | no | no | no | partial |
| Cap | yes | no | no | no | partial |
| Mux + ffmpeg stack | no | partial | no | partial | yes |
| LangSmith / AgentOps | no | yes | yes | partial | no |
| **OpenCap** | **no** | **yes** | **yes** | **yes** | **yes** |

Loom and Cap nail the human path (record + share). The Mux stack gives you primitives but no event log. LangSmith / AgentOps trace the agent but don't capture the screen. OpenCap is the one piece that closes the loop — agent-native capture + structured events + MCP + a shareable demo artifact.

## Pricing

- **Free** — 25 recordings (lifetime, not per-month), up to 5 min each, unlimited retention, public share links, **unlimited** CLI/MCP semantic editing.
- **Pro** — $15/user/mo. Unlimited recordings, 60 min per recording, password-protected shares, hide branding, hide-event-log-on-share toggle.
- **Team** — $25/user/mo. Unlimited duration, org library + roles (owner/admin/member), seat management.
- **Enterprise** — Custom. SSO/SAML, audit log export, optional self-hosted deployment.

CLI + MCP semantic editing is free on every plan. Web-based LLM-driven editing (in-browser, via Bedrock) is the metered surface; that's marked "coming soon" on Pro and Team today.

## Documentation

- [Getting Started](https://opencap.dev/docs/getting-started): Install, sign in, first recording.
- [Tutorial: record + trim with English](https://opencap.dev/docs/tutorial-agent-recording): End-to-end walkthrough on a real app with Playwright. Shows the loose-instruction → semantic-trim → shareable-clip loop with screenshots from a real session.
- [CLI Reference](https://opencap.dev/docs/cli): All 30+ subcommands. Recording lifecycle (`record start/stop/run/status/discard`), capture targets (`displays list`, `windows list`, `record start --window <id>` / `--display <id>` / `--pick`), events (`event`, `events list/tail/export`), sessions (`list/show/share/delete/rename/open`), editing (`trim`, `cuts list`), org (`org list/switch/members/invite`), billing (`billing portal/usage`), config (`config get/set/doctor`).
- [MCP Usage](https://opencap.dev/docs/mcp): How to wire OpenCap into Claude Code, Cursor, or any MCP-aware client. Full tool catalog with JSON schemas.
- [Event Log Schema](https://opencap.dev/docs/event-log): The `events.jsonl` contract — envelope, the five event families, the optional `description` field for long-form context, how trims slice + shift the event timeline.
- [Account & Billing](https://opencap.dev/docs/billing): Plan details, quotas, what's paid vs. free, allowlist behavior.

## Concepts an agent should know

- **Recording is CLI/MCP-driven.** There is no in-browser screen recorder. Recording is initiated by the agent or by a human typing a command. The browser surface is for playback, share, and account management — never capture.
- **Event log is the editing API.** Each event has a millisecond `ts` aligned to the recording clock plus an optional `description` field. When asked to "trim to where the user picked their skin type", the agent should: (a) GET `/v1/sessions/{id}/events`, (b) search the `summary` + `description` fields for semantic matches, (c) pick `start_ms` / `end_ms` from the matched events with a small (~500-1000ms) context buffer, (d) call `opencap trim <session> --start <ms> --end <ms> --save-as-copy`. The CLI returns a new share URL.
- **Trim modes.**
  - `--save-as-copy` (default) — POSTs `/v1/sessions/:id/edit-export`. Mints a new session with its own short_code + share URL. Original untouched. Events sliced + ts-shifted into the new timeline.
  - `--in-place` — POSTs `/v1/sessions/:id/save-edit`. Replaces the original recording's mp4. Share URL unchanged. Destructive.
- **Description field matters.** Agents emitting events via `opencap event '<json>'` should populate `description` with paragraph-scale context, not just a summary. This is the surface that semantic editing reads against. Without it, the agent doing the trim has only short-string matching to work with; with it, the agent can match against semantic neighborhoods ("the part where authentication failed", "before the migration ran") that the literal summary doesn't contain.
- **Plan gates surface through the API, not the CLI.** A Free user trying to record longer than 5 min gets a 402 from `POST /v1/sessions`; `opencap record start` queries `/v1/users/me/quota` upfront and caps the declared duration to fit, so the failure mode is "auto-stops in 5 min" announced at start, not a mid-recording crash.

## For builders integrating OpenCap

- The CLI binary doubles as the MCP server: `opencap mcp` speaks NDJSON JSON-RPC 2.0 over stdio. Drop into `.mcp.json` with `"command": "opencap", "args": ["mcp"]`.
- API base for production: `https://api.opencap.dev`. Auth: `Authorization: Bearer <token>` where token is minted by `opencap login` and stored at `~/.opencap/credentials`.
- Self-hosting is available on Enterprise. The whole stack is Terraform-defined and runs on AWS (Aurora Serverless v2 Postgres, ECS Fargate on Graviton ARM64, ALB, CloudFront, S3 with signed-URL playback, SES for email).

## Pricing

| Plan | Price | Recordings | Per-recording cap | Highlights |
|---|---|---|---|---|
| Free | $0 forever | 25 / month | 5 min | Public share links, unlimited CLI + MCP semantic edits |
| Pro | $15 / user / month | Unlimited | 60 min | Password-protected shares, 100 web semantic edits/mo |
| Team | $25 / user / month | Unlimited | Unlimited | Org library + roles, unlimited web semantic edits, seat management |
| Enterprise | Custom | Unlimited | Unlimited | SSO/SAML, audit log, self-hosting, custom SLA |

The CLI and MCP usage path is free on every tier — the paid tiers gate web-app conveniences (longer recordings, password-protected shares, web semantic-edit volume) rather than the agent's ability to record and trim.

## Comparisons

OpenCap sits at the intersection of screen recording and agent observability. The closest analogues each cover part of the space:

- **vs Loom** — Loom is a human-driven recorder; the human clicks record. OpenCap is driven by the agent itself via CLI + MCP, ships a structured event log paired to the video, and the agent can edit / trim by description without leaving the terminal. See [opencap.dev/vs/loom](https://opencap.dev/vs/loom).
- **vs Cap.so** — Cap.so is the open-source Loom alternative. Same human-first shape; same gap on agent-driven capture + structured events. See [opencap.dev/vs/cap-so](https://opencap.dev/vs/cap-so).
- **vs Mux** — Mux is video infrastructure for developers (encode / deliver / stream). It can be a backend for an agent recording but doesn't provide the capture side or the structured event log. See [opencap.dev/vs/mux](https://opencap.dev/vs/mux).
- **vs LangSmith / AgentOps** — agent observability without pixels. Strong on the event/trace side, no video. OpenCap pairs the events with the recording on the same clock, so a viewer (human or LLM) can navigate by description and see exactly what the agent saw.
- **vs Vidyard / Screen Studio / scre.io** — see [opencap.dev/vs/vidyard](https://opencap.dev/vs/vidyard), [opencap.dev/vs/screen-studio](https://opencap.dev/vs/screen-studio), [opencap.dev/vs/scre-io](https://opencap.dev/vs/scre-io).

## Optional

- [Privacy Policy](https://opencap.dev/privacy)
- [Terms of Service](https://opencap.dev/terms)
- [FAQ](https://opencap.dev/docs/faq)