Skip to main content
Someone on your team hits a bug, records a Jam, and drops the link in your issue tracker. Later that day a pull request is open. It carries a video of the fix working. Nobody typed a repro, nobody scrubbed a video, nobody pasted a stack trace into a chat window. Your coding agent started from the link. That is what the Jam CLI is for. A coding agent lives in a terminal, and the CLI puts a Jam there: the console errors, the failed requests, the clicks, and the frames of what was on screen. Then it records the fix and hands back a link. Every read and write in Jam is a command, output is compact text an agent reads cheaply (or JSON with --json), and it runs on macOS, Linux, and Windows. The full command list is in the CLI reference.

​
Quickstart

1

Install the CLI

On Windows, run powershell -c "irm https://native.jam.dev/install.ps1 | iex". See Install for platform notes.
2

Log in

This opens a browser. For CI or WSL, pipe a personal access token into jam auth login --token instead.
3

Read a Jam

You are in. Everything the Jam captured is one command away.
4

Teach your agent

This writes four skill files where your agent reads them (Claude Code, Cursor, Codex, OpenCode). A skill is a short Markdown guide the agent loads when the work matches. jam-cli teaches it to read a Jam. jam-proof teaches it to record one. jam-annotate teaches it to mark up a screenshot before filing it. jam-feedback teaches it to report a Jam command or doc that was wrong. Each file tells the agent to load its instructions from the CLI, so jam upgrade keeps them current. To install into the repo instead of your home directory, see Set up your coding agent.
5

Paste a Jam link

Give your agent a Jam link and a sentence: “Fix this and show me it works.” The agent does the rest.

​
What to say to your agent

Once the skills are installed you talk in English, not in flags. The agent picks the commands. These are the sentences that do the most work. The words that matter are the ones that ask for evidence: show me, prove, record, send me the link. They tell the agent to reach for jam record instead of stopping at a green test.

​
Recipes

Each recipe is one job, start to finish: the sentence to give your agent, and the commands it runs if you would rather run them yourself.

Fix a bug from a Jam link

Read the errors, failed requests, and frames from a Jam, then patch the code.

Prove a fix with a screenshot

File an annotated screenshot that boxes the change and redacts secrets.

Prove a fix with a video

Record the fix running and post the link on the pull request.

Record end-to-end tests

Turn a test run or a CI failure into a Jam with console and network on the timeline.

Record an agent's browser

Capture the console, network, and clicks from any browser an agent drives.

Request Jams from customers

Create a Recording Link per ticket from a script, then read what comes back.

​
Why the CLI over MCP

Jam also has a Model Context Protocol (MCP) server. Both read the same Jam, and every active MCP tool except search and fetch has a matching CLI command that returns the same fields with --json. Deprecated compatibility tools are excluded. Pick MCP when your agent only needs the bug context and you want zero install. Pick the CLI when you want any of these.
  • It records. jam record run records a browser or a window while a check runs and uploads a Jam. MCP reads Jams. It cannot make one. Proof of work only exists on the CLI side.
  • It runs anywhere a shell runs. CI jobs, cron, a Docker container, a script on a colleague’s machine. No MCP client, no per-tool config, one JAM_TOKEN.
  • It works with every agent. Any agent that can run a command can use it, including ones with no MCP support. jam skills install targets Claude Code, Cursor, Codex, and OpenCode, one runtime per run (--target <agent>), and jam agent-context covers any agent they do not.
  • It ships the workflow, not only the tools. jam skills install teaches the agent the order of operations: errors first, frames when logs run out, record the fix, comment the link. An MCP tool list leaves that up to the model.
  • It creates Jams from test runs. Point jam create jam at a Playwright video and trace and the failure becomes a watchable Jam with logs on the timeline. See Record end-to-end tests.
  • It composes. Pipe to jq, branch on exit codes, page with --after, write frames to disk and open them in whatever you like.
  • It keeps context small. Filters like --level error and --status 5xx return only the events that matter, and output lands on disk or in a pipe until the agent asks for it.
  • It is yours to wrap. jam agent-context prints the full command surface as JSON (argument types, flag enums, output shapes), kept in step with the commands by a test. Skip the skills and build your own tool definitions on it: jam agent-context | jq '.commands["get.jam"]'.

​
Next

  • CLI reference lists every command, flag, exit code, and environment variable.
  • Personal access tokens covers scopes, expiration, and rotation for CI.
  • MCP sets up the same bug context in Claude, Cursor, VS Code, and ChatGPT.