How the Pieces Talk

A distributed team only works if its members can stay in sync. OpenFlows uses three distinct communication channels, each solving a different problem. Understanding them clears up a lot of the "magic."

Channel A — The Controller talks to Coder

The Controller provisions workspaces and creates agent chat sessions over Coder's API. This is how the brain:

Hands a workspace to an agent ("this is your task"),
Starts and supervises the agent's session, and
Reads back progress.

This is the command-and-control channel: the brain assigns and supervises, Coder runs the machinery.

Channel B — The coordination store (durable state)

The coordination store is where durable facts live — tickets, worker availability, phases, approvals, reviews, pull requests, liveness. It is the single source of truth.

The important rule is about who may write:

The Controller writes planning, assignment, and fleet state.
The worker command surface is the only way an agent inside a workspace records its own phase, approvals, reviews, and heartbeats.

Nothing else writes. Writes are validated so that bad or out-of-order data is rejected rather than accepted. This is what lets every agent trust the store: there is exactly one consistent record, and only the right actors can change it.

Channel C — The live task relay (evidence exchange)

The store is great at expressing facts, but some work is a live task — most importantly, delegated verification: when SENTINEL (the reviewer) needs evidence that FORGE's tests pass, without touching FORGE's filesystem.

Diagram of the A2A live task relay: the reviewer's workspace dials out to the relay in the control plane, which checks an allowlist and routes a safe command to the builder's workspace, then mirrors the evidence back into the coordination store. — The A2A relay exchanges live evidence between workspaces and mirrors it back into the store.

For that, OpenFlows uses a small internal relay inside the orchestrator workspace:

SENTINEL submits a request: "run this safe, allowlisted command; here's the timeout and what we expect."
The relay checks the command against an allowlist and routes it to FORGE's workspace.
FORGE runs it in isolation and sends the result back.
The relay mirrors the result into the coordination store before acknowledging — so the evidence becomes a durable fact that can gate an approval.

Coder workspaces are good at calling out and bad at being called in, so both sides dial out to the relay. This makes the orchestrator the enforcement chokepoint: it knows who's allowed, what commands are safe, and it keeps the audit trail.

Keeping "facts" and "tasks" straight

The design rule that ties the channels together:

Facts live in the store; the relay gathers evidence

The coordination store is the single source of truth for durable facts. The live relay is used only for in-flight task exchange — and every result of that exchange is written back into the store before the task is treated as complete. The store stays authoritative; the relay is just a way to gather evidence to store.