Let an AI agent fix your bug reports over MCP
Coding agents are good at fixing small, well-described problems: a misaligned button, a typo in a label, a form that rejects a valid email. What they are bad at is guessing. Paste “the checkout button is broken on mobile” into an agent and it will search the codebase, pick a plausible button and change it, confidently, whether or not it was the right one.
The fix is not a better prompt. It is a better bug report, delivered in a form the agent can read directly. That is what Jot’s MCP server does: it gives an agent the same report a developer sees, with the page, the element, the screenshot and the browser, and lets it reply on the thread when it is done.
What MCP is, briefly
The Model Context Protocol is an open standard for connecting AI applications to tools and data. An MCP server exposes a small set of named tools; an agent such as Claude Code, Cursor, Windsurf or Gemini-based Antigravity discovers them and calls them when the task needs them. For bug reports this means the agent does not need a copy-paste from you, a scraped web page or an API key in a curl command. It asks the server for the open reports and gets structured results.
The tools
Jot’s server is deliberately small. Fewer tools means less of the agent’s context spent on tool descriptions and fewer ways to go wrong. The four that matter for the fixing loop:
fetch_feedbacklists Jots: id, status, labels, the reporter’s sentence, the page and the element. Every filter is optional (status, label, page, search text and more), and it needs no project id: the token already knows which projects it reaches.get_commentreturns one Jot in full: its capture context, the thread so far, a summary of the session recording if there is one, a link to the dashboard, and the screenshot as an image the agent can look at.update_statusmoves one Jot, or several, toIN_PROGRESSorRESOLVED.post_replyreplies on the thread. The reply is marked as coming from an agent and appears on the reporter’s pin.
There are two more: create_batch_note, for one note across several Jots that turned out to be the same bug, and list_projects. The full reference is in the MCP documentation.
Why the report shape matters
A Jot is created by a person clicking the element that is wrong. That click is the important part: it records a CSS selector for the exact element, the URL, the browser, operating system and screen size, and a screenshot. For an agent, the selector and URL turn a search problem into a lookup. Instead of hunting for “the checkout button”, it can find the route that renders that URL and the component that renders that element.
When the reporter also recorded a session, the agent gets a summary of it, so it knows what happened before the bug, not only the final state. This is the same information that makes a report good for a human (see how to write a bug report); the difference is that nobody had to type it.
The loop
A typical session with an agent looks like this:
- The agent calls
fetch_feedbackto see what is open. - For each Jot it decides to take, it calls
get_commentfor the full repro, including the screenshot. - It marks the Jot
IN_PROGRESS, so the team and the reporter can see someone is on it. - It finds the code, makes the change and runs whatever checks you have asked it to run.
- It calls
post_replyto say what changed, ideally with a link to the pull request. - It marks the Jot
RESOLVED.
You start all of that with one instruction. The prompt we use in the docs is:
Fetch the open feedback. Fix what you can, reply on each Jot
with what you changed, and mark them resolved.Humans approve, by default
Jot has four statuses: open, in progress, resolved and approved. An agent sets the middle two. Who may set APPROVED is your workspace’s choice, and by default it is only the person who reported the problem: the API refuses it from an agent token unless an admin opts in.
The reason is simple. “Resolved” means “someone believes this is fixed, please check”. “Approved” means the person who reported the problem looked again and agrees. An agent can be wrong in convincing ways: it can fix a different element that matches the description, or fix the symptom on one screen size and not another. Keeping approval with the reporter means every agent fix is checked by the person who saw the bug, on the page where they saw it, before anyone calls it done.
In practice this works well for reporters who are not technical. They see a reply on their pin (“Fixed the button’s width on small screens, PR #212”), check the page, and approve, or reply that it is still wrong, which puts it back in front of the team.
Setting it up
MCP access is included on every plan, Free too (see pricing). In Claude Code, install the Jot plugin:
/plugin marketplace add usejot/claude-plugins
/plugin install jot@usejotThen ask Claude to connect Jot: it opens your browser, you pick the workspace, and it works without a restart. Or paste an agent token from Settings → Agents when Claude Code asks. For Cursor, Windsurf, Codex or any other agent, run these in the repo:
npx @usejot/cli login
npx @usejot/cli initThe first opens your browser to pick a workspace; the second connects the repo, with no token to paste. Restart the agent so it loads the tools, and run npx @usejot/cli mcp doctor if you want to check which projects it can see.
Where agents help, and where they don’t
Agents do best on reports that are specific and local: one element, one page, a clear expected result. Copy fixes, layout bugs at one breakpoint, a missing validation rule, a broken link. They do worse on reports that are really product decisions (“this flow is confusing”) or bugs that need data or access they do not have. A sensible pattern is to let the agent take what it can, reply on what it could not, and leave the rest for a person. The reply is still useful: it tells the team what the agent tried.
Two habits make the loop more reliable. Ask the agent to reply before it resolves, so every resolved Jot has an explanation. And ask it to link the pull request, so whoever reviews the code can see the original report and its screenshot.
If you would rather not run an agent yourself
On the Agency plan, projects linked to a GitHub repository also have Fix with AI: select up to ten Jots in the inbox and Jot opens a pull request. It never merges and never changes a Jot’s status; you review the PR, ship it, resolve the Jots, and the reporters approve.
Either way, the agent works from what a reviewer captured by clicking the problem. The better that capture, the less the agent has to guess. You can read more about the widget and the dashboard on the product page, and about MCP and the other integrations on integrations.