TL;DR
- BugHerd is a website feedback and bug-tracking tool: point-and-click element pinning, auto-captured browser/OS/URL/screenshot metadata, a kanban board, and tracker integrations.
- BugHerd also shipped an MCP server, which is a real signal that they take the agent workflow seriously. As documented at the time of writing, its tools read and write tasks: the client comment text, a screenshot, the page URL, browser and OS, status, severity, assignees, tags and comment history.
- That is the ticket, in text and static-image form. What the BugHerd MCP does not appear to hand an agent is a recording's structured context, a transcript, timestamped key-moment frames, or the click coordinates of what the reporter actually did.
- Clipy takes the opposite starting point. You record the bug, and Clipy's MCP hands the agent the recording itself: a summary, key moments with frames and click coordinates, and the full transcript, delivered through real MCP tools your coding agent can call.
- The question that decides it: when my AI agent picks up this bug, what does it actually receive? With Clipy, the answer is "what happened on screen, in order, with the clicks," plus console logs and network requests from the Chrome extension. That is what an agent needs to reproduce and fix a bug.
Why BugHerd having an MCP at all is worth noticing
Most bug-tracking and feedback tools still assume a human is going to read the ticket. BugHerd is one of the few incumbents that has actually shipped a Model Context Protocol server, which means it is telling an "agent" story out loud. That is worth taking seriously rather than dismissing.
An MCP server is the thing that lets a coding agent, Claude, Cursor, ChatGPT, a Codex or Gemini CLI, and so on, call structured tools instead of screen-scraping a dashboard. When a tool ships one, it is making a bet that the next "user" of a bug report is a machine, not just a developer with coffee. BugHerd made that bet, and this comparison is a fair fight because they did.
So the question this post asks is not "does BugHerd have an agent story", it clearly does. The question is narrower and more useful: what does that agent story actually put in front of your AI when it opens a bug?
What BugHerd (and its MCP) do
Element-pinned visual feedback. BugHerd lets a client or teammate drop a pin on a live web page, point, click and comment, and the feedback stays attached to that element.
Automatic technical capture. Every comment arrives with browser version, operating system, screen resolution, device info and the page URL, plus a screenshot of what the reporter saw.
Kanban and integrations. Feedback becomes a task on a board, and BugHerd pushes into Jira, Trello, Asana, ClickUp, GitHub, Slack and Teams.
An MCP surface for the tracker. The BugHerd MCP exposes tools to read task details, list a project's tasks, list your tasks, list projects and get project details, and to update a task, add a comment, create a task, create a project and update a project. It is built to keep a tracker tidy.
All of that operates on the ticket. The question for a coding agent is what that ticket actually contains.
What the BugHerd MCP actually hands an agent
Here is the careful part. As documented at the time of writing, when a BugHerd task is read through its MCP, the agent receives the task's data:
- the client's comment as verbatim text,
- a screenshot of what the reporter saw,
- the page URL,
- browser version and OS,
- task status, severity, assignees, due date and tags,
- the client-visibility flag,
- and the full comment history.
Read that list again through the eyes of a coding agent that has been asked to reproduce and fix the bug. It is a rich description of the ticket and a single static frame of the outcome. It tells the agent the "where" (URL, element, browser) and the "what the human typed." It is built for triage, routing and prioritization, which is what the MCP's write tools do.
What it does not appear to include is the sequence of events that produced the bug. A comment plus a screenshot captures the end state and the human's interpretation of it. It does not capture the three clicks that got there, the order they happened in, the transient toast that flashed and vanished, or the exact coordinates the user pressed before the app broke. BugHerd does offer a video-feedback capability for humans to record and share sessions, but that is a human-viewing artifact, and the MCP's documented tool surface is task, comment, screenshot, project and metadata text. It does not appear to hand the agent a recording's transcript, its timestamped frames, or click coordinates as structured data the agent can reason over.
That is the layer its MCP operates at: the ticket layer. If you want the agent to receive the recording layer, you need a tool whose MCP was built to serve the recording.
What Clipy's MCP hands an agent: the recording itself
Clipy starts from the other end. You record the bug, screen, and on Mac or the Chrome extension, the cursor and clicks too, and Clipy turns that recording into something an agent can read directly. The whole design goal is stated on the for-agents page: the recording is the source of truth, and the agent gets structured access to it.
There are two doors into that structured context.
Share the normal recording link. The agent still needs permission to access private material; installing the skill does not change who can read the recording.
For private recordings or library search, ask the agent to connect your Clipy account. Follow the sign-in prompt if needed. Let it use the connection guide instead of copying configuration yourself.
get_agent_context, the whole structured package for a recording in one call,get_key_moments, the timestamped moments, with frames delivered as inline images and click coordinates where available,get_transcript, the words that were said,get_summary, the recording distilled,search_recordingsandlist_recordings, find the right recording,get_recording, pull one by id.
The difference from the ticket layer is concrete. When a Clipy-backed agent opens a bug, it is not reading a human's paraphrase and squinting at one screenshot. It is reading what happened, in order, with the clicks: the summary tells it the gist, the transcript tells it what the reporter narrated, and the key moments tell it, frame by frame, with coordinates, where the cursor went and what it hit right before things went wrong. Frames arrive as inline images through the MCP, so a vision-capable agent can actually look at the state at each step.
Click coordinates come from the Mac app and Chrome-extension recordings, and the Chrome extension also captures console logs, network requests, GraphQL errors and WebSocket totals, with each click's accessibility label. Clipy hands the agent the full context; your agent writes the fix. Full setup lives in the MCP docs.
The comparison, on the one axis that matters
Strip away everything else and line the two MCPs up on the single question: what does the agent receive when it opens the bug?
- Client's words. BugHerd: yes, verbatim comment text and comment history. Clipy: yes, as the transcript of what the reporter narrated while recording, plus a generated summary.
- A picture of the problem. BugHerd: a screenshot of the end state. Clipy: multiple timestamped key-moment frames across the recording, delivered as inline images.
- The sequence of actions. BugHerd: not part of the documented MCP surface, you have the end state, not the steps that led there. Clipy: yes, the key moments are ordered through the recording.
- Where the user clicked. BugHerd: not exposed as structured data to the agent. Clipy: click coordinates as frame fractions on Mac and Chrome-extension recordings, with a burned-in marker on the coordinate frame.
- Runtime evidence. BugHerd: browser, OS, resolution, device and URL. Clipy: from the Chrome extension, console logs, network requests, GraphQL errors and WebSocket totals, the evidence that explains why the page broke.
- Pointing at the exact element. BugHerd: a pin on the live page. Clipy: click coordinates, the clicked element's accessibility label, and Flare highlights of whatever the reporter pointed at, all captured while recording.
- Getting it into a tracker. BugHerd: tasks on its own board. Clipy: create a Jira, Linear or GitHub issue from the recording, publish a Confluence page, or attach the recording to a pull request, with the Generate tab writing the bug report for you.
- Cost. Clipy: viewers watch with no signup, the MCP works on every plan, and Pro is $9 a month or $72 a year after a 7-day free trial with no card. BugHerd is a paid team product.
Clipy has an answer on every row. And the rows where BugHerd's MCP goes quiet, the ordered sequence, the clicks, the transcript, the multiple frames, are exactly the ones that decide whether an agent can reproduce the bug instead of guessing.
A concrete example: the same bug through both MCPs
Abstractions are easy to nod along to, so picture one specific bug: a user reports that clicking "Save" on a settings page silently does nothing, no error, no confirmation, the form just sits there. Here is what each agent actually gets to work with.
Through the BugHerd MCP, the agent calls something like get_task_details and receives: the comment "Save button doesn't work on the settings page," a screenshot of the settings page with the pin on the Save button, the URL app.example.com/settings, "Chrome 141 on macOS," severity high, assigned to nobody yet, and two follow-up comments from a teammate. The agent can label it, route it to the frontend team, set severity, and post a "looking into this" comment, which is what BugHerd's write tools are for. But if the agent is asked to reproduce the failure, it has the destination without the road: it knows the Save button on the settings page is implicated, but not what field the user had just edited, whether a validation error flashed and disappeared, or whether the click even registered. It has to guess, or ask the human to go do it again.
Through Clipy's MCP, the agent calls get_agent_context for the recording the user made while hitting the bug, and receives an ordered story. The summary says the user changed their display name, clicked Save, and nothing happened. The transcript has the user saying, out loud, "I'm changing my name here, now I click Save, and, see, nothing." The key moments give it frames at each step with click coordinates: the cursor entering the name field, the click on Save at a specific point in the frame, and the frame immediately after, where a vision-capable agent can read a tiny red validation hint under a different field the user never scrolled to. That is the bug: a hidden validation error on an unrelated field is blocking submit, and the UI isn't surfacing it near the button. The agent didn't guess. It watched.
That contrast is the whole post in one story. The ticket layer tells you which button and which browser. The recording layer tells you the sequence that broke it, and only the recording layer lets the agent reproduce it.
Why Clipy is the better fit for agent-driven bug fixing
When the unit of work is a bug or a flow that has to be reproduced, your AI agent needs "what sequence of actions, in what order, with which clicks, produced this." Clipy's MCP hands the agent the recording itself: the steps, the narration, the frames, the coordinates and, from the Chrome extension, the console and network logs.
Clipy also covers the reporting side. Customers can send you a recording through a request link, the Generate tab turns it into a written bug report, and integrations put it straight into Jira, Linear or GitHub. One tool takes the bug from "here, watch me break it" to a ticket a coding agent can act on.
See it in practice
If you want to go deeper on the agent-reading workflow specifically, these walk through it:
- Give Claude and Cursor access to your screen recordings over MCP, the setup, end to end.
- Give Claude, Cursor and ChatGPT context from a screen recording, what the agent does with it.
- Screen recording for developers: bug repros that write themselves, why the recording is the better bug report.
- Escalate once: let the recording write the repro for engineering, the handoff to a team.
FAQ
Does BugHerd have an MCP server? Yes. BugHerd shipped an MCP server that connects AI tools like Claude, Cursor and ChatGPT to your BugHerd projects and tasks. As documented at the time of writing, it can read task details and lists of tasks and projects, and it can write, update tasks, add comments, and create tasks and projects.
Does the BugHerd MCP give my agent a screen recording's transcript or click coordinates? Not that we can confirm from its documented tool surface. When an agent reads a BugHerd task it receives the client's comment text, a screenshot, the page URL, browser and OS, and task metadata such as status, severity, assignees, tags and comment history. It does not appear to hand the agent a recording's transcript, timestamped frames, or click coordinates as structured data. BugHerd does have a human video-feedback feature, but that is separate from what the MCP exposes.
What does Clipy's MCP expose that's different? Clipy's MCP is built to serve the recording itself. Its read-only tools (get_agent_context, get_key_moments, get_transcript, get_summary, search_recordings, list_recordings and get_recording) hand the agent a summary, a transcript, and timestamped key-moment frames with click coordinates (on Mac and Chrome-extension recordings). Frames come back as inline images the agent can actually see.
Do I need the MCP, or can I just use a URL? Share the normal Clipy recording link with your agent. The skill handles retrieving the available recording context.
Which is better for an AI coding agent? Clipy. BugHerd's MCP hands the agent the ticket: comment text, a screenshot and metadata. Clipy's MCP hands the agent the recording's structured context: summary, transcript, ordered key-moment frames with click coordinates and, from the Chrome extension, console logs and network requests.
How much does Clipy cost? Clipy starts with a 7-day free trial, no card needed. Pro is $9 a month or $72 a year. Viewers never need an account, and the MCP works on every plan. It is authenticated with a key from your settings and scoped to your own recordings. Start on the for-agents page or read the MCP docs.