The agentic product workspace
Context, specs, roadmap, goals, customer feedback, market signals, and decisions — written together in real time and grounded in one Context Graph. Then any coding agent ships the work over MCP. Open source, self-hosted, on your own keys.
Context, specs, decisions, roadmap, competitor and market insight, and customer feedback — baked into a single agentic surface. Product, design, and engineering work in the same place, and so do their agents. No more stitching tools together or losing the thread between them.
Context lost at every hand-off.
One source of truth — humans and agents.
Most tools own one slice of this and hand off the rest — so context leaks at every seam. Burrow runs the whole loop on one surface: a spec becomes an AI breakdown, an agent does the work, your team signs off. The same context — your company knowledge, the spec, the decisions — is carried forward at every step, for both humans and agents.
A real-time editor with live cursors and presence, built on BlockNote and Yjs. The PM writes the intent, engineers add the constraints — same document, same moment. A / slash menu and in-editor AI drafting are right there when you need them.
One click streams a breakdown — tasks with acceptance criteria — from your spec plus your Context Graph. Don't like it? Undo and regenerate. Runs on your own API key, never ours.
Your coding agent connects over MCP, calls get_next_task with full spec context, and pushes status back as it works. Claude Code, Cursor, anything MCP-capable — and it shows up in the activity feed as a teammate.
Teammates mark each spec Approved or Flagged. Sign-offs are append-only and pinned to the exact spec version they were cast against — a clean decision log, not a buried PR comment.
Then it runs again — faster each time, because the context compounds instead of evaporating. Plan, work, and decisions never leave the room.
Multiplayer specs, the PM surfaces around them, AI that stays grounded, an agent bridge, automations, and a shareable library. All on one canvas, all on your keys.
Burrow's editor is real-time multiplayer. Live cursors, presence, and instant edits — the PM writes the intent, engineers add the constraints, all in one spec at the same time. Built on BlockNote and Yjs, with in-editor AI drafting and a / slash menu, so it feels like the document tools your team already knows.
User settings redesign
Consolidate 4 scattered settings pages into a single panel.
Success: <2 support tickets/week about finding settings.
/ ai draft acceptance criteriaAnikaBeyond the spec, Burrow runs the whole plan. A Now / Next / Later roadmap you drag initiatives across. Goals and OKRs with key results, linked to the specs that serve them. Customer feedback that AI clusters into themes — and turns a theme into a spec. Plus a Market surface tracking competitors and severity-scored signals, each with a clear “so what for us.”
One click turns a spec into tasks with acceptance criteria. Insights surface quietly on the roadmap, the backlog, and each spec — always grounded in your Context Graph, offered as amber suggestions, never red alarms. Decline one and it stays out of your way. With no key configured, the AI degrades silently rather than nagging.
Three Now initiatives have no key results yet. Want to draft KRs from the linked specs?
Burrow exposes an MCP server, so any coding agent works with it. Your agent calls get_next_task and gets the full spec context — not a pasted snippet — does the work, and calls update_task_status, which flows straight to the board. It can pull get_insights and list_skills to act the way your org would. Agents appear as square-avatar teammates in the live activity feed.
# your agent, over MCP get_next_task → task + acceptance criteria + full spec context get_insights · list_skills → act the way your org would update_task_status → flows straight to the board
Lightweight when/do routines run in-process — no extra infrastructure, no queue to babysit. When a sign-off is approved, notify Slack. When a spec moves to In progress, post the next task to your agent. Simple triggers, real actions, no Zapier in the middle.
Package your team's skills, agents, and routines as .burrow/ files — shareable, version-controlled, and synced like code. The format is published and versioned, so you build on an open spec, not a closed binary. Reuse a skill across teams, fork it, review it in a PR.
.burrow/
├── skills/
│ ├── write-spec.md
│ └── triage-feedback.md
├── agents/
│ └── ship-next-task.md
└── routines/
└── notify-on-signoff.mdMost tools make you choose: a polished surface you don't own, or plain files your agents can't reason about. Burrow refuses the trade. The plan, the work, the decisions, and the agents all live on one surface — open source, on your infrastructure, on your keys.
Give Burrow your company, product, persona, and ways-of-working docs once. They're embedded into a Context Graph that grounds every AI surface — breakdowns, insights, in-editor drafting, even what your agents see over MCP. The AI works from how your team actually operates, not a generic template.
The spec is the unit of truth. Real-time, multiplayer, versioned — and the full context an agent pulls over MCP, not a pasted snippet. Sign-offs pin decisions to the exact version, so there's always a clear record of what was agreed and when.
Skills, agents, and routines — packaged as version-controlled .burrow/ files — teach the AI your team's moves. An agent calls list_skills and acts the way your org would. Reuse them across teams, fork them, review them in a PR.
The breadth around the loop — built to move fast and leave a record.
Teams own both people and work — see a team's specs, initiatives, and members in one place. The whole org, structured the way it really runs.
Append-only sign-offs pinned to the exact spec version they were cast against. A clean, auditable decision trail — nothing quietly edited or deleted.
Jump to any spec, surface, or action without leaving the keyboard. The fast path through the whole workspace.
Search across specs, feedback, market signals, and decisions — one box over the entire surface, not six tools.
A calm, focused view for sign-off — read the spec the way it's meant to be reviewed, then approve or flag in place.
Every spec is versioned. Sign-offs, insights, and the agent's context all reference the version they belong to.
Anthropic, OpenAI, Google, OpenRouter, or Ollama for fully on-prem. Add a key once; it's encrypted at rest and never leaves your server.
Single-key shortcuts across the app, a Home dashboard of what needs you, and a workspace chat grounded in your specs.
Burrow connects to your stack over MCP, using your org's own credentials — so integrations ride the open ecosystem instead of bespoke connectors you have to maintain.
Jira, Confluence, and Slack are in progress — over MCP, with your own credentials. No bespoke connector to maintain.
The web app, realtime server, and database run on infrastructure you control. Burrow hosts no models and runs no inference — every AI feature uses your org's own provider key. No data transits our servers, because we run no servers in your path. No telemetry, no install pings, no hosted models. docker compose up is the intended experience.
git clone https://github.com/burrow-hq/burrow cd burrow # add your .env (API key + one secret) cp .env.example .env docker compose up
Burrow is open source, and the openness is structural — not a marketing word.
The license ships with the first commit. Permissively licensed — we're finalizing the exact terms before public launch.
A public governance doc in the repo's first week. The license can't be quietly swapped out from under you.
Build agents and tools against a stable, open format. No closed binary, no proprietary protocol.
Monetization, if it ever comes, is hosting convenience and enterprise compliance — never core capability.
| Hosted AI planning tools | Burrow | |
|---|---|---|
| Run it on your own infrastructure | No | Yes — docker compose up |
| Your own API keys | No — runs on their servers | Yes — Anthropic, OpenAI, Google, OpenRouter, Ollama |
| Telemetry | Yes | None |
| Price | Per creator, per month | Free, unlimited creators |
| Agent bridge | Closed, unpublished format | MCP-native, published .burrow/ spec |
| Governance | Commercial, closed | Open source, no-rug-pull pledge |
You don't have to choose between a tool that looks good and a tool you actually own. Burrow is both.
Flat specs in the repo are free and fully yours. So is Burrow. The difference is everything files can't do: edit the spec together live, break it down with AI on your own key, and hand your agent real context with a decision trail behind it. You keep the ownership and gain the loop.
docker compose up, bring your own key, and have two people co-editing a spec in under 10 minutes.
Open source. Self-hostable. Your keys, your data, no seat tax.