The idea of a leaderless multi-agent system — where autonomous agents coordinate through shared state rather than answering to a central orchestrator — has quietly become one of the more provocative questions in distributed AI architecture. A recent Hacker News post by developer har-ki put the question directly to the community: has anyone actually built one in production?
The Case Against the Orchestrator
Frameworks like LangGraph and CrewAI have become the default way developers wire together multiple AI agents. They provide structured workflows, deterministic state transitions, and a central coordinator that manages the flow of information between specialized components. For most teams, this is the path of least resistance. But har-ki argues it may also be the wrong one.
The alternative model draws from a simple observation: distributed systems have operated without central supervisors for decades. Databases achieve consensus through protocols like Raft and Paxos. Message queues route tasks through worker pools. None of these systems rely on a single conductor to manage every interaction. So why should AI agents be any different?
In a leaderless architecture, each agent reacts to its own inputs and coordinates only through shared state. There is no supervisor directing which agent should act next. The agents are autonomous, and the system's behavior emerges from their interactions rather than from a pre-written control flow.
A Practical Use Case
The context for this question is more concrete than abstract theory. Har-ki previously described running Claude Code as an AI site-reliability engineer handling an incident from start to finish. That single-agent approach worked, but the system is being rebuilt as four agents working simultaneously on the same incident — each responsible for a distinct phase: detect, diagnose, remediate, and communicate.
This decomposition is telling. Rather than one generalist agent moving through a pipeline, four specialists operate concurrently, each pulling from and pushing to a shared state. The detect agent monitors for anomalies. The diagnose agent correlates signals. The remediate agent applies fixes. The communicate agent updates stakeholders. No agent waits for permission from a supervisor; they each act when their own inputs trigger them.
Why It Matters for Production Systems
The practical appeal is scalability and resilience. A central orchestrator becomes a bottleneck — and a single point of failure. If the coordinator goes down, the entire system halts. In a leaderless design, the failure of one agent does not necessarily cascade. Other agents continue operating as long as they can access the shared state.
There are also latency implications. Orchestration frameworks add overhead: each step must pass through the coordinator, which serializes what could otherwise be parallel work. For incident response, where every second counts, that overhead compounds.
But the trade-offs are real. Without a central coordinator, debugging becomes harder. When four agents are acting simultaneously on shared state, race conditions and conflicting actions become possible. The developer loses the narrative clarity of a step-by-step pipeline and instead faces emergent behavior that is harder to predict and reproduce.
The Open Question
What har-ki's post ultimately surfaces is not a technical problem but an architectural philosophy question. The existing ecosystem of agent frameworks is overwhelmingly orchestrator-centric. Tools like LangGraph enforce a graph-based execution model where a node manager decides the next step. CrewAI assigns roles and delegates tasks through a designated lead agent. These patterns work, and they are well-documented. Moving to a leaderless model means giving up that structure in exchange for something more distributed — and less understood.
The community response was thin at the time of posting, with only a single point and no comments beyond the original question. That silence may reflect the novelty of the approach rather than its impracticality. The few teams attempting this architecture are likely doing so quietly, without the visibility that generates public discussion.
For developers experimenting with multi-agent systems today, the choice is still binary: use an existing orchestrator or build custom coordination logic from scratch. The leaderless approach occupies the space between those options, and it remains to be seen whether the tooling will catch up to the architecture.