Many agents, one considered answer.
Converging on one answer, handing work down a line, flagging disagreement: these are common patterns. What's different here is that each handoff is a visibility grant you can see on an auditable map. Every mode is built on real independence, because each agent only sees what you grant it.
Coordination only means something if the agents are independent.
Agents that read each other tend to anchor: the second voice leans on the first, and a room of models collapses into one opinion wearing several names. PolyphonyAI starts from the opposite place. Agents are isolated by default, so when they do converge, chain, or disagree, it is because they genuinely arrived there, not because they copied each other.
That is why orchestration here rests on the visibility layer. The coordinator decides what each agent sees at each step, and the server enforces it.
Ask the room. Get one answer.
Put the same question to a bench of agents and get a single result back: a tallied vote when the choice is constrained, or a synthesized merge when a passive agent reads every reply and reconciles them into one considered answer.
The agents answer without seeing each other, so each answer comes from independent context. The result is saved as its own message, visible to the agents that took part.
Hand a goal down a line of agents.
Run agents in a defined order, where each stage sees exactly the output of the one before it. A researcher's findings flow to an architect, whose plan flows to a builder, whose work flows to a reviewer, each handoff happening on its own.
Each handoff is an explicit visibility grant, not an open scratchpad every agent can read. That means the pipeline shows up in the visibility map: you can see, and audit, exactly what each stage was given. Each stage runs on its own branch and hands its output to the next.
When they disagree, you hear about it.
When several agents answer the same question, PolyphonyAI checks whether they actually agree. It surfaces where agents genuinely disagree by comparing their positions, not just their wording, all on-device with no API call and nothing leaving your machine. When answers pull apart, a passive referee reads them and reports the conflict: which agents, which claims, quoted so you can check.
Because the agents answered without seeing each other, a disagreement is a real difference of view, not an artifact of one anchoring the next. You decide, instead of missing the contradiction.
Coordinate in stages, not all at once.
Timing is part of coordination. You decide which agents work together and the moment each one learns what. Run a blind first pass and reveal everyone's answers only after, or hand a reviewer the work only once it has committed to an opinion. Because visibility is re-checked on every turn, staging a conversation is just deciding when each grant opens.
One coordinator on the server, built on primitives that already ship.
Coordination runs server-side, in one place, so every mode resolves the same deterministic way. Each mode is assembled from the same pieces that power the shared conversation.
Coordination and control are the same idea.
Every mode here is built on selective visibility. Read how that layer is enforced, or see where orchestration sits in the whole system.