All jobs

Triage Customers' Jam Bug Recordings Into Reproducible Reports

A SaaS support team's agent reads each new Jam a customer records, pulls the failing request and console error, and writes a report engineering can reproduce.

Run this on RushOpens the console with this prompt ready to send. Connect Jam there first.

What the agent does

This is for the support team of a SaaS company that asks customers to show a bug instead of describing it. Support sends the customer a Jam Recording Link; the customer records their screen, and Jam captures the console, the network requests and their clicks alongside the video. The recordings pile up in a folder, and a support engineer opens each one, scrubs the video, and copies the failing request into a ticket. The agent does that first pass. It connects through Jam's remote MCP server, once, with POST /me/connections {"type": "mcp", "name": "jam", "url": "https://mcp.jam.dev/mcp", "auth": {"mode": "oauth"}}, approved by a support lead on Jam's own sign-in page. Jam's MCP server follows that person's existing Jam permissions and grants no new access.

Each run lists the Recording Link's newest Jams with listRecordingLinkJams and skips any it has already reported, by the ids in the previous report the prompt names. For each new Jam it calls getDetails for the author, what happened and the timeline, getConsoleLogs filtered to errors, and getNetworkRequests filtered to failed statuses, which by default include the bodies of error responses. getUserEvents gives the customer's clicks, inputs and page changes in plain words, which become the steps to reproduce.

Where the customer spoke while recording, getVideoTranscript gives what they said with timestamps, and the agent quotes the sentence that says what they expected. getMetadata returns whatever the company's app set through Jam's jam.metadata() call, such as the account id, the app version and feature flags, and the agent copies those into the report, because "fails on version 4.12 with the new editor flag" is most of a diagnosis. For a moment the transcript and logs do not explain, getFrames returns screen images at given timestamps.

The agent then sorts. A failed request with a 5xx from the company's own API goes to the top. A 4xx that matches what the customer was doing (a permission error after a role change) is marked as likely expected behavior for support to explain. A Jam with no errors at all is marked as a possible usability problem rather than a bug. It compares new Jams with each other and calls out ones with the same failing endpoint and error. It writes nothing back to Jam: no comments, no folder moves, no links.

Start it with one API call

POST https://api.phoenix.so/o/{org}/sessions with this body:

{
  "agent": "claude",
  "input": "Triage new Jams recorded through our Recording Link named 'Customer bug reports'. Find it with listRecordingLinks, then list its Jams with listRecordingLinkJams. Skip these ids, already reported: 7f2c1a, 9b44de. For each new Jam call getDetails, getConsoleLogs (errors only), getNetworkRequests (failed statuses, with error bodies), getUserEvents and getMetadata; call getVideoTranscript when it is a video Jam with audio. Write one section per Jam: title, Jam link, account id and app version from metadata, steps to reproduce from the user events, expected vs actual (quote the customer if they said it), the failing request (method, path, status, the error body's message) and the console error. Classify each as server error, expected 4xx, client error, or no error captured, and group Jams that share a failing endpoint and error. Write triage.md, server errors first, and triage.json with the same fields. Do not comment on, move, edit or delete any Jam.",
  "connections": [
    "jam"
  ]
}
  1. Get an API key. In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
  2. Send the request. POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
  3. Read what came back. Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

What comes back

Two files come back as artifacts on the session. triage.md has one section per Jam, server errors first, each with the steps, the failing request and its error message, and the customer's own words where there were any, plus a short list of groups where several customers hit the same endpoint. triage.json holds the same fields so the support team's own tooling can open one ticket per group in its tracker. The session's result is the count per class and the groups.

A support engineer reads it before anything reaches engineering. The classification is a first sort, not a verdict: an "expected 4xx" may still be a bug in how the app checks permissions, and "no error captured" can mean the problem was on the customer's network. Each section links back to the Jam, so the engineer confirms the request and the moment in the video in a minute instead of finding them from scratch.

Network bodies and console logs can contain customer data. The report copies error messages and paths, not whole bodies, and the transcript holds what the tools returned, so keep the session with the support team and redact anything you paste into a public tracker.

Run it on every weekday, twice a day

In the console, a Project automation with a schedule trigger (0 9,14 * * 1-5 with the team's timezone) can run a saved agent that names the Jam connection and holds these instructions. To skip Jams already reported, the prompt can ask for those recorded since the previous run's time, or the support team's handler can start each run with POST /o/{org}/sessions and the last report's ids in input.

With a webhook URL on the API key, each run.completed reaches that handler with the result, and it can open the tickets from triage.json without anyone copying fields by hand.

The use case this job follows, with its automation and trigger: Produce a report or file, no repo.

Why run it on Rush?

Jam already captures everything; the work is reading it. A script can download network logs, but it cannot watch a customer's clicks, hear them say "I expected the invoice to show the discount", and decide that a 403 after a role change is not the same bug as a 500 from the billing endpoint. The agent reads each recording the way a support engineer would and leaves the engineer the decision.

The Jam sign-in stays in Rush's connection, limited to what that support lead can see in Jam. Each run has its own computer, its own record of every tool call and its cost, and when a report is wrong the transcript shows which log line the agent read. On a busy day several runs can work through recordings at once without anyone's laptop open.

Frequently asked questions

Does the customer need a Jam account to record?

A Recording Link lets someone record a Jam into your workspace from the link, which is why support teams send it to customers. Check Jam's own docs for the current rules on who can record through a link on your plan.

What if the Jam is an Instant Replay or a screenshot?

Jam's video tools return nothing for Instant Replay Jams, and screenshots come from getScreenshots instead. The agent still reads console, network and user events where Jam captured them, and says in the section which kind of Jam it was.

Can it file the tickets itself?

This agent does not, so a person reads the triage first. A run that also names your tracker's connection could draft tickets, but keeping the create step in your own handler means a misread recording never becomes a ticket on its own.

How does it get the app version and account id?

Only if your app sets them with Jam's jam.metadata() SDK call; getMetadata returns those key-value pairs. Without it, the agent reads what the page URL and requests show and says the version is unknown.

More Jam jobs

More jobs like this: Produce a report or file, no repo

Keep reading