One board. You, your team, and every agent you use — writing in it at the same time.

A note, a task, a decision, a deadline, a research finding - all the same primitive. One markdown document with tags, scores, and typed links to whatever it affects.

There is no notes-versus-tasks split to reconcile, because there is only one kind of thing to file.

A node's parent says what it belongs to. Its edges say what it blocks and what it affects.

Move a branch and every view updates at once - the canvas, the ranked list, and what your agent reads next. Nothing to re-file, because nothing was filed twice.

A decision is recorded where it happened and linked to what it changed.

Six months later, "why did we pick this?" is a question you ask the graph, not a scroll back through a chat log. Each one keeps the reasoning that was live at the time - not a tidy summary written afterwards, once everyone already agreed.

Every node is embedded in the background as you write.

Ask what was decided about authentication and you get the decisions - including the ones that never use the word. Nobody maintains the index, and nobody tags things hoping their future self guesses the same word.

Node bodies are real markdown - headings, tables, code fences, lists. Paste a spec in and it stays readable.

Export is not a roadmap item. It is the storage format.

Rank comes from value, effort, how many things a node unblocks, and any deadline pressure.

It is deterministic: the same board always produces the same order. Nobody spends Monday morning re-sorting a backlog to feel productive.

A blocked item stays in its position and names what is holding it.

It does not quietly sink to the bottom - a list that hides blocked work is a list that lies about how much is left.

Ranking is automatic; the pinned head is yours.

Pin the three things that actually matter this week and the computed order fills in underneath. Judgement where it belongs, arithmetic everywhere else.

There is no agent view and human view to keep in sync.

Ask an agent what is next and it reads the exact ranking you are looking at. When you re-prioritise, it picks up the change on its next read.

Two numbers per node: value and effort.

Leaving them blank is honest when you genuinely do not know yet. A made-up 7 is not. The ranking degrades gracefully instead of demanding certainty you do not have.

Two agents and a human can edit the same branch simultaneously and the edits merge cleanly.

It is a CRDT underneath, so offline edits merge too when you reconnect. Nothing locks, nothing is checked out, nobody overwrites anybody.

An agent does not hand you a proposal to re-type into your tracker.

It creates the branch, wires the dependencies, and marks things done - in your board, while you watch. You prune the dead end while it is still planning the next one.

Close the chat. Open a different agent tomorrow, on a different machine, from a different vendor.

It reads the board and knows where the last one stopped. Nothing is re-explained, because the context never lived inside the conversation.

Claude Code, Cursor, Cline, Codex, Gemini CLI, or something you wrote yourself. The board does not care which model is inside.

Switching agents costs nothing, precisely because the context was never held by the agent.

Agent writes land on the canvas live - nodes appear as they are created, and you can move them while they do.

Presence shows who is in which node right now, so "is it still working?" is answered by looking.

Any MCP client gets every verb: search, read, create branches, reorder, complete, record decisions.

A local host on your machine or a cloud gateway - one build, the same tools either way.

No MCP in your harness? One llms.txt teaches an agent the routes and the sign-in.

A homegrown CLI agent, or a local model running through Ollama, works the same way a commercial one does.

ChatGPT and Gemini connect through generated connectors and work your boards from the browser - no terminal involved.

And for a chat with no integration at all, a fragment link carries an outline inside the URL itself. Nothing touches a server.

When an agent needs your real boards it shows a short code, you approve it in your browser, and it carries on in the same conversation.

Same flow a TV uses to sign you in. No key in a config file, no key in a chat log, nothing to rotate when a laptop goes missing.

Paste one sentence to any agent that can run a command and it builds you a real, live board in seconds - no signup, no install, no card.

Watch it get built, then claim it if you want to keep it.