Flow
Menu

Start

What Flow is not

The product decisions Flow is built on, what each one rules out, and the limit that follows from them.

Flow is small on purpose. Each decision below rules something out, and most of what Flow does not do follows from one of them. The principles are the rules of the method. These are the decisions about the product the method runs on.

The decisions underneath

A task is not an issue

The task is the lasting unit of intent. The PRD that proposed it, the issue that tracks it, the pull request that builds it and the commit that ships it are references on that one task, not four tasks. A tool where one task is one issue spends four objects on one intent, and Flow would reproduce exactly that if it copied the model. See references.

Flow has authority over nothing

Flow does not read your tracker, does not poll anything, and never decides on its own that a task changed. Your agent already has a client for every place your work lives, and it writes to Flow when it judges the write worth making.

The cost is freshness, and Flow pays it in the open. Every reference records when an agent last checked it against its source, and a task’s readiness reports the oldest check it rests on. A store that hides how stale it is is not simpler. It is unreliable.

Readiness is computed, never labelled

Whether a task can start is derived from its edges and waits on every read (P5). There is no “ready” label to forget to remove: closing the last thing that blocks a task is the act that makes it ready, and there is no second step.

A write is never refused for being inconvenient

Flow accepts a write and reports what it noticed: a cycle, a missing cause, a link to work nobody captured (P7). It refuses only a status that contradicts itself, never a write because of how much you have written. An agent that meets one refusal it did not expect stops writing whenever it is unsure, and a graph nobody writes to answers nothing.

One graph across every project

Work lives in projects, because a project is what you share. Nothing asks you to pick one before you look: what is next, the order and the graph read every project you can reach unless you narrow them. Asking which workspace to open first would rebuild the fragmentation Flow replaces.

There is no sub-task, only the dependency

One relation between two tasks answers “what is this waiting on”. A sub-task answers a different question, “where does this live”, and a tool that offers only that one forces every dependency to be written as prose beside it. Flow does not offer both: a second structure over the same tasks is a second thing to keep true, and the two disagree the first time a piece turns out to belong somewhere else. Where work belongs is its project and its tags, which hold nothing up. See no sub-tasks.

The agent is the first client, not the only one

Flow is an MCP server, and your agent shows its answers in whatever client you are already using. The console is a second client of the same API: it draws the graph and writes through the same operations an agent calls. Nothing in either decides anything on your behalf. A task written from the console is a task written, exactly as one written by an agent.

What Flow is not

Not a replacement for your issue tracker. Issues keep being filed where they are filed. Flow holds what a tracker cannot: typed edges between pieces of work, one task across several repositories, and what can start now as a question you ask rather than a list somebody keeps.

Not a sync engine. Flow never reads back from your tracker and never writes to it, so there is no class of bug where two stores disagree about which one won. What arrives from outside, through an ingest endpoint, lands as a capture in your inbox and decides nothing until you triage it.

Not a system of record for anything but its own graph. The issue, the pull request and the document stay where they are. A reference is a link to them, not a copy of them.

Not something that acts for you. Flow ranks what is ready and reports what it noticed. It starts nothing and closes nothing. An agent that finds a task in the ready set acts because you asked, and the task is the context for that request (P2, P8).

The limit that follows

Because Flow reads nothing by itself, the graph holds only what an agent, a person or an endpoint you published bothered to write. There is no answer to “is this the whole picture?”. It is as much of the picture as was written down.

That is why the method asks every agent run to write back what it did before it stops (the agent protocol), and asks you to review what nobody has confirmed in a while. Neither makes the graph complete. Both keep it close enough to trust.