October 12, 2026
Multi-agent design is drifting away from the supervisor pattern. Instead of one orchestrator node delegating to workers, newer systems let agents hand off to each other directly — each hop's output chooses the next hop, and routing emerges from the swarm rather than descending from a leader. The appeal is real: no bottleneck hop, no single point of failure, no supervisor prompt trying to hold the whole plan in its context.
But "no leader" removes the node, not the need for steering. And that distinction becomes very concrete the first time a leaderless run goes sideways and you look for somewhere to intervene.
A supervisor graph has a natural intervention point: the supervisor. When a run goes wrong, the fix is usually a prompt tweak or a routing rule on that one node — the place where global decisions were already being made is the same place you apply yours.
In a leaderless graph there is no such node. Every hop routes on its own output — semantic decisions made at runtime, by whichever agent happens to be executing. When the swarm takes a wrong turn, no single agent's prompt contains the mistake, because no single agent made a global decision. The mistake is in the topology — which agents can hand off to which — and the topology is the only thing left to fix.
Which creates a fork in the design space. If the topology is frozen while a run executes — compiled, snapshotted, or checkpointed — then your entire control surface for a misbehaving swarm is the kill switch. If the topology is mutable mid-run, the canvas is a steering wheel.
Here's the counterintuitive part: decentralized execution needs more central visibility, not less. In a supervised system the leader is a place where global state is already collected — observability arrives as a side effect of control. Remove the leader and nothing anywhere sees the whole run, unless you deliberately build the one place that does.
The live canvas is that place — but only if it's a control surface, not just a window. A read-only visualization over a leaderless run is the frustrating version of a panopticon: you can watch every hop take the wrong path in perfect detail and do nothing about it. Most agent tools ship exactly that — beautiful traces, inert canvas. Watching is easy; acting on what you see requires the graph itself to be writable during execution.
LiveGraph's per-hop engine makes that cheap: the graph is re-read from the database after every hop, so an edge you drag while a run is in flight is the edge the next hop follows. In a leaderless swarm this is the difference between "restart the run and hope" and "steer the run you have."
There's a second payoff that gets less attention: live-editing makes agent decisions testable at runtime. New frameworks keep appearing to make agent behavior more testable — decision assertions, trajectory checks, eval harnesses — because the industry is maturing past "did it produce output" toward "did it make the right call."
Live-editing is the runtime version of that idea. The router agent makes a call you disagree with — reroute it and watch the consequence, without throwing away the run's accumulated state. Every hop of context the run already built survives the intervention. A restart forfeits it; a checkpoint rollback forfeits some of it; a mid-flight edge drag forfeits nothing. You're not re-running the experiment — you're correcting the subject mid-experiment.
For a CI/CD pipeline this is the difference that matters most. An improvement loop is leaderless by nature: an engineer agent works a queue item, CI routes its own verdict, a reviewer decides merge-or-fix-round — no single hop is in charge. The observed failure mode is an agent burning its fix rounds on the wrong approach. On a static pipeline you restart the run or eat the failure. On a live canvas you watch hop three take the wrong turn, drag the next hop to a different agent — or insert a constraint hop with the context it was missing — and the run continues with everything it already learned.
pinned mode, which snapshots the graph at creation and ignores edits. That's the reproducibility you want when nobody's watching. live is for runs a human is actually attending — chat, the canvas Run button, and the loop round a merge just kicked off.The frame worth keeping: the more leaderless the execution, the more the canvas matters — because it's the only place left where a person can act. A decentralized system with an inert canvas isn't autonomous. It's just unsteerable.