ConsensFlow Download
New in 3.0.7 · nine roles, backups and Vacation, own hands

A software factory,
staffed by
AI coding agents.

A desktop app. You give the goal to a Chief of Staff; it plans the work on a board, and a staff in nine roles takes the tasks, each in a terminal of its own, in the coding agents you already use, with your own logins.

  • Claude Code
  • Codex
  • Pi
  • Devin
  • Muse Code

The latest alpha. Mac with Apple silicon, macOS 13.5 or later; Windows 10 or 11, 64-bit. No passwords stored, no API keys. Supported versions

Or install from a terminal

Mac
curl -fsSL https://consensflow.ngvoicu.dev/install.sh | sh -s -- --alpha
Windows, PowerShell
$env:CONSENSFLOW_CHANNEL = 'alpha'; irm https://consensflow.ngvoicu.dev/install.ps1 | iex
The ConsensFlow window on a demo project, pantry, with Inbox, Specs, Project settings and New project along its top. On the left, the board: a note from the chief under For you, then the columns Backlog, Queued, Working, Waiting, Done and Finished. The chief's row has T-10 and T-9 in the backlog, each blocked by the tasks it waits for. Under it the Workers group is open, five members, each named by its model: @gpt-6-1-terra-high on Codex with T-2 accepted; @gpt-6-astra-medium on Pi, out of quota, its backup taking its tasks, with T-5 waiting; @claude-sonnet-5-5-medium on Claude Code at work on T-7; and @gpt-6-luna-low, on Vacation. On the right, the chief's pane, Claude Code on claude-opus-5-5, with Do with your own hands, History, Switch chief and Start meeting on its card. In its terminal the chief accepts T-2 and T-3, leaves a note, reads an advisor's result on time zones, and puts a plan of five tasks, T-8 to T-12, on the board with cf task add --plan.
A demo project. The board on the left: the chief's row, then the staff grouped by role, here the workers, and a column for each state of a task. The chief's terminal on the right: Claude Code reads an advisor's result and puts the next five tasks on the board with one plan.

Who does what

A software factory

Behind the board, ConsensFlow is a small civilization at work. The chief plans, and hands each task to a member of the role it needs: workers build, frontend designers design and build screens, architects design the software, researchers and advisors bring findings, reviewers and testers check finished work, integrators land what was accepted, and the image designer draws. When a check finds something, the chief sends it back into the same window, so the follow-up continues where the task stopped. You set the goal and make the calls that are yours. What comes out is software.

Who talks to whom in ConsensFlow You give the goal to the Chief of Staff and answer its questions; the chief answers you and leaves notes on the board. From the chief, a line of its own runs to each of the nine roles of its staff, and messages go both ways on it. A worker gets a task and sends back completed work and evidence. A frontend designer gets a screen's purpose and sends back its design and implementation. An architect gets a design problem and sends back documents, contracts and a code frame. A researcher gets a question and sends back findings and where they were found. An advisor gets a question and sends back findings and recommendations. A reviewer gets finished work to check and sends back findings and evidence. A tester gets work to run and check and sends back test results and evidence. An integrator gets accepted work and sends back the work merged, checked and landed. The image designer, on Codex, gets a drawing order and sends back the saved image. Workers, frontend designers, architects, integrators and the image designer change your project; researchers, advisors and reviewers change no project file, and testers change no product code. With own hands on, the chief does the work on your project itself. No member is joined to another: every message goes through the chief. goal, answers questions, notes own hands: the chief does the work itself YOU give the goal CHIEF OF STAFF plans, answers, decides: accepts, or sends back WORKER → a task ← completed work and evidence FRONTEND DESIGNER → a screen's purpose ← its design and implementation ARCHITECT → a design problem ← docs, contracts, a code frame RESEARCHER → a question ← findings and their sources ADVISOR → a question ← findings and recommendations REVIEWER → finished work to check ← findings and evidence TESTER → work to run and check ← test results and evidence INTEGRATOR → accepted work ← merged, checked, landed IMAGE DESIGNER → a drawing order (on Codex) ← the saved image YOUR PROJECT the software Who talks to whom in ConsensFlow You give the goal to the Chief of Staff and answer its questions; the chief answers you and leaves notes on the board. From the chief, a line of its own runs to each of the nine roles of its staff, and messages go both ways on it. A worker gets a task and sends back completed work and evidence. A frontend designer gets a screen's purpose and sends back its design and implementation. An architect gets a design problem and sends back documents, contracts and a code frame. A researcher gets a question and sends back findings and where they were found. An advisor gets a question and sends back findings and recommendations. A reviewer gets finished work to check and sends back findings and evidence. A tester gets work to run and check and sends back test results and evidence. An integrator gets accepted work and sends back the work merged, checked and landed. The image designer, on Codex, gets a drawing order and sends back the saved image. Workers, frontend designers, architects, integrators and the image designer change your project; researchers, advisors and reviewers change no project file, and testers change no product code. With own hands on, the chief does the work on your project itself. No member is joined to another: every message goes through the chief. goal, answers questions, notes own hands YOU give the goal CHIEF OF STAFF plans, answers, decides: accepts, or sends back WORKER → a task ← completed work and evidence FRONTEND DESIGNER → a screen's purpose ← its design and implementation ARCHITECT → a design problem ← docs, contracts, a code frame RESEARCHER → a question ← findings and their sources ADVISOR → a question ← findings and recommendations REVIEWER → finished work to check ← findings and evidence TESTER → work to run and check ← test results and evidence INTEGRATOR → accepted work ← merged, checked, landed IMAGE DESIGNER → a drawing order (on Codex) ← the saved image YOUR PROJECT the software
Who talks to whom. From the chief, a line of its own to each role, and on each line the board carries messages both ways: what the chief sends, and what comes back. The staff talk only to the chief, never to each other; you talk to the chief in its terminal, and can step into any window. Researchers, advisors and reviewers change no project files; testers change no product code. With human approval on, every message between them waits for you.

One goal, under way

The shopping list of the demo project, as far as it has gone: your goal in the chief's terminal, the messages the board carried for two tasks, the API (T-2) and its review (T-3), and the chief's note to you. The page, T-4, is still under way. T-2's own messages are in its task, shown open under What it does.

  1. Goalyou → chief, in its terminal

    “The pantry app needs a shopping list: add items, check them off, clear what's done. Keep the list on the server, and have the API reviewed before the page is built on it.”

  2. Request 1chief → the board · T-2, for a standard worker

    The chief reads the routes the app has and writes the brief: three routes, where to keep them, tests beside theirs, npm test before reporting. It adds T-4, the page, for the frontend designer, to wait until T-2 is accepted. @gpt-6-1-terra-high, a standard worker on Codex, is free: T-2 opens in a fresh Codex window.

  3. Question@gpt-6-1-terra-high → chief · T-2 waits

    “Should clearing delete the checked rows, or keep them and mark them cleared? items keeps its history with a deleted_at column; the list could do the same.”

  4. Answerchief → @gpt-6-1-terra-high · T-2 goes on

    “Delete them. The list is a scratch pad: nothing reads old entries, and items keeps the history that matters.”

  5. Result 1@gpt-6-1-terra-high → chief · T-2 done, for the chief to decide

    “Done. The three routes are in server/routes/list.ts, mounted in server/app.ts. […] 15 new tests in server/routes/list.test.ts. npm test passes: 61 tests.”

  6. Reviewchief → the board · T-3, for a complex reviewer

    “Read the change for T-2 and the diff. Is it right, and is it tested?”

    @claude-opus-5-5-max, a reviewer on Devin, takes it. A review changes no file.

  7. Findings@claude-opus-5-5-max → chief · T-3 done

    “Not ready yet: two findings. Clearing deletes row by row, outside a transaction; a failure halfway leaves the list half cleared. PATCH with an unknown id throws, so the client gets a 500; it should get a 404. Otherwise the routes match the brief, and each has its tests.”

  8. Request 2chief → @gpt-6-1-terra-high · T-2 reopened, back into the same window

    “The review (T-3) found two things to fix before I accept this: clear it in one transaction, and answer 404 for an id that does not exist. Add a test for each, run npm test, and report.”

  9. Result 2@gpt-6-1-terra-high → chief · T-2 done again

    “Both fixed. Clearing runs in one transaction: a failing delete rolls the whole clear back. An unknown id answers 404. 3 new tests. npm test passes: 64 tests.”

  10. Acceptedchief · T-2 and T-3 finished

    T-4, the page, was waiting on T-2: it starts now, in a window of its own, for the frontend designer.

  11. Notechief → you, on the board

    “The shopping list API is in: T-2, reviewed in T-3. The page is under way in T-4.”

And it goes on. For the expiry reminders, the chief had a question of its own, how to handle time zones, and put it to an advisor as T-6. The advice came back, and one plan put the next five tasks on the board: store each household's time zone, T-8; the reminders themselves, T-9, waiting on the page, the time zone and the design; the README, T-10; the job's design, for the architect, T-11; and the mail service, for a researcher, T-12. It is all there in the first capture above, in the chief's terminal.

One task's path

How it works

Everything happens in one window: the board on the left, the agents' terminals on the right. Here is one task's path across the board.

    • Backlog

    The chief puts a task on the board

    A brief written for someone who has never seen the project, for the role the work needs, and for a worker, advisor, reviewer or tester its tier: critical, complex, standard or light. A task can wait for others to be accepted first.

    • Queued

    An available member takes it

    ConsensFlow picks an available member of that role, and of that tier where the role has one, never a name, so the work is shared across the staff.

    • Working
    • Waiting

    It works in a terminal of its own

    A fresh terminal of the member's harness, with your login. Open it from the member's row to watch, or tell it something: a tell reaches the window at its next rest. A question to the chief puts the task in Waiting until the answer comes.

    • Done
    • Finished

    The result comes back to the board

    The chief decides: accept it, or send it back to the same window with what must change. The window closes, and its conversation is kept, so a follow-up continues where it stopped.

The ConsensFlow window with the board folded and the terminals side by side. On the left, the chief's Claude Code: a worker's result arriving, cf task accept, a note to the human, an advisor's result on time zones, and cf task add --plan putting five tasks on the board. On the right, the frontend designer's Codex session, @gpt-6-1-sol-high, on T-4, the shopping list page: its brief from the chief, the files it read and edited, its tests passing, and Working.
The board folded, the terminals have the window: the chief's Claude Code beside the frontend designer's Codex session at work on the list page. The dock scrolls sideways to the other windows.

Since 3.0.6

New in 3.0.7

What you will notice. Each one is told in full under What it does.

  • Nine roles

    Frontend designers, architects, researchers and integrators join workers, advisors, reviewers, testers and the image designer.

  • A board grouped by role

    The new dark board groups the staff by role, and each task says how long it has been in its state.

  • Backups and Vacation

    When a member cannot run a task, its free backup can take it, even if it was already given; work in progress starts over in a fresh window. New tasks go to members first. Vacation stops a member's new tasks.

  • Do with your own hands

    The chief does your work itself, and uses the board only when you ask.

  • Models from your harnesses

    Settings → Agents is gone: New project, Project settings and Switch chief read each installed harness's models as they open, and members are named by their model.

  • A plan in one command

    cf task add --plan plan.md puts a plan and its order on the board at once.

  • Muse Code, the fifth harness

    Meta's Muse Code joins Claude Code, Codex, Pi and Devin, for the chief or its staff.

  • A meeting with the chief

    Start meeting holds the staff's messages while you talk with the chief; they come in one at a time after.

  • Compaction, and Claude Code's extras

    Project settings sets when members compact their conversations, and whether Claude Code guesses your next prompt or uses its advisor tool.

  • Messages at the right moment

    A tell reaches a window at its next rest. Notes that need the chief are typed into its window; the rest wait in cf inbox.

  • Resume after a quit or update

    Resume a project and its windows come back on their conversations; a member cut mid-turn is told to go on.

  • Install from a terminal

    One line installs the latest release on a Mac or on Windows, and upgrades the one you have, once it has quit.

In the app

What it does

The staff

One chief, a whole staff
Give the chief your goal in its terminal. It breaks the work into tasks, does what is its own, and hands the rest to the staff you picked for the project.
Nine roles
Workers, frontend designers, architects, researchers, advisors, reviewers, testers, integrators and an image designer, on Codex. The chief gives each member work for its role, and what the role makes comes back, as the factory above draws it. Researchers, advisors and reviewers change no project files; testers change no product code.
Work by tier
For worker, advisor, reviewer and tester tasks, the chief asks for a tier (critical, complex, standard or light), and each such task gets a new window of a member of that role and tier. The other roles need no tier.
Named by their model
Pick a member's harness, one of its models and, where offered, an effort: the lists are read from the installed harnesses when the dialog opens. A member is named by its model, as @gpt-6-1-terra-high is.
The board with every role's group folded under the chief's row, where T-10 and T-9 wait in the backlog. Workers, 5 members, with chips for 2 working, 1 question waiting and 1 out of quota; Frontend designers, 1 member, 1 working; Architects, 1 done, to decide; Researchers; Advisors, 1 done, to decide; then Reviewers, Testers, Integrators and Image designers, one member each.
The board grouped by role, every group folded: what a group's members are doing shows on its head. Open a group for its members' rows.
The top of the Project settings dialog, its Staff section: what each role does, then a row for each member in each of its roles, the member named by its model, and its effort where offered, with its harness, and a tier for a worker, advisor, reviewer or tester. Most rows have Edit, Remove, Send on Vacation and Add a backup. Standard workers: @gpt-6-1-terra-high on Codex; @gpt-6-astra-medium on Pi, out of quota until 22:42 with Try again now, and no Add a backup: under it is its backup, @claude-sonnet-5-5-high on Claude Code, with Send on Vacation, Change and Remove. Light workers: @claude-sonnet-5-5-medium on Claude Code, and @gpt-6-luna-low on Codex, on Vacation, with Bring back in place of Send on Vacation. Then a frontend designer, an architect and a researcher on Devin, with no tier; @claude-opus-5-5-max on Devin as a complex advisor, and again as a complex reviewer, a row with no Add a backup; a standard tester on Muse Code; an integrator, with no tier; and last @codex-default, the image designer, with no tier and only Remove and Send on Vacation. Under them, Add a member: Worker, Codex, gpt-6.1-sol, high effort, complex work, with Refresh models and Add to staff.
Project settings, the staff: a member in each of the nine roles, named by its model. A backup sits under the member it covers, and one worker is on Vacation. Add a member offers the models of the harness picked.

Backups and Vacation

A backup for a member
Give a member an optional backup on any harness or model. New tasks go to free members first. When a member cannot run a task—for example because its quota is out, its login or billing is refused, its model moved or stays busy, its harness cannot open, or the member needs an edit—its free backup can take it, whether it is new or was already given. Work in progress starts over in a fresh window, with a warning to check for partial changes. Tasks given by name, follow-ups, the chief's own tasks and tasks you paused do not move. The chief and the image designer have no backup. On the board, a member and its backup share one team lane and one status. Open the team to see each one.
Vacation
On the board, Vacation sends a member and its backup together; in Project settings, you can send either one. Vacation stops new tasks; work already in a window finishes there. A member on Vacation is not covered by its backup.
Quota-aware
A member works up to 100% of its quota and waits when its harness says it is out, keeping its work in its window until the reset. If the account's quota is renewed early, Try again now brings it back; for harnesses with a shared login, it also brings back chiefs and members across projects.
The Workers group has four members. The team for @gpt-6-astra-medium is open: the Pi member is out of quota and @claude-sonnet-5-5-high on Claude Code is its backup. Under the team are the member’s sessions and the backup’s gentle-cedar session, working on T-8. Another worker, @gpt-6-luna-low, is on Vacation.
An open team: its member is out of quota, its backup has a working session, and another worker is on Vacation.

Do with your own hands

The chief does the work itself
Turn it on in New project, Project settings or the chief's pane, and the chief does your work itself, using the board only when you ask. Work already on the board continues.
The board when you want it
Ask for a task and the chief puts it on the board as before. It can read the board's guide in parts with cf guide.
The chief's pane with Do with your own hands switched on, beside History, Switch chief and Start meeting. In its Claude Code terminal the chief says it now does the work itself, using the board only when asked, and that the tasks already on it go on. Asked to keep people signed in for 30 days instead of 7, it searches for maxAge, reads and updates server/auth.ts, runs the auth tests, 9 passed, and reports that nothing went on the board.
Own hands, switched on in the chief's pane: the chief changes the code and runs the tests itself, and nothing goes on the board.

The chief

Any harness, any of its models
In New project, pick the chief's harness, its model and, where offered, an effort. The lists are read from the installed harnesses when the dialog opens. Settings → Harnesses shows which are installed, their versions, and whether ConsensFlow is set up for each; the versions that work are on the Supported versions page.
Switch the chief anytime
Move the chief to another model or harness. The new chief starts with a handoff: what is on the board, your last words, and the history of the chiefs before it.
A meeting with the chief
Start meeting, on the chief's card, holds the staff's results and questions while you talk with it, shown on the board as held. Stop meeting and they go in one at a time, as the chief comes to rest, questions first.
The New project dialog: the project folder, /Users/demo/projects/recipe-cards; the chief on Claude Code, claude-opus-5-5, at xhigh effort, with Refresh models; then the staff, the last project's: gpt-6.1-terra and claude-sonnet-5-5 as workers, gpt-6.1-sol as frontend designer, claude-opus-5-5 on Devin as advisor and as reviewer, and muse-spark-1.3 on Muse Code as tester, each with Remove and Add a backup; and Add a member, by role, harness, model, effort and tier.
New project: the chief's harness, model and effort, read from the harness as the dialog opens, and the staff the last project had.
The Switch the chief dialog: the chief goes on in a new window on the harness and model picked, Codex, gpt-6.1-sol, at max effort, with Refresh models; Let it finish its turn, then switch, chosen; First ask the chief to write down where things stand, checked; Cancel and Switch.
Switching the chief, from its card: the harness, model and effort it goes on, and whether it finishes its turn first.
The chief's pane after the switch, now Codex on gpt-6.1-sol. Its first message is ConsensFlow's handoff: you are the chief now, switched from Claude Code (claude-opus-5-5) to Codex (gpt-6.1-sol); read cf history before you act; the human's last message; and what waits, a question from a worker on T-5. Then the new chief runs cf history, cf task list and cf answer, and says it has taken over and what comes next.
The new chief, here on Codex, opens on its handoff: what you said last, what waits on the board, and where to read the chiefs before it.

The board

A board you can read
The dark board groups the staff by role. Each task shows who has it, where it stands, and how long it has been in that state. Open a task to read its brief, result and messages, and see what the agent did.
Each task in its own window
A task opens a fresh terminal of its agent's harness, and the window closes when the work is done. Its conversation is kept, so a follow-up continues where it stopped.
Plans with an order
A task can wait for others to be accepted first, so a plan runs in its own order, in parallel where it can. The chief can add a plan and its dependencies in one command with cf task add --plan plan.md.
Task T-2, Shopping list API: add, check off, clear, accepted, asked of @gpt-6-1-terra-high-quiet-harbor. Its story: Request 1 from the chief; a question from the worker, whether clearing should delete the checked rows, and the chief's answer, delete them; Result 1; Request 2, the chief's follow-up after a review found two things to fix; and Result 2, both fixed, 64 tests passing. Under it, folded, what the agent did, 58 items, and the buttons Show terminal and Delete task.
A task after some back and forth: the brief, the worker's question and the chief's answer, a result, the chief's follow-up after a review, and the second result.

Specs

Big work becomes a spec
With specs on, the chief plans big work as a spec, with Specmint, and puts each phase on the board as tasks, in order. A small ask still goes straight to the board.
On for every project, or for one
Settings → Specs sets whether a chief plans big work as specs in every project that doesn't say otherwise, in which folder and with which variant of Specmint. A project's own Specs settings win.
Read them in the app
The Specs button on the board opens the project's specs folder: its tree, and each spec as Markdown, Mermaid diagrams included.
The specs viewer on the demo project, Specs of pantry. On the left, the specs folder as a tree: registry.md, then a folder for each spec, Shopping list, Expiry reminders, Expiry dates on items and Add items by barcode, with Shopping list's SPEC.md chosen. On the right, that spec: its frontmatter as chips, an Overview, the Acceptance Criteria as checkboxes, an Architecture diagram drawn from Mermaid, and three phases with their tasks checked off or not: The API completed, The page in progress, The README pending.
The specs viewer: the project's specs folder as a tree, and the chief's spec for the shopping list, with its criteria, a diagram, and its three phases, whose tasks the chief put on the board.

History

Everything a participant said
History, on a window's head and on the chief's card, opens everything ConsensFlow keeps of that participant's conversations. Search it. It follows your system's light or dark appearance.
The chief reads it too
After you switch the chief, the new one reads what you and the chiefs before it said with cf history, and searches it with --find.
The History dialog, searched for time zone: the human's words about households in different time zones; the chief's reply, that time zones are the open question and it will ask an advisor; its cf task add for the advice, T-6, with what the command printed; the advisor's result on T-6, to send at 08:00 in each household's own time zone; and the chief's next step.
The chief's History, searched for “time zone”: your words, the chief's, a command it ran, and the advisor's answer.

Project settings

One dialog for each project
Project settings holds the project's staff and backups, own hands, human approval, wake-up calls and specs. New project offers the same, so a project can start with them set. Right-click a project in the sidebar to rename it, or to give it a one-line description that no agent is told.
Compaction
A size from 250,000 to 1,000,000 tokens at which each member's harness compacts its conversation, or the harness's own point. A new project starts at 300,000.
Prompt suggestion and the advisor tool
Prompt suggestion controls Claude Code's next-prompt guess for the chief and members; Advisor tool controls Claude Code's own advisor tool for members. Both are off by default; when on, Claude Code follows its own settings.
Wake-up calls
A chief that stopped while work is left carries on: you set how often it is asked, and what it says.

You stay in charge

Tell, pause and resume
A tell lets a member keep working and reaches its window at the next rest. A pause stops the task and can ask a question; resume sends it on in the same window.
Notes without interruption
ConsensFlow types notes that need the chief's attention into its window. Other status notes are there for the chief in cf inbox.
Resume after a quit or update
Resume a project to bring its windows back on their conversations. A member cut mid-turn is told to go on; a window that cannot come back has its task paused, with the reason.
Your approval, if you want it
Turn on human approval for a project, and every message between agents waits for you to pass it on.
Project settings, below the staff: Compaction, at a size of 300000 tokens, with Save compaction; Advisor tool, off, with Save advisor tool; Prompt suggestion, off, with Save prompt suggestion; Do with your own hands, off, with Save own hands; Human approval, a checkbox alone, off, with no Save; Wake-up calls, on, every 2 hours, saying Do you still have work to do? If tasks are left on the board or in your plan, carry on., with Save wake-up calls; and Specs, on, in the folder .specs, with the Specmint variant core and Save specs.
Project settings, below the staff: compaction, Claude Code's advisor tool and prompt suggestion, own hands, human approval, wake-up calls, here every two hours, and specs.
Three terminals of the staff side by side, each on its task. The frontend designer's Codex session building the shopping list page: the files it edited, its tests, and Working. A worker's Pi session on the decimal bug: the grep and the file that rounds quantities, then cf ask putting a question to the chief, and the agent waiting for the answer. A worker's Claude Code session seeding a demo household: the files it read and wrote, npm run seed twice, and its progress.
Each task in its own window: the frontend designer's Codex session on the list page, a worker's Pi session that asked the chief a question and waits for the answer, and a worker's Claude Code session seeding test data.

Before you start

Your data, and what the agents can do

  • ConsensFlow keeps its data in ~/.consensflow (on Windows, %USERPROFILE%\.consensflow).
  • It never sees your passwords: each agent uses its own harness's login.
  • Agents work with full permissions in their windows, as they would if you ran them yourself. Your protection is the review, the chief's acceptance and, if you turn it on, your approval. Use ConsensFlow on projects kept in version control.
  • Every agent, the chief and its staff alike, starts with its harness's MCP servers and connectors (your browser, your accounts, your IDE), skills, settings and customizations, as it would if you ran it yourself. The staff use them with full permissions while you aren't watching, so keep in a harness only what you would let any agent use.

Open source, MIT

ConsensFlow is free, and its source is on GitHub under the MIT license, with every release and its notes. Its engine is written in Rust.