Something strange happened to software work. The doing of it got fast — an agent spins up a worktree, files a plan, writes the code, opens the PR — and the seeing of it got worse. The work happens in terminals you aren’t watching, in sandboxes that get recycled, in session tabs that belong to a vendor. When the run ends, what remains is a diff. Not the reasoning, not the dead ends, not the state of the forty other tasks in flight. A diff.
Teams have always solved this with a shared surface: the board on the wall, the tracker, the place where work is a thing you can point at. But every surface we have was built for a different world, and each one fails the agent era in its own way.
The agent’s work has nowhere durable and shared to live.
Look at what exists. Three clusters, each fine at what it was built for — and all three leaving the same hole.
- Too heavy
Jira / Linear
Human-first trackers. Agents bolted on as triggers, output as a code-only PR. You carry a whole platform.
- Invisible
Local agent trackers & markdown plans
Memory for the agent in the terminal. Proudly no dashboard. Anyone not in the repo can’t see the work.
- Ephemeral & siloed
Sandboxes, cloud agents, traces
They run the agent, but the record of what it did is machine state, a vendor’s session tab, or debug spans. Gone when the run ends.
None of this is a strawman. The heavy kanban trackers are excellent systems of record for humans. The local trackers are genuinely good memory for one agent in one repo. The sandboxes really do run the work. But nothing spans them. There is no durable, shared, human-and-agent-readable record of the work itself.
That hole is the whole product.
Agents do the work. Your team gets the window.
Your fleet is working. Now everyone can see it.
One agent or fifty, across as many worktrees. Instead of fifty terminals and a pile of PRs, you get one live board — who’s doing what, what’s blocked, what shipped — that a teammate, a lead, or a stakeholder watches without a clone or a CLI. And it’s the same record the next agent reads to pick up where the last one left off.
That second half matters as much as the first. Durability isn’t sentimentality about old tickets; it’s continuity. The next agent arriving cold shouldn’t re-derive what the last one knew from a git log. It should read the board.
Work at token speed. Record on paper.
Agents create and destroy structure at token speed. A board that took a committee a quarter to configure, an agent authors in one prompt — and deletes without ceremony when the work ships. That speed is the point, and nothing about it should be slowed down to make a human comfortable.
But humans have a very old need the terminal never met: proof, presence, a record of account. The ledger. The board on the wall. Paper — not because paper is fast, but because paper is legible, and it survives the person who wrote it.
We refuse to pick a side. The machine works at machine speed; the record reads like something a human can hold. That tension isn’t a compromise to manage — it’s the product thesis. It’s even this site’s design language: torn paper, tape, and ink, driven by a CLI.
Not a system of record.
A system of motion.
Built to be torn down.
Boards are cheap. Spin one up per feature, per migration, per research sweep. Export the outcome as markdown, archive the board, and move on. The board disappears; the result persists.
This is the opposite bet from every tracker before it. Trackers assume the board is the permanent thing and the work passes through it. We assume the work’s record is the permanent thing, and the board is scaffolding — thrown up fast, torn down without grief.
- create
- shape
- drive
- export ↴
- archive
Four commitments.
- 01
Agent-first, human-visible. Every capability works headless for an agent and live for a person watching. If only one audience can use it, it isn’t done.
- 02
Structure is a prompt, not a project. The agent defines the board’s shape in seconds, in unlimited forms. No config marathons, no opinions imposed on your domain.
- 03
Own the artifact, not the compute. Sandboxes and agent vendors run the work; the record of it shouldn’t die with them. The ticket is the durable index — snapshot, preview, trace, PR — not the runtime.
- 04
Built to be torn down. Boards are cheap and meant to end. Durability belongs to the record of the work, not to the scaffolding around it.
The compute is ephemeral. The vendors are interchangeable. The work — what was tried, what was decided, what shipped — is the part worth keeping, and the part everyone should be able to see while it happens.
Give your agents a board. Give your team a window.