Skip to content
Branchflow

Private alpha — November 2026

Open source

Build software by plan, not by prompt.

Branchflow is the AI planning workspace for building software with agents. Plan a project as features and tasks — every task is an agent you can run, and every result is reviewed and verified before it reaches you.

Get notified at release

One email when v0.1.0 ships. Double opt-in, no spam, unsubscribe any time.

How it works

From an idea to a verified pull request.

Agents can write code. The hard parts sit either side of that — deciding what to build, holding a plan across ten sessions, and proving the result works.

You decide what gets built and what ships. In between, Branchflow interviews you, drafts a plan you can argue with, turns the approved version into a spec and a tree of tasks, runs each task as an agent, reviews the code it writes, and checks the finished feature back against the spec.

  1. Three questions, each offering two options, with one option chosen in every row.

    01questionnaire

    It asks before it builds.

    Start with a description of what you want — a sentence is enough. Branchflow interviews you about the parts that decide everything else: scope, the business rules, the edge cases, what is explicitly out. You don’t have to know how to brief an agent. That is what the questions are for.

  2. A draft plan beside a back-and-forth thread with the agent, above two buttons: keep editing, or approve.

    02plan

    Argue with the plan while it is still a draft.

    A plan comes back — and it stays a draft. Push back, ask for a different split, add what was missed, go round with the agent as many times as it takes. Nothing is built, and nothing is committed to, until you approve it.

  3. A spec document beside a design diagram, with a rail dropping from it into three task nodes on orthogonal connectors.

    03spec + tasks

    Approve it: a spec, a design diagram, and tasks that run.

    Approving turns the draft into a detailed spec with a design diagram, and decomposes it into tasks. The spec is where the design is confirmed, and it travels with every task as its context — and each task is an agent you can run, not a line in a checklist.

  4. A task marked as running, with the agent’s output streaming into the panel below it and a progress bar part-filled.

    04run

    Run a task as an agent.

    Each task runs as an agent on its own branch, with the approved spec as its brief and the rest of the plan as context. Watch it work, see what it is costing, stop it whenever you like.

  5. A report panel listing three passing checks above a two-line plain-language summary.

    05review

    Every task is code-reviewed before it reaches you.

    The project’s own checks run against the change, and a reviewer agent reads it. What comes back is pass or fail, the findings, and what changed and why in plain language. The diff is there if you want it.

  6. A spec panel with three checks passing, linked to a pull request card with a button to open it.

    06verify + PR

    Then the feature is checked against the spec, and shipped.

    Code review asks whether the change is sound. This asks a different question: does the finished feature do what the spec said it would? Once it does, the work goes out as one pull request, described from the spec you approved.

And you can see where everything stands.

Open a feature and it tells you how it is doing: what is merged, what is running right now, and the one task that came back with something you need to look at. Pick a task and you get its agent, its progress, what it is costing and what review found — without opening a diff or a terminal.

That view is the interface. Features and tasks are what you navigate, not files and tabs, and the same picture is coming for a whole project — every feature, its stage, and what is waiting on you.

A feature dashboard: a tree of tasks marked merged, running and planned beside three summary tiles, with the selected task showing its progress and three review results, one of them flagged.

These are illustrations of the flow the alpha is built around, not screenshots — and the last stages, code review, spec verification and opening the pull request, are designed and being built rather than finished. Sign up below and you will see the real thing when it ships.

Who it’s for

For the people who decide what gets built.

If you can read a plan and judge a result, this is aimed at you. Writing the code is the agents’ job — deciding what gets built, and whether what came back is right, is yours.

  • Engineers and tech leads

    You design before you build. Branchflow holds that design as a spec every agent has to work from, gives each task its own branch, and puts a review between an agent’s output and your attention — so following the plan is the default rather than something you chase.

  • Product owners and project managers

    You think in features, acceptance criteria and dependencies. Plan at exactly that level, send a task off to an agent, and read back what it did in plain language, checked against the criteria you set. Driving the build does not require writing the code — it requires knowing what “done” means, which is already your job.

  • Teams who already write specs

    You write the spec first, then spend the week pasting it back into an agent one task at a time, hoping it still remembers what you settled on Monday. Here the spec belongs to the feature, and every task it produces carries it automatically. Write it once; each agent starts with it in hand.

One caveat about the alpha specifically: it runs on your own machine and installs with Node and git, so the first five minutes are developer-shaped. The hosted version that follows drops that step. Planning the work never needed a terminal — only this first release does.

What it is not

Four things Branchflow deliberately isn’t.

Each of these is a decision, not a gap waiting to be filled. If one of them is a deal-breaker for you, better to find out here than after you install it.

Not a code editor, and not a chat box
It is an IDE for the work, not for the files: no file browser, no terminal, no hand-editing code, and the diff is read-only. The work is structured — projects, features, tasks — so every step leaves a record, and nothing that matters lives in a scrollback you have to re-read.
Not a model — and not tied to one
Branchflow drives coding agents rather than being one. It runs on Claude today, through its Agent SDK; Codex is next, then local and air-gapped models through any OpenAI-compatible server. You bring your own key, and you see what each run costs.
Not autonomous by default
You decide what runs, and you approve the plan before anything does. Reviewers and verifiers decide what is ready for your eyes — nothing ships because an agent felt confident.
Local-first, not local-only
The alpha runs on your own machine, on your own repositories. Server mode and a hosted version follow, so the work can carry on with the laptop closed.

Signup

Be there when it opens.

Branchflow is in private alpha. v0.1.0 is the first release anyone can install, and when it lands we will write to you exactly once — that day. No newsletter, no drip sequence, and nobody else gets your address.

We use your address for one thing: an email when Branchflow v0.1.0 ships. You will get a confirmation link first — your address is not on the list until you click it. Unsubscribe from any email, any time; we never share or sell it.