Skip to content
Pigeon — local-first MCP kanban Pigeon — local-first MCP kanban Pigeon

Pigeon

Pigeon // self-hosting MCP kanban

A kanban board that carries context
between AI coding sessions.

Self-hosting MCP integration, real-time SSE board updates, audit-grade attribution. You see a board. The agent reads and writes the same board over MCP. Nothing leaves your machine.

Storage
SQLite, on disk
Updates
Real-time SSE
Surface
MCP + Web UI
License
MIT, open source
FIG.01 The session loop Context released at saveHandoff, carried in flight, recovered at briefMe. The next agent starts in-context.
  1. 01 saveHandoff writes a handoff record from session N.
  2. 02 The handoff persists on disk — a SQLite row. No network.
  3. 03 briefMe hydrates session N+1 with the same context.

§01 The problem

Context evaporates at the end of every chat.

You open a new session and re-explain what was planned, what's done, what was decided, what's stuck. Pigeon catches that context for you — and hands it to the next agent.

  • You see a board, live

    Cards, columns, priorities, checklists, comments, activity. Drag-and-drop in your browser. Real-time SSE updates — everything the agent does shows up live, no refresh.

  • The agent sees structure

    10 essential MCP tools always on. 65+ extended tools discoverable on demand via getTools / runTool. Context footprint stays small.

  • Sessions hand off cleanly

    saveHandoff writes a structured handoff at the end of one chat — type /handoff in Claude Code to trigger it. The next chat calls briefMe and resumes exactly where the last one stopped.

  • Audit-grade attribution

    The Attribution Engine picks one card per session via a 5-tier heuristic. Every TokenUsageEvent row carries the signal that produced its cardId — see exactly why a session was attributed.

§02 Surface

The board, annotated.

Columns mark state; cards are units of work; priority rides as a colored stripe; tags filter; numbers stay stable across sessions.

FIG.02 — Board view Tutorial board, fresh install
Pigeon board view with Backlog, In Progress, Review, Done, and Parking Lot columns. Cards show priority-colored stripes, tags, and stable card numbers. 01 Columns = state 02 Card = unit of work 03 Priority stripe 04 Tags + counters
  1. Columns = state Backlog, In Progress, Review (optional), Done, Parking Lot. The agent moves cards across columns instead of inventing new statuses. Top 3 of Backlog are pinned — the human-priority queue.
  2. Card = unit of work One concern per card. Title, priority stripe, tags, stable #N number. Everything the agent reasons over has an id.
  3. Priority stripe Color-coded left edge. Critical, high, medium, low. Quick visual ranking without opening the card.
  4. Tags + counters Tags filter the board (tutorial, mcp, advanced). Comment and checklist counters surface card depth at a glance.
FIG.03 — Card detail The single screen where humans and agents converge
Card detail panel showing description, tags, checklist, and comments for card #12 — Add Comments & Collaborate. 01 Stable #N 02 Description = scope 03 Checklist = sub-state 04 Comments = guidance
  1. Stable #N Card numbers never change, even after deletion. Agents reference cards by #12 across sessions and the link still resolves.
  2. Description = scope What, why it matters, try-it instructions. The agent reads this on briefMe; the human edits it during planning.
  3. Checklist = sub-state Lightweight subtasks. Crossing items off is a legitimate end-of-session save point — no need to split a card.
  4. Comments = guidance Human nudges and agent observations. Surfaced to the next session via getCardContext. The audit trail makes clear who said what.

§03 The metaphor

The pigeon carries the message.

saveHandoff releases a handoff at the end of one chat. The wire is your local disk, not a network. briefMe catches the same payload at the next session — fully in-context, in seconds.

A handoff is a SQLite row. A row knows the project, the active card, the recent decisions, the open threads. It does not know your network — there isn’t one to know. The next session’s first move is briefMe; what comes back is the handoff plus the current board pulse plus any open blockers.

Built for two readers. A human who wants a board. An agent that wants structure. The same SQLite file serves both, all the time, with no sync layer between them.

§04 Continue

What to read next.

Two paths in. Surface readers go to the quickstart. Depth readers go to the rationale.