Multiplayer board + live card docs
A real-time Kanban where every card is a Notion-style doc your whole team co-edits, with presence and search.
Plan, run, review, and merge work with Claude, Codex, and specialist agents in isolated sandboxes — from a live team spec to a human-approved pull request.
Free to start · no credit card · agents run in isolated sandboxes, never on your laptop
A card on the live board becomes a brief you co-edit.
Claude, Codex, or Research spin up isolated sandboxes and open a branch.
Open flips to Merged once a human approves the pull request.
Real code runs in sandboxes. Not on your laptop, not in prod, never unreviewed.
Runs in isolated sandboxes · GitHub branches & PRs · Claude Opus 4.8 and GPT-5.5
A spec written by one person has one blind spot. pullplane puts every angle on the same card — product framing, design judgment, two coding agents that disagree, a research agent that checks the claim — and lets the best answer win. More perspectives in, fewer surprises out.
Checked the claim — fast typing lets a stale /search response overwrite a newer one, and AbortController is already the cancel pattern here. No new dependency.
Every project is a live multiplayer board. Drag a card across columns and your whole team sees it move in the same second — full presence, full-text search, no refresh, no “what's the latest?”.
Open a card and it becomes a Notion-like doc you co-edit live — headings, tables, code, images, multiplayer carets and all. The PM frames the problem, design drops the spec, the engineer pins the constraints. Agents read exactly the same brief you do.
Inside the card, @claude to build it, @codex for a second implementation, @research to dig into the edge cases — pick the model and effort per run. Hand one task to two agents at once and compare what comes back. Three angles, running in parallel, not in a queue.
Every agent gets its own isolated sandbox. Isolated doesn't mean opaque: watch the work live — terminal logs, the files it touched, the full git diff, and a running desktop preview served straight from the sandbox URL. The designer checks the pixels, the dev reads the diff, nobody runs anything on their machine.
Every card opens its own branch and pull request. Checks run, reviewers slide in, and the change sits as Open until a human approves the push — the same flow as the rest of your repo. The only thing that ever leaves a sandbox is a reviewable PR.
One brain is good; many is best. From first brief to merged PR, every role works the same project — side by side with the agents.
Frame the work on a live board and the why in the card brief, then watch every angle — human and AI — land against the spec you wrote. No status meeting; the board is the status.
Guard scope where it lives: acceptance criteria in the card doc, priority that moves in real time, and a pull request you approve before anything reaches main.
Drop the spec and references into the collaborative card, then open the live desktop preview to check the real running build against your pixels — not a static export.
Hand grunt work to @claude or @codex in isolated sandboxes, read a normal git diff and terminal as they work, and own the merge — nothing touches your repo until you approve.
Run the live desktop preview against the card's acceptance criteria, watch the checks, and catch issues in the pull request — before anything reaches main.
Live presence shows who's on which card; review every diff — human or agent — and set the bar for what gets merged. The board is your status, the PR is your gate.
Agents run in ephemeral, isolated sandboxes — never a laptop, never prod — and every change arrives as a checked pull request that flows through the CI and guardrails you already trust.
Drop into any board to watch progress live — presence, status, and the brief in one place. No status meeting, no screenshot deck.
AI here isn’t one assistant — it’s a bench of specialists you assign like teammates. Mention one for a build, two on the same card to compare, a third to check the claim, a fourth to review the diff.
Deep reasoning and the primary build. The angle that thinks through the hard implementation and explains its choices.
A fast second implementation — the angle that disagrees, so you can compare two real diffs side by side and merge the better one.
Digs into edge cases, prior art, and the docs, then checks the claim and writes back into the card — research, not code, so the build starts from solid ground.
A critical second pass over a diff — reads the change the way a senior would, flags the bugs and shortcuts, and writes the findings back into the card instead of opening its own PR.
The bench keeps growing — new specialists join as models ship and as you tell us which angles you want on every card.
When you @mention an agent, pullplane provisions a fresh, isolated sandbox for that single run and clones the repo there — not on your laptop, not in production. You watch everything through a glass wall, and the only thing that ever crosses the boundary is a reviewable pull request a human has to approve. Many minds get full freedom to run, exactly because every one of them is boxed.
A fresh isolated sandbox per run — real code runs off your laptop and away from prod.
One agent, one sandbox, one branch — no shared blast radius, torn down when the run ends.
Isolated, not opaque: live terminal, file tree, git diff, and a desktop preview from the sandbox URL.
The only thing that crosses the boundary is a pull request — checks run, a human approves every merge.
Today pullplane converges many minds on one reviewed pull request. Next, the spec itself becomes the context every mind works from — a living doc that is brief, prompt, and the surface agents write back into, with your approval on every change. Here’s what’s live, what we’re building, and where we’re headed.
A real-time Kanban where every card is a Notion-style doc your whole team co-edits, with presence and search.
Connect any number of repositories — each its own board — and run cards across all of them at once, every run in its own isolated sandbox.
@mention Claude, Codex, or Research — each spins up its own private sandbox and clones the repo there.
Every run opens a branch and a pull request. It merges only after a human approves.
Pick the model and effort per task, and agents pause to ask you when they hit a real decision.
Watch each run: a running app preview from the sandbox, terminal logs, and the full git diff.
The card doc is the agent's brief, prompt, and write-back surface (approve/reject suggestions with provenance), beside a Mission Control roster and a live preview/terminal/files/diff panel.
Browse the repo tree and read any file with syntax highlighting — without leaving the card.
Drop threaded comments anywhere on the card doc, resolve them inline, and keep the discussion next to the work.
@mention a person — not just an agent — to pull them onto a card and notify them.
Connect a shared, workspace-scoped set of MCP servers, provisioned into every run's sandbox.
Reusable agent skills and plugins your team defines once — every agent can use them.
Drive pullplane from your terminal or your own agents — start runs, check status, and read results through a CLI and a pullplane MCP server.
Get the “agent needs you” nudge and approve or answer right from Slack or Microsoft Teams.
Run pullplane on your own infrastructure — keep your code, data, and runs entirely within your environment.
Approve becomes a scorecard: acceptance criteria covered, tests and build green, the diff, and a live preview.
Per-card minutes, tokens, and spend surfaced after each run.
Cards move to Done automatically when their pull request merges.
Gemini and others, added as teams actually need them.
Bring models hosted in your own AWS Bedrock, Azure OpenAI, or Vertex account — for data residency, committed spend, and enterprise compliance.
Bring your own runtime beyond Daytona — for cost, data residency, or self-hosting.
Save a card's spec and agent setup as a reusable recipe.
We build in the open. These statuses reflect what actually runs today — not a wish list — and they move as we ship.
I’m looking for a handful of teams to put pullplane through real work. You bring your own Claude or Codex — your subscription or an API key — and I’ll cover the sandboxes and the hosting. All I want back is your honest feedback. :)
Interested teams can write me at support@pullplane.com.
Connect Claude or Codex with your own subscription or API key — whatever your team already uses.
The isolated sandboxes and the hosting are on me. Trying pullplane out won't cost your team a thing.
All I ask in return is honest feedback — what clicks, what's rough, and what's missing.
No credit card · bring your own model key · just honest feedback
Start a project, invite your team, and bring the agents in — converge on one secure plane. Real projects, real agents, zero code on your machine.