The kanban board that works itself
PeckBoard spawns Claude Code agents to work your project board. Add a card describing a task; a worker session — one of your flock — picks it up, edits real files in your repository, and moves the card across the board until it reaches Done.
One binary · your machine · your code never leaves the nest
Fresh From the Latest Releases
Remote-control agents (0.1.17)
Enroll another machine with the peckboard-agent daemon and drive it from your sessions — commands, servers, screenshots, mouse and keyboard. Binaries for every platform ship with each release as of 0.1.18.
Providers are installable plugins (0.1.13)
Claude, Grok, Codex, Kimi, Cursor, and Ollama each live in their own plugin. Fresh installs start clean and you add just the providers you use — third-party providers plug in as WASM.
Sturdier long sessions (0.1.15–0.1.18)
Large-context compaction no longer dies at 30 seconds, background subagents survive the end of a turn, and a CLI killed by the OS now says so — signal and likely cause — instead of “exited without a result”.
Full details on the releases page.
You write the cards. The flock ships them.
Lay out the cards
Write cards the way you'd brief a colleague. Set priorities and dependencies; blocked cards wait until the cards they depend on are done.
A worker swoops in
The orchestrator spawns a worker session — a Claude Code agent — in the project's folder. It consults the project's experts, edits files, and runs your tests.
Review, then Done
Watch every step live, chat with the worker mid-run, inspect a side-by-side diff of what changed, and let the card land in Done.
Everything your flock needs
Chat with any session
Every agent run is a session you can open: the full transcript, each tool call, and the model's replies stream in live. Interrupt, redirect, or just ask what it's doing — workers, experts, and plain chats all speak the same way.
Core concepts →
Review documents with an AI pass
Annotate any markdown document — suggest, mark wrong, ask to expand — and run a pass: a reviewer session revises the document, resolves each annotation with a note, and asks an inline question when it needs your call. Every revision is a version with a diff, and nothing touches the source until you apply. Link a GitHub pull request and its review comments come along.
The review flow →
Experts that know every branch
Long-lived expert sessions each read one area of the repository and answer workers' questions; a question expert remembers your answers, and a PM expert records decisions. Workers ask before they guess.
How experts work →
Bring the CLI you already use
PeckBoard drives the coding CLIs installed on your machine — Claude Code, OpenAI Codex, Cursor's cursor-agent, Grok, and Kimi Code — plus your own Ollama servers and any OpenAI-compatible endpoint. Sign in multiple accounts per provider, give each a spending budget, and watch real subscription plan usage — every model shows up in one picker.
Providers & supported CLIs →
Plugins in two clicks
A built-in registry installs eighteen WebAssembly plugins — a code knowledge graph, an app installer, SSH fleet tools, session orchestrators, a UI design gauge, a public REST API — and over a hundred MCP server templates. Nothing runs until you approve the exact hooks a plugin asks for; deny and it stays dormant.
Browse the plugins →
Replay every test flight
Recorded test runs replay like a session-replay product: the cursor moves, clicks ripple, the network waterfall and console scroll alongside, and rage-clicks are called out. Playback skips inactivity so a two-minute run reviews in seconds.
The Playwright Tests plugin →
The rest of the flock's kit
Usage dashboard
Token and cost rollups per model, project, and session — with trends over time — so you know where the spend goes before the bill says so.
Repeating tasks
A saved prompt on a schedule: every N minutes, daily, or weekly. Each firing starts a fresh session in the task's folder — nightly dependency checks, morning summaries.
Multi-user access
Accounts with per-user sessions: each person sees and streams their own conversations, and admin-only surfaces stay locked to admins.
Plans before code
An agent proposes a plan you can read, comment on, and revise; a wizard then turns the approved plan into cards the flock works through.
Reports that outlive sessions
Agents write markdown reports — research, audits, findings — that collect in a browsable library long after the session that wrote them is gone.
Every tool call, readable
Whichever provider runs the agent, the transcript reads the same: the real command line, the model's one-sentence reason, and a diff card for every file edit.
Remote-control agents
Enroll another machine with the peckboard-agent daemon. It dials home over an outbound WebSocket so sessions can run commands, manage servers, and drive the screen — no inbound ports required.
One binary. Your machine. Your code.
The web interface, database, and TLS certificates all live inside a single binary. State is a SQLite file in one directory — a backup is a folder copy. No external services, no cloud account, and your source never leaves the machine the agents run on.
Configuration covers the flags, accounts, and where data lives.
# grab a release, then hatch it:
./peckboard
# prints the admin login and listens on :3344