# Snag

> Snag is a bug-capture and AI-fix platform: your users report a bug in one click, and Snag captures a session replay, console, network activity, and repro steps — masked in the browser before anything uploads. Reports route into Jira and GitHub with full context, and a coding agent (yours, over Snag's MCP server, or Snag's built-in sandboxed agent) reads the captured evidence and opens a fix pull request for a human to review. Snag never auto-merges and never trains models on customer code. Pricing is flat per workspace with unlimited reporters and members: a free tier, a flat capture plan, and fix plans metered per fix-run. Every current price is listed on https://snag.ac/ and in llms-full.txt, generated from the live pricing API.

## Pages

- [Snag the bug, ship the fix.](https://snag.ac/): Your users catch a bug in one click. Snag captures the replay, console, and network, files it into Jira + GitHub, and lets a coding agent open the fix PR.
- [Why Snag](https://snag.ac/why): Bug reporting tools meter the wrong thing: seats. Every reporter you add raises the bill, so teams ration who's allowed to file bugs. Snag never counts seats: unlimited capture + MCP is one flat $29/mo for the whole workspace — about what Jam charges for two people. Fix plans add the AI agent that opens pull requests, metered per fix, reviewed by a human.
- [How it works](https://snag.ac/how): Every capture — replay, console, network, and repro steps, masked in-browser — lands in your tracker the same way. The only choice is how people start one: an always-on pill, a quiet launcher in production, or your own link.
- [The agent](https://snag.ac/agent): Every fix arrives as a pull request for you to approve — the agent never touches your live site. Here's exactly what happens between "someone hit a bug" and "there's a PR waiting."
- [MCP](https://snag.ac/mcp): Point any MCP-capable coding agent — Claude Code, Cursor, Windsurf, VS Code, Codex, Gemini CLI — at Snag's MCP server and it reads each bug's captured context straight from your workspace: replay, console, network, repro steps. Your agent opens the fix PR in your repo. Snag never touches your code.
- [Glossary](https://snag.ac/glossary): Short definitions for the terms that come up around bug reporting, session replay and AI fixes — written to be useful whether or not you ever use Snag.
- [Security](https://snag.ac/security): Snag sees your users' bug reports and, if you turn the agent on, a disposable copy of your code. Here is exactly what happens to both.
- [About](https://snag.ac/about): Ten years as a product manager, now building. Snag is the tool I kept wishing existed — twice, for two different reasons.

## Comparisons and use cases

- [Compare](https://snag.ac/compare): Head-to-head with every bug-reporting tool we are asked about, sourced and dated.
- [Snag vs BugHerd](https://snag.ac/compare/bugherd): BugHerd is built for agencies, and it is good at that job. A client drops a pin on the exact element, and the comment arrives with the browser, operating system and screen resolution attached. What Snag aims at is one step downstream, the engineer who picks the ticket up: the replay, the console and the network they need, then a sandboxed fix run that ends in a pull request with a repro test that fails before the fix and passes after.
- [Snag vs Capture for Jira](https://snag.ac/compare/capture-for-jira): Capture for Jira is SmartBear's exploratory-testing tool for teams working inside Jira. Capture for Jira records screenshots and screen video in the browser, annotates them with audio and visual tools, and runs shared testing sessions anyone on the team can join. SmartBear describes Capture for Jira on their product page in the present tense, so this is a straight comparison and not a migration guide. What separates the two is the model rather than the feature list. The Capture for Jira licence follows your Jira user count; Snag charges a flat workspace fee, takes reports from end users who have no licence at all, and finishes the job by opening a pull request.
- [Snag vs Disbug](https://snag.ac/compare/disbug): Disbug is an evidence pipe for AI coding agents, and an unusually well-built one: the extension collects the screenshot, the DOM selector, console errors, failed network requests, the user-event trail, browser metadata and local storage in the background, and an MCP server lets your agent pull one field at a time instead of flooding its context window. Snag collects the same kind of evidence and then keeps going. A sandboxed fix run reproduces the bug in a disposable copy of your repo, writes a repro test that fails before the fix and passes after, and opens a pull request for a person to review.
- [Snag vs IssueCapture](https://snag.ac/compare/issuecapture): IssueCapture is a Jira Cloud bug-reporting widget with an unusually deep AI layer on top: a screenshot the reporter annotates, the console logs, the failed network requests and the environment details, and then triage by priority, urgency and ROI, smart summaries and auto-categorization. Snag captures the same kind of evidence, adds a session replay recorded only when somebody files a report, and keeps going. A sandboxed fix run reproduces the bug in a disposable copy of your repo, writes a repro test that fails before the fix and passes after, and opens a pull request for a person to review.
- [Snag vs Jam](https://snag.ac/compare/jam): Jam made one-click bug capture the standard, and we'll say it plainly: their recordings are excellent. But Jam's job ends when the report lands — by design, it hands the context to a coding agent you wire up and run yourself. Snag starts the same way — replay, console, network, PII masked in-browser — and keeps going: triage, a sandboxed reproduction, and a fix PR with a repro test that fails before the fix and passes after.
- [Snag vs Issue Collector](https://snag.ac/compare/jira-issue-collector): Went looking for the Jira Issue Collector and found a page about a work item collector instead? Nothing has been taken away from you: Atlassian replaced the word issue with the phrase work item across Jira, and the Cloud page describing the Issue Collector still lives at a URL that reads use-the-issue-collector. The Issue Collector is documented on Cloud and in the Jira Data Center administration guide alike. So this is a straight comparison rather than a migration guide, and the difference between the two is not whether they exist — it is how much of a bug each one carries, and what happens to the ticket afterwards.
- [Snag vs Marker.io](https://snag.ac/compare/marker-io): Marker.io is a strong website-feedback widget: annotate the screenshot, send, and on their Team tier the report arrives with a detailed log of all network activity attached. Their MCP page is refreshingly direct about what comes next — an AI agent pulls the context and opens the pull request, and that agent is yours to choose and run. The step Snag adds is the fix run itself: the same class of evidence is captured, then reproduced in a disposable copy of your repository, and the run ends in a pull request with a repro test that fails before the fix and passes after.
- [Snag vs Pastel](https://snag.ac/compare/pastel): Pastel is a review canvas: point it at a live web page or a video, share the link, and anyone can leave in-line comments on top of it without making an account. Snag works the other way round. The snippet already lives on the site, so a report is filed from the screen the problem happened on, and it leaves the browser as a session replay with the console and the network beside it. Personal data is masked in the browser before anything uploads — inputs are never recorded. That becomes a ticket in Jira or GitHub, and the same bundle is what a sandboxed fix run reads before it opens a pull request with a repro test that fails before the fix and passes after.
- [Snag vs ruttl](https://snag.ac/compare/ruttl): ruttl is a website review tool and an unusually literal one: comments are pinned to the pixel on a live page, and text, alignment and imagery can be changed in the browser while you look at them. Snag works at the other end of that. Nothing on the live page is touched: what gets recorded is what the browser did, the DOM played back, with the console and the failed requests beside it, filed as a ticket in Jira or GitHub. Personal data is masked in the browser before anything uploads — inputs are never recorded. The change itself turns up in the repository, as a pull request carrying a repro test that fails before the fix and passes after.
- [Snag vs Userback](https://snag.ac/compare/userback): Userback is a feedback tool. A widget sits in your app, arrows and shapes go on the screenshot, an AI layer sorts what arrives into bugs, ideas or feedback and writes the titles, and an MCP server lets a coding agent write back through it. Snag collects one kind of thing and takes it further. A click records the session replay, the console and the network — on every plan, with no developer tier to reach first — masks personal data in the browser, and files the report into Jira or GitHub. A sandboxed fix run reads that same recording and comes back with a pull request and a test that fails before the change and passes after it.
- [Snag vs Usersnap](https://snag.ac/compare/usersnap): Usersnap is a feedback platform: a widget on your site, five annotation tools on the screenshot, and an AI layer that summarises and labels what comes in. What Snag does is narrower, and it goes one step further. One capture records the session replay, the console and the network, masks personal data in the browser, and files the report into Jira or GitHub. A sandboxed fix run then opens a pull request carrying a repro test that fails before the fix and passes after.
- [Snag vs Ybug](https://snag.ac/compare/ybug): Ybug is a capture-and-route tool, and a good one: marked-up screenshots, console and network logs on the plans that carry them, and a route into Jira, Asana, Slack, ClickUp and 25+ other destinations plus Zapier. Snag starts in the same place and does not stop there. The capture is a session replay rebuilt from the DOM, with the console and the network beside it, on every plan, masked in the browser and filed into Jira or GitHub. A sandboxed fix run then takes that recording, reproduces the failure and opens a pull request with a test that fails without the change and passes with it.
- [Alternatives](https://snag.ac/alternatives): What carries over and what you give up, tool by tool.
- [Switching from BugHerd](https://snag.ac/bugherd-alternative): No per-member add-on, and no seat count of any kind whoever files the bug. Your first 5 fixes are on us.
- [Switching from Disbug](https://snag.ac/disbug-alternative): One flat workspace price, unlimited members whether they file bugs or fix them, and your first 5 fixes are on us. Already happy with your own coding agent? The MCP server is included from the Capture plan up.
- [Switching from IssueCapture](https://snag.ac/issuecapture-alternative): One flat workspace price, unlimited members whether they file bugs or fix them, and your first 5 fixes are on us. Jira stays where it is, and GitHub joins it.
- [Switching from Jam](https://snag.ac/jam-alternative): Unlimited members on every plan, and your first 5 fixes are on us. If you love your agent, keep it — the MCP server is included.
- [Switching from Marker.io](https://snag.ac/marker-io-alternative): One flat price per workspace, so the invoice does not change as the team grows. Keep the agent you already use: the MCP server is included, and it changes nothing of yours.
- [Switching from Pastel](https://snag.ac/pastel-alternative): Snag is not a review canvas and does not try to be one. It is where the defects go once the sign-off is done: one snippet on the site, a replay with the console and the network in every report, and a fix run that answers in a pull request. One flat price covers everybody who touches it, and your first 5 fixes are on us.
- [Switching from ruttl](https://snag.ac/ruttl-alternative): The bill stops counting people. One flat workspace price with unlimited members — designers, testers, the contractor who is here for a fortnight — and your first 5 fixes are on us.
- [Switching from Userback](https://snag.ac/userback-alternative): The replay, the console and the network are recorded on every plan here, free one included, and what you capture stays readable. Nobody is counted as a seat, and your first 5 fixes are on us.
- [Switching from Usersnap](https://snag.ac/usersnap-alternative): Unlimited people on every plan, whether they report bugs or fix them, and the first 5 fixes are on us. Bringing your own coding agent? The MCP server is included.
- [Switching from Ybug](https://snag.ac/ybug-alternative): No ceiling on projects and unlimited members on every plan, and your first 5 fixes are on us. Reports still go to Jira or GitHub — what is new is what happens once they land.
- [Use cases](https://snag.ac/for): How the capture-to-pull-request loop lands for different kinds of team.
- [Snag for agencies](https://snag.ac/for/agencies): A studio is answerable for sites whose users it does not employ. The bug is found by a client's marketing manager or a client's customer, described in an email, and reproduced by whoever on your side has the fewest deadlines that week. Snag lets the person who hit it hand over the session instead.
- [Snag for inherited codebases](https://snag.ac/for/inherited-codebases): On code you inherited, the expensive part of a bug is not the change. It is finding the place the change belongs, in a system whose reasons left with the people who had them.
- [Snag for internal tools](https://snag.ac/for/internal-tools): The people who use an internal tool are close enough to tell you about a fault in passing, and that closeness is exactly why it is never filed. By the time it comes up they have found a way around it, and the workaround has become the process.
- [Snag for QA teams](https://snag.ac/for/qa-teams): A tester halfway through a regression pass writes a better report than any tool will. What they cannot hand over is the request that returned an error, the exception that never reached the screen, or the state the page was in at the moment it went wrong. One script tag on the dev, staging or UAT build attaches all of it to the write-up they were already going to file.
- [Snag for solo founders](https://snag.ac/for/solo-founders): When you are the whole engineering organisation, a bug report is an interrupt before it is a defect. The expensive part is almost never the change — it is working out what the person actually did, on what, in which browser, and whether you have seen it before.
- [Snag for support teams](https://snag.ac/for/support-teams): A support team usually gets one chance to ask a customer anything. They report the fault in their own words, and by the time anybody asks which browser they were on, they have closed the tab and gone back to work. With Snag, what they hand over is the session itself rather than a description of it.
- [Snag for teams with a coding agent](https://snag.ac/for/teams-with-a-coding-agent): A coding agent is fluent in your codebase and completely blind to the twenty seconds before the failure. The evidence it needs existed — in the reporter's browser — and the only route it has ever had into the context window is you, retyping it.

## Legal

- [Terms of service](https://snag.ac/terms)
- [Privacy policy](https://snag.ac/privacy)

## Translations

- Español: https://snag.ac/es
- 中文: https://snag.ac/zh
- Deutsch: https://snag.ac/de

## Full text

- [Every page as one markdown document](https://snag.ac/llms-full.txt)