Skip to content

BugBoard tools for AI agents

One MCP server that gives your agent the checks to run before it files work. It needs no account and no key, and the agent never signs up.

The agent calls a tool

For example, to check for a duplicate.

It gets the result and a link

The result is data. The link keeps it for 72 hours.

You open the link

You sign in, or sign up, when you choose to.

It lands in a project

You pick the project and the tasks are added.

The server

One address, ten tools. Any MCP client that supports HTTP servers can use it.

MCP server address
https://tools.bugboard.ai/mcp
ToolYou give itYou get
check_duplicateA repository and a bug descriptionThe closest issues, with scores
report_from_logA stack trace, CI log or HAR fileThe error, the failing frame, a fingerprint and a report
spec_to_ticketsA specTickets with acceptance criteria, in an export format
convert_boardA Trello JSON or CSV exportThe board converted to another format
create_task_listA nameA list and its token
add_tasksThe token and tasksThe tasks, added
list_tasksThe tokenThe tasks and who holds each
claim_taskThe token and an agent nameA task and a lease
release_taskThe token and the claimThe task, free again
complete_taskThe token, the claim and a noteThe task, done
bugboard worklog --jsonNothing. It runs on your computer.Time, tokens and cost per task. Not published yet.

Add it to your agent

Choose your client and copy the setting.

Run in a terminal
claude mcp add --transport http bugboard-tools https://tools.bugboard.ai/mcp

Have a BugBoard API key? Send it to raise the daily limits.

Optional, with a key
claude mcp add --transport http bugboard-tools https://tools.bugboard.ai/mcp \
  --header "Authorization: Bearer bb_YOUR_KEY"

Add the skill

The skill tells the agent when to use each tool and what to do with the result, including never opening a save link or signing up.

Save it as .claude/skills/bugboard-tools/SKILL.md in your project or your home folder.

.claude/skills/bugboard-tools/SKILL.md
---
name: bugboard-tools
description: Free checks to run before filing work, with no account - find duplicate issues in a public GitHub repo, turn a stack trace, CI log or HAR file into a bug report, split a spec into tickets and export them (GitHub, Linear, Jira, Trello, Markdown), convert a Trello or CSV board export, and share one task list between several agents with safe claiming. Use before opening an issue, when a test or CI run fails, when asked to turn a spec or PRD into tickets, or when several agents work through the same tasks.
---

# BugBoard Tools

Tools on the free BugBoard Tools MCP server. No account and no key are needed.

## Set up

If the `bugboard-tools` MCP server is not connected, ask the user to add it:

- Claude Code: `claude mcp add --transport http bugboard-tools https://tools.bugboard.ai/mcp`
- Cursor and other clients: an MCP server entry with `"url": "https://tools.bugboard.ai/mcp"`

Without MCP, the same tools answer JSON-RPC over HTTP: `POST` to that URL with
`Content-Type: application/json` and a body like
`{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"check_duplicate","arguments":{...}}}`.
The result is in `result.structuredContent`.

## Rules

- The tools return data. Write the issue, report or summary yourself from it.
- Many results have `save_url`. Show it to the user as a link and say what it does
  ("open this to keep it in a BugBoard project"). Never open it yourself and never
  sign up for anything.
- On `quota_exceeded`, `capacity_reached` or `rate_limited`, tell the user and do not
  call that tool again before `retryAfterSeconds`. A key from a BugBoard account
  raises the limit; only the user can make one.
- Never paste secrets on purpose. `report_from_log` removes the ones it recognises
  before it reads the log, and says how many in `redactions`.

## Before filing an issue in a public GitHub repo

1. Call `check_duplicate` with `repo` (owner/name), `title`, and `text` (the symptoms
   and the error message make the match better).
2. If `verdict` is `likely_duplicate`, do not file. Tell the user which issue it is
   (number, title, url) and offer to add your details there as a comment.
3. If it is `related_found`, mention those issues in the new one. If `looks_new`, file it.

## When a test, build or app run fails

1. Call `report_from_log` with the log (or the HAR file as text). Add `repo` to also
   check for duplicates in one call.
2. If `recognised` is false, ask for the part of the log that shows the failure.
3. Write the issue from `title`, `error`, `failing_frame`, `environment` and
   `excerpt`, or use `report.markdown` / `report.github` / `report.jira` as given.
   Keep the `fingerprint` in the issue: the same bug gets the same one.
4. Steps to reproduce are never in a log: ask the user or say they are missing.

## When asked to turn a spec or PRD into tickets

1. Split it yourself into tickets an agent can finish: `title`, `type`, `priority`, a
   short `description`, testable `acceptance` points (Given/When/Then or a checklist),
   `test_cases` (`title`, `steps`, `expected`) under `test_areas`, `depends_on` (refs
   of other tickets) and `likely_touched` (files or areas the spec names or implies;
   it is a guess, never invent paths).
2. Call `spec_to_tickets` with `tickets` and the `format` the user wants (`github`,
   `github_csv`, `jira_csv`, `linear_csv`, `trello_csv`, `markdown`, `json`). Fix what
   it refuses (unknown dependency, cycle, limits) and call again.
3. Give the user `output` (for `github` it is a shell script of `gh issue create`
   calls to run in the repo) and the `save_url`. Importing the save link into BugBoard
   also puts the test cases on the project's Testing board.
4. To convert a board export (Trello JSON or a CSV) instead, call `convert_board`
   with `content` and `to`.

## When several agents share the work

1. One agent calls `create_task_list` with a `name` and the `tasks`, and gives the
   `list_token` to the others. Keep it out of public places: anyone with it can use
   the list.
2. Before starting a task, call `claim_task` with `list_token` and your `agent` name
   (and `task`, or none to take the first ready one). Keep the `claim_id`.
3. A `conflict` means another agent holds it: take another task; never work on it.
4. Renew a long task before its lease ends: `claim_task` with `task` and `claim_id`.
5. When finished, `complete_task` with a `note` of what changed. To stop part way,
   `release_task` with a `note` of what you tried and what is left.
6. To let the user see the list in BugBoard, call `list_tasks` with `export: true`
   and show the `save_url`.

What it looks like

A made-up session. It shows the order of the calls, not real output.

Limits

Without a key

Counted for each network, a day: 30 duplicate checks, 100 log reports, 100 spec splits, 50 board conversions and 2,000 shared task list calls.

With a key

A BugBoard API key raises each daily limit about ten times and counts the calls for your organisation, not your network. Only a person can create a key.

At most 30 requests a minute without a key. When a limit is reached the tool says how long to wait.