BugTape blog

What evidence a coding agent needs from a bug report

Q: Can my agent watch the replay?

It doesn't need to. get_repro_context gives it a compact timeline of the failed request, console and errors as text.

A screen video shows a person what happened. A coding agent needs the failed request, console, stack and DOM steps as data. Here's the difference and why it matters.

Page owner: Jaco Veldsman, hi@bugtape.ai. Last checked 22 October 2026.

A screen recording is a great way for a person to show another person a bug. You watch it, you see the spinner that never stops, you get it.

A coding agent doesn't watch. It reads. Give it a video file and it has to guess at the failed request, the status code, the console line and the stack frame that a developer would have pulled from DevTools. Give it those things as data and it can go straight to the code.

That's the whole difference between DOM replay and screen video, and it's why BugTape records the first and not the second.

Screen video vs DOM replay, in plain terms

Screen video is pixels over time. It shows exactly what was on the screen, including things no event log captures well, like a canvas chart or a video player. It's what tools built around a person pressing record are good at.

DOM replay is a list of page events: the page structure, then each change to it, plus mouse moves, scrolls and inputs. BugTape uses rrweb for this. The console rebuilds the page from those events and plays it back, so it looks like a recording, but underneath it's structured data with timestamps.

	Screen video	DOM replay (BugTape)
What it stores	Pixels	Page events (structure, changes, clicks, scrolls, inputs)
Can a person watch it?	Yes	Yes, rebuilt in the console
Can an agent read it as text?	Not directly	The events are data, and BugTape also sends a compact timeline
Masking	Usually blur after capture	Masked in the browser before anything is sent
Canvas, WebGL, video elements	Shown as on screen	Not something BugTape claims to capture

Neither is "better". They answer different questions. If a tester wants to show you what they saw, video is the right tool, and our Jam comparison says so. If the bug happened to a user who left without telling anyone, and you want an agent to fix it, you need the second kind.

What an agent actually needs

When a developer debugs a broken checkout, they look at four things, roughly in this order:

The failed request: method, URL, status, timing.
The console: errors and warnings around the failure.
The stack: which file and line threw.
The steps: what the user clicked and typed before it broke.

A video gives you number 4 well and the others only if they happened to be on screen. A BugTape report carries all four as data. The browser SDK records the page (as DOM events), network requests (URL, status, duration), console output and uncaught errors and unhandled promise rejections. Request and response bodies aren't recorded. See capture semantics for the full list and the switches to turn each recorder off.

Why raw replay isn't the answer either

Pasting thousands of rrweb events into a chat window doesn't help an agent much more than a video does. It's noisy and expensive in tokens.

So BugTape's MCP server gives agents get_repro_context: bug metadata plus a compact timeline of console, network and error events, not raw rrweb. The MCP tools docs describe it as the tool to prefer for fix loops. The full replay is still there for a person in the console.

A typical agent loop looks like this (illustrative; your agent does the code work in your repo):

list_recommended_critical      # start here; bugs a person sent you come first
get_repro_context              # compact timeline: request, console, stack, steps
ack_bug  action: "working"     # team sees it's picked up
# ... fix, open a PR ...
ack_bug  action: "working"  prUrl: "https://..."

A person reviews and merges the PR. Agents don't get the ordinary triage edits (update_bug, merge_bugs, delete_bug, add_comment); those stay with humans.

MCP works on every plan. On Free and pay-as-you-go, each agent read of a bug's captured events costs 2 credits (Free includes 150 a month); on Pro those reads are free. See pricing.

Privacy is easier with events than with pixels

Because DOM replay is data, it can be cleaned up in the browser, before it's sent. With video, whatever was on screen is in the file unless something blurs it.

From BugTape's privacy guide and trust page:

Standard: typed values in inputs, text areas and selects are masked, and emails, card numbers and tokens are scrubbed from recorded text. Mark anything else private with data-bugtape-ignore and it's left out of the replay.
Strict (privacy: 'strict'): every character of page text becomes a solid block before it leaves the browser, so "Anna Smith" is recorded as "▇▇▇▇ ▇▇▇▇▇". Layout, clicks and scrolls stay, so the replay still shows what the user did. URLs lose query strings and request bodies are never kept.
Sealed details (tokenize): marked values leave as placeholders and are sealed with your public key. BugTape stores them but can't open them.
Errors only (disableDomRecording: true): no page replay at all. Errors and failed requests are still reported.

One thing to know: even in strict mode, error messages and stack traces are still sent (after the scrub), because they're what you need to fix the bug. If an error message includes a client name, it carries it. Run the privacy checklist on your own screens before going live.

Data is stored in Sydney, Australia.

What BugTape doesn't do

It doesn't record screen video.
It doesn't record every visit. The SDK keeps a short buffer in browser memory and sends it with a supported failure or a user report.
If the tab crashes or closes, the in-memory buffer is lost. Use a crash-monitoring tool for that.
Fatal iOS crash capture isn't available.
It isn't a session analytics tool. If you want funnels and heatmaps across all visits, look at something like LogRocket; our LogRocket comparison covers where each fits.

Try it

Start free (no card) and add the browser capture.
Connect your agent: Cursor, Claude Code, or read Install BugTape MCP.
Trigger a test failure, then ask your agent to run list_recommended_critical and get_repro_context and open a PR you review.

No account yet? npx -y bugtape --help prints the commands without signing you in, and the demo MCP at https://app.bugtape.ai/demo/mcp needs no sign-in.

FAQ

Is DOM replay the same as a screen recording?

No. It's page events rebuilt into a playback. It looks similar to a person but it's structured data underneath.

Can my agent watch the replay?

It doesn't need to. get_repro_context gives it a compact timeline of the failed request, console and errors as text.

Does BugTape capture canvas or video content?

BugTape doesn't claim to. If what broke lives inside a canvas, a screen recording from the user is the better evidence.

Should I replace my screen-recording tool?

Not if your testers use it to show you bugs. BugTape covers the failures users hit when nobody is recording.