Coding agents can write the code. They can’t run the backlog
Specboards is the end-to-end agentic harness for AI product teams. Your coding agents already write the code; Specboards gives them the backlog to work from, with each spec versioned in your repo. One MCP connection covers the whole loop, from idea to shipped, while your team plans in the same board.
$npx @specboards/cli helpNo account needed to look around. All install options
The hosted service is in pre-release and invite-only while we onboard product teams. The app itself is open source: self-host it today.
Coordinated, not single-shot. Agents share one board and one validated workflow, so several can work a backlog at once.
Git-native. No second source of truth: the specs in your repo are the backlog, versioned with your code.
Governed. Per-agent identities, scoped keys, request and write quotas, and an audit trail of every spec write.
The loop
Every stage, on one board, for people and agents alike
One MCP connection covers the whole loop, from an idea nobody has written down to a release that has shipped.
Capture
Raw ideas and requests land in a dedicated Ideas intake. Promote the ones worth doing straight into the backlog, so nothing is lost between feedback and the plan.
Define
The specification is written to specs/**/spec.md and committed, so it arrives as a reviewable diff rather than a field in a database. Specboards parses each spec, injects a stable UUID when one is missing, and keeps a live, sha-tracked index. Renames and moves never orphan your data, because every spec is keyed by its id, not its path.
Break down
Create work at any level of initiative, epic, and feature, nest it, and roll a summary of the children back up into the parent. The hierarchy above the spec is managed in the app, not in git.
Prioritize
Rank, assign, and tag in a fast backlog: drag to reorder, save custom views, filter by product, status, or owner. Group work into releases and cycles, and record what it ladders up to with goals and key results.
Implement
Pick up what is ready and walk a validated workflow: backlog, defining, ready, in progress, in review, done, plus archived. Status always means the same thing, typed dependencies say what is blocked, and each repo can customize the stages in .specboards/config.yml.
Review
Connect a repo with a one-click GitHub App. Specboards imports specs, reconciles on every push, and links live PR, issue, and branch state to your work, so the board reflects what GitHub says rather than what someone last typed.
Release
Lay work out by release and quarter on the roadmap, track what ships when, and draft the customer-facing release notes. Your team and your agents read the same view of what is next.
Why not just use...
Your team has a tracker. Your engineers have agents. The gap is between them.
Specboards doesn't replace your specs or move them into another tool. It's the structure that lets agents run the backlog those specs describe, and lets your team watch them do it.
Why not just use Jira or Aha?
They describe work to people. An agent gets a ticket description rather than the specification, and nothing it does comes back without someone retyping it. Every spec has to be copied out of the repo and kept in sync by hand.
With Specboards: The spec files in your repo stay canonical, and an agent reads and writes them directly. There's nothing to duplicate and nothing to reconcile.
Why not just use Linear, or an MCP plugin for it?
Reading and closing tickets covers one stage. Defining the work, breaking it down, ordering it, and shipping it are the stages where the time actually goes, and none of them are on offer.
With Specboards: One connection covers the whole loop: intake, specs, hierarchy, status, dependencies, releases, cycles, and goals. The same surface your team uses in the UI.
Why not just use Notion or Confluence?
Specs drift from the code the moment they're written, there's no real status workflow across them, and nothing is machine-readable for an agent to act on.
With Specboards: Specs move through a validated status workflow, ship inside pull requests with the code, and expose a structured, agent-readable backlog.
Why not just use Plain markdown in git?
You get canonical specs but no layer on top: no status, no priority, no ownership, no roadmap, and nothing that lets two agents work the same backlog without colliding.
With Specboards: Keep the markdown exactly where it is. Specboards adds the backlog, board, roadmap, releases, goals, and ownership around it, without pulling it out of the repo.
How it works
From repo to running agents in minutes
No migration project. Point Specboards at a repo, and the specs you already have become a backlog your agents can work.
Connect your repo
Set up the GitHub App in one click. There are no secrets to paste; credentials are created and stored encrypted for you.
Specs import automatically
Specboards scans specs/** per your .specboards/config.yml, homes each under a Feature, and keeps the index in sync on every push.
Point your agents at it
Connect any MCP client with OAuth, or give an unattended agent its own scoped key. It picks up what's ready, writes specs, opens pull requests, and moves cards, while your team works the same board in the app.
Ecosystem
Works with the spec-driven tools you already use
Specboards reads plain markdown specs in git. Whether your team writes specs by hand or generates them with Spec Kit, Kiro, or OpenSpec, Specboards turns them into a managed backlog.
GitHub Spec Kit
Spec Kit's /specify workflow writes specs/<feature>/spec.md straight into your repo. Specboards indexes those same files, so every Spec Kit feature lands on your backlog and board automatically.
Kiro
Kiro's spec sessions turn prompts into requirements and design docs that live with your code. Specboards layers status, priority, ownership, and roadmap over the specs your Kiro workflow produces.
OpenSpec
OpenSpec keeps change proposals and specs in git as markdown. Point Specboards at the repo and those artifacts get a product home: ranked, owned, and scheduled into releases.
Claude Code, Cursor & MCP agents
Any coding agent that speaks the Model Context Protocol can read your prioritized backlog, update status, and write specs back to git. Your agents plan from the same board your product team does.
New to the practice? Read our guide to spec-driven development, including core material from GitHub, Anthropic, OpenAI, and AWS.
Install
Run something before you talk to us
The CLI is published to npm and Homebrew, and the app is on GitHub. Nothing below needs an invitation.
The CLI
Drive work items (status, assignment, GitHub links) from the terminal or a git hook, over the same public API the app uses. Apache-2.0, so you can script against it freely.
$npx @specboards/cli help
$npm i -g @specboards/cli
$brew install specboards/tap/specboards
Pointing it at a deployment needs an API key from that deployment, hosted or your own.
Self-host the full stack
The web app, the hosted MCP endpoint, and GitHub sync, from one Docker Compose stack. No feature gates on the core.
$git clone https://github.com/Specboards/Specboards
$cp infra/.env.example infra/.env
# set BETTER_AUTH_SECRET and POSTGRES_PASSWORD, then:
$docker compose -f infra/docker-compose.yml up
This builds the image from source, so allow a few minutes on the first run. We don’t publish a prebuilt image yet.
Open source
Yours to run, or hosted by us
The app is open source under the AGPLv3. Self-host for internal control, or use the managed SaaS and skip the ops.
Self-host
Run it on your own infrastructure, modify it, and keep your specs and backlog inside your network. The whole application is in the repository, including the multi-tenant code path we run ourselves, with no feature gates on the core.
Get the codeHosted SaaS
Request access to the hosted beta, then connect a repo in minutes. We run the database, deploys, and updates so your team can focus on the product.
Request accessFAQ
Agentic product development, answered
Common questions about running a backlog with coding agents, and where Specboards fits.
What is spec-driven development?
Spec-driven development is a workflow where a written specification, usually a markdown file committed to the repo, is the source of truth for what gets built. Tools like GitHub Spec Kit, Kiro, and OpenSpec help teams author and refine those specs, and AI coding agents implement against them. The spec, not the ticket, drives the work.
What is an agentic harness?
The structure around a coding agent that tells it what to work on and records what it did. An agent inside a session is good at writing code; it has no memory of what your team decided last week, what is blocked, or what ships next. Specboards is that structure: a backlog agents read at the start of a session and write back to at the end, shared with the people who decide what is worth building.
Where does product management fit into spec-driven development?
Specs describe what to build, but someone still has to decide what to build next, who owns it, and when it ships. Specboards adds that layer directly on the spec files in git: ideas and intake, a prioritized backlog, a kanban board, a roadmap, releases, and goals, with no separate tracker to keep in sync, and all of it reachable by your agents.
Who is Specboards for?
Product teams building with AI coding agents: product managers who need a backlog and roadmap, engineers who want specs to stay canonical in git, and anyone running more than one agent who needs them working from the same plan instead of colliding.
How does this relate to Anthropic's AI-native SDLC playbook?
Specboards is designed to be compatible with that model, not dependent on it. The playbook describes six stages (plan, design, build, test, deploy, maintain) and the version-controlled artifacts that carry work between them. Specboards serves the stages either side of the coding session: intake and specs on the way in, live pull request state, governance, and releases on the way out. It does not do your testing or run the coding session. The full stage-by-stage mapping, including the gaps, is in the repository.
Does Specboards work with GitHub Spec Kit and other spec tools?
Yes. Specboards indexes plain markdown specs in your repo (specs/**/spec.md by default, configurable per repo in .specboards/config.yml). Specs authored with Spec Kit, Kiro, OpenSpec, or by hand all work the same way.
How do AI coding agents use Specboards?
Through Specboards' built-in MCP server. Agents like Claude Code and Cursor connect with OAuth, or with a scoped key if they run unattended, and cover the whole loop: list products and work items, read specs, follow dependencies, create work at any level, write specs back to git, link a pull request, move a card through the workflow, and draft release notes. Every agent gets its own identity, so you can see what each one did and revoke one without touching the others.
Can I try it without an invitation?
Yes. The CLI is published, so npx @specboards/cli help works right now, and it also installs from npm or Homebrew. The application is open source under the AGPLv3, so you can clone the repository and run the full stack with Docker Compose. Only the hosted service is invite-only during pre-release.
Is Specboards open source?
Yes. The app is open source under the AGPLv3, with no feature gates: the full web app, MCP endpoint, and GitHub sync run from one Docker Compose stack. You can self-host it, or request access to the hosted SaaS and skip the ops. A commercial license is available if the AGPL does not fit your use.
Give your agents a backlog to work from
Connect a repo and put your backlog, board, and roadmap where your team and your agents both already work: the specs in git. Or clone it and run the whole thing yourself.