OpenFlow 1.2.2

• Eval corpus — six fixed canvases run the same way each release, a scorer that reads run logs into a scorecard, and the first recorded baseline.
• Round checkpoints and ledger — commit the working tree after each round under a ref, record what each round produced, and measure stalling off that record rather than off the task text.
• Run resilience — survive a provider blip mid-run, and announce when a run ends on a channel the user turned on.
• Line counts — count the lines each card changed, measured off git rather than asked of the card.
• Completion — a card is done when it did the work, not when it stopped talking.
• Per-card working copies — give every card in a batch its own working copy when the canvas asks for it.
• Routed-model warning — warn when a dispatching card runs on a routed model.
• Runs menu — legible rows, delete, prune, search.
• Canvas — select many cards at once; the plain canvas drag pans again.
• Non-git projects — stop blaming a stale engine for a project that is not a git repository; offer git init instead.
• Track only the shipped templates under .openflow.

Full changelog: packages/flow/CHANGELOG.md

OpenFlow 1.2.1

OpenFlow 1.2.1

• keep swarm/orchestration cards out of each other's files: pre-batch refusal on declared overlaps, post-batch collision report to the orchestrator
• warn about swarm peers with nothing to disagree about, and peers that can write files
• pick up a run the browser tab abandoned instead of starting it over
• gauntlet: survive rate limits, count what they cost, refuse to certify unjudged work

Full changelog: https://github.com/SeeRay11/OpenFlow/blob/dev/packages/flow/CHANGELOG.md

OpenFlow v1.2.0

Execution modes

A canvas now has a mode, and it changes what the graph does when you run it.

• Swarm — every card is a peer. They answer the same task in parallel, then debate over a fixed number of rounds, each round reading the last round's messages from every other peer. A dedicated synthesizer card reads the whole debate and writes the verdict.
• Orchestration — the graph is a tree. An orchestrator card dispatches work to its child cards, one task each, and a child with children of its own orchestrates its own subtree the same way. Bounded by depth and dispatch caps so a run can't fan out without limit.
• Pipeline — unchanged. Every canvas saved before this release runs exactly as before.

Preflight prints the session count before any run, because a swarm is agents × rounds + 1 sessions and an orchestration compounds per level.

v1.1.1

Changes since v1.1.0

• docs(flow): document FLOW_MANAGE_SERVER in the run command (#5)
• fix(flow): probe free models live before picking a default (#4)
• fix: pin bun.lock to LF so a Windows clone installs clean (#3)
• docs: explain the database is locked engine failure
• chore(flow): bump version to 1.1.1

OpenFlow v1.1.0

Everything in this release is in packages/flow. No upstream OpenCode package is
modified, so merging upstream stays clean.

MCP servers

A new MCP panel manages the project's servers — local stdio and remote http/sse —
writing them into the project's own opencode.json rather than a hidden OpenFlow
file. Each node picks which servers it may reach; the choice compiles to
<server>_* permission rules on that node's generated agent, so the allowlist is
enforced at runtime instead of being advisory.

Those rules can only be built from the project's server list, so OpenFlow now
refuses to write agents while that list is unreadable rather than emitting agents
with no rules at all — the case that would have quietly handed every node access
to servers it had been denied.

Runs

Prompt attachments: files and images can be attached to a whole run or to a single
card, and are carried as data: URLs, so no upload endpoint is involved. Models
that cannot read images are detected from the model's declared input capabilities
and told what was withheld instead of being handed something they will hallucinate
over.

In-run questions: a node can stop and ask, and the canvas surfaces a modal that
blocks until you answer. Opt in per node. The timeout rejects rather than guesses —
an invented answer would be treated as your intent, which is worse than none.

Runs also merge the current agent block into opencode.json before starting, so a
node never runs against a def that was edited but never merged. The write is
skipped entirely when nothing changed, so repeated runs neither rewrite the file
nor leave a backup.

Canvas and project

• Skills can be authored from the canvas, written to .openflow/skills/<name>/SKILL.md
  and self-registered in the project config.
• The project folder can be picked through the OS file explorer.
• OpenFlow reopens the project folder you had open, and within it the pipeline you
  were last editing.
• Panel buttons no longer overflow their container.

Note

OpenFlow is an independent project and is not affiliated with, endorsed by, or
sponsored by the OpenCode project or its maintainers.

OpenFlow v1.0.0

OpenFlow — a visual builder for multi-agent AI workflows. Drag role cards onto a canvas, wire a pipeline (planner → architect → coder), save it, and run it with real parallel agents. Built on the opencode engine.

Install

Prerequisites: Bun 1.3+ and Git.

git clone https://github.com/SeeRay11/OpenFlow.git
cd OpenFlow
bun install

Run

./openflow.ps1   # Windows (PowerShell)
./openflow.sh    # macOS / Linux

Starts the engine, waits for it to listen, then opens the canvas at http://localhost:5174. Ctrl+C stops both. Point agents at another repo with -Project <dir> (PowerShell) / -p <dir> (shell); add -Built / -b to serve the built bundle.

Before the first run: log in a provider (opencode auth login, a provider env var, or OPENCODE_AUTH_CONTENT) — Flow inherits the server's credentials. Set OPENFLOW_PROJECT to the repo the agents should work in; these agents write real files.

Full docs in the README and packages/flow/README.md.