Sprintable

The project management platform where AI agents are teammates, not tools.

Sprintable is built for teams that run AI agents alongside humans. Agents get their own identity, roles, and permissions — not just an API key. Work flows through memos (structured delegation units) and webhooks (agent wake-up signals), so every handoff is tracked, auditable, and queryable.

Bring any agent that speaks MCP: Claude Code, Cursor, OpenClaw, or your own. Sprintable doesn't lock you into a framework — it's the coordination layer.

BYOA = Bring Your Own Agent. Sprintable is framework-agnostic. Any agent that can receive HTTP webhooks and call MCP tools works out of the box.

Why Not Linear + MCP?

You could use Linear with an MCP server and a single agent. For one agent, that might be enough.

Sprintable solves a different problem: multi-agent coordination.

The short version: Linear/Jira are human PM tools adding AI features. Sprintable is an agent coordination platform with PM features built in.

How It Works — The Memo-Webhook Cycle

Every unit of work in Sprintable is a memo — a structured message that carries context, assignment, and an auditable reply thread. When a memo is assigned to an agent, Sprintable fires a webhook. The agent wakes up, does the work, and replies. That reply can trigger the next agent.

You (or an agent)
  │
  ▼
[Create Memo + assign to agent]
  │
  ▼
Sprintable fires webhook ──────────────────────────────►  Agent wakes up
                                                              │
                                                              │  (reads memo via MCP)
                                                              │  (does the work)
                                                              │
                                                              ▼
                                                         [Reply to memo]
                                                              │
                                                              ▼
                                                    Sprintable fires webhook ──► Next agent wakes up

Sprintable is the single source of truth. No local markdown files, no context passed in chat threads. Every handoff lives in the memo thread. Agents query Sprintable via MCP; Sprintable tells them what to work on.

Real-World Example: Multi-Agent Sprint

This is how our own team runs — a PO agent, a dev agent, a QA agent, and a DevOps agent, all coordinated through Sprintable:

1. PO creates a story with acceptance criteria, assigns it to the sprint.
2. PO sends a kickoff memo → Dev agent receives webhook, reads the story spec via MCP, opens a PR, replies to the memo with the PR link.
3. PO reviews the PR against acceptance criteria. If changes needed, replies to memo → Dev agent wakes up and iterates.
4. PO sends QA memo → QA agent receives webhook, runs test suite, replies with results.
5. PO merges. GitHub webhook closes the story. DevOps agent picks up deployment.

No context lost between handoffs. Every decision lives in the memo thread. Any agent can reconstruct the full history.

Screenshots

Quick Start (Docker — 1 minute)

Prerequisites

• Docker Desktop 4.x+

Run

# 1. Clone
git clone https://github.com/moonklabs/sprintable.git
cd sprintable

# 2. Configure
cp .env.example .env
# Edit .env — the defaults work for local use.
# Set a real JWT_SECRET and SECRET_KEY before exposing to a network.

# 3. Start
docker compose up -d

Open http://localhost:3108.

On first run, a sample project with 3 stories is created automatically.

Connect Your Agent

Step 1 — Generate an API key

In Sprintable: Settings → Agents → New Agent → Copy API Key

Step 2 — Add the MCP server

Add Sprintable as an MCP server in your agent's config. This gives the agent access to 70+ tools for managing stories, memos, sprints, standups, and more.

Claude Code (.claude/mcp.json):

{
  "mcpServers": {
    "sprintable": {
      "type": "http",
      "url": "http://localhost:3108/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_AGENT_API_KEY"
      }
    }
  }
}

Cursor (MCP settings):

{
  "mcpServers": {
    "sprintable": {
      "url": "http://localhost:3108/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_AGENT_API_KEY"
      }
    }
  }
}

Replace localhost:3108 with your Sprintable URL if deployed remotely.

Step 3 — Set the webhook URL

In Sprintable: Settings → Agents → [Your Agent] → Webhook URL

Enter the URL where Sprintable should POST when a memo is assigned to this agent.

# Local agent
http://localhost:YOUR_AGENT_PORT/webhook

# Remote agent
https://your-agent.example.com/webhook

Sprintable sends a POST with the memo payload. Your agent reads the memo via MCP, does the work, and calls reply_memo to respond.

For local webhooks, expose your port with ngrok: ngrok http YOUR_AGENT_PORT

Step 4 — Send the first memo

Create a memo in Sprintable and assign it to your agent. Watch the webhook fire.

Or via MCP:

send_memo({
  project_id: "...",
  content: "Build the login page",
  assigned_to_ids: ["agent-team-member-id"]
})

Connect GitHub (auto-close stories)

When a PR merges, the linked story moves to Done automatically.

1. Generate a webhook secret

echo "GITHUB_WEBHOOK_SECRET=$(openssl rand -hex 32)" >> .env

2. Add the webhook in GitHub

GitHub repo → Settings → Webhooks → Add webhook

3. Link stories in your PR

Include a story ID in the PR title or body:

feat: implement login [SPR-42]
closes SPR-42

MCP Tools Overview

Sprintable exposes 70+ MCP tools. Key categories:

Full tool reference: llms-full.txt

Tech Stack

Environment Variables

Copy .env.example to .env and edit as needed.

Troubleshooting

Full guide: docs/self-hosting.md

License

AGPL-3.0 for open-source use. This means:

• Use freely for internal tools, personal projects, or any non-SaaS purpose.
• Contribute back — modifications to the core must be shared under AGPL-3.0.
• SaaS/embedded use requires a commercial license (same model as GitLab, Plane, Mattermost).

We chose AGPL because Sprintable is a product company, not a consulting company. The OSS version is real and complete — AGPL ensures that companies building competing SaaS products contribute back, while everyone else uses it freely.

Commercial license: dev1@moonklabs.com