Coordination Without a Central Orchestrator: Emergent Order in Decentralized Multi-Agent Systems

In Tutorials I through III, we developed the machinery for agents to discover each other, form coalitions, build trust, evaluate capabilities semantically, and align economic incentives. But throughout every worked example, one structural assumption remained unchallenged: a single orchestrator agent Ω sat at the center of every coalition, decomposing tasks, assigning roles, aggregating results, and making all coordination decisions. The orchestrator was the brain; every other agent was a limb.

This tutorial confronts the question of what happens when Ω is removed, or more precisely, when no agent has the right to assume the orchestrator role. In the open agentic web, agents are operated by different organizations with different trust levels, economic incentives, and operational constraints. Designating any single agent as orchestrator creates a concentration of authority that may be unacceptable, infeasible, or fragile. The question becomes: can a coalition coordinate itself?

The answer draws from five decades of distributed systems research, three decades of multi-agent systems theory, and a rapidly emerging body of work on LLM-based collective intelligence. Under the right conditions, decentralized coordination is not only possible but more resilient, more scalable, and more adaptable than centralized alternatives. But the conditions matter enormously. Without careful protocol design, decentralized coordination degrades into oscillation, deadlock, or strategic exploitation by self-interested agents.

1. The Orchestrator Bottleneck — Why Central Control Fails at Scale

The orchestrator pattern (Tutorial I, Section 5) is intuitive: a single agent Ω receives a task, decomposes it into sub-goals, discovers and recruits specialists, monitors their execution, handles failures, and aggregates results. This is the dominant architecture in every major multi-agent framework (AutoGen, CrewAI, MetaGPT, LangGraph), and for good reason: it simplifies coordination to a series of one-to-many interactions. The orchestrator maintains global state, and every other agent only needs to communicate with Ω.

But the pattern carries structural liabilities that become acute as systems scale beyond controlled environments into open, cross-organizational networks.

The distributed systems literature quantifies these problems precisely. Yang et al. (NeurIPS 2025) demonstrated that AgentNet, a fully decentralized DAG-structured framework where LLM agents route tasks autonomously via local routing strategies, significantly outperformed centralized multi-agent systems in task efficiency, adaptability, and fault tolerance. Their key insight was that removing the central orchestrator allowed agents to specialize dynamically and adjust connectivity based on task demands, capabilities that star-topology coordination fundamentally precludes.

A 2025 industry survey reinforces this: contract net protocols (the decentralized ancestor of modern agent negotiation) remain the most widely deployed coordination mechanism in production multi-agent systems, used in 47% of deployments, while market-based approaches account for 29% and distributed constraint optimization covers 18%. Fully centralized orchestration, despite its dominance in research prototypes, is the minority pattern in systems that must actually survive in production.

The goal of this tutorial is to provide the theoretical foundations and practical protocols for removing Ω: not by ignoring the need for coordination, but by distributing it across the coalition itself. We will examine four complementary approaches: consensus protocols, stigmergic coordination, peer-to-peer negotiation, and learning-based emergent coordination. Each has different trade-offs; production systems will layer them, just as discovery protocols are layered (Tutorial I, Section 3).

2. Formal Foundations — Dec-POMDPs and the Complexity Wall

Before examining solution strategies, we need to understand why decentralized coordination is fundamentally hard: not merely inconvenient, but computationally intractable in the general case. The standard formal framework is the Decentralized Partially Observable Markov Decision Process (Dec-POMDP), which generalizes the single-agent POMDP to teams of cooperative agents with local-only observation.

The fundamental theorem of Dec-POMDP complexity, established by Bernstein et al. (2002), is sobering:

Moving from centralized (POMDP) to decentralized (Dec-POMDP) control raises worst-case complexity by an exponential step. The infinite-horizon case is undecidable. This is not an artifact of formalization; it reflects a genuine information-theoretic barrier: without shared observations, agents must reason about what other agents might be observing and doing, creating a recursion of beliefs about beliefs (the "I think you think I think" problem) that scales combinatorially.

Three structural relaxations are particularly relevant to agentic systems:

The remainder of this tutorial examines four families of coordination mechanisms, each of which exploits one or more of these relaxations. We will see that communication-based consensus, stigmergic shared state, negotiation protocols, and learned coordination strategies are not competing approaches but complementary layers in a coordination stack.

3. Consensus-Based Coordination — Reaching Agreement Without Leaders

The most direct approach to orchestrator-free coordination is consensus: a protocol by which distributed agents converge on a shared decision despite having only local information and local communication. Consensus is the bedrock of distributed computing, underlying Paxos, Raft, and every blockchain, and its adaptation to multi-agent AI systems provides the first building block for leaderless coalitions.

3.1 Weighted Belief Fusion for Agent Coalitions

In our domain, the "values" that agents must agree on are not numbers but beliefs: about the task decomposition, about subtask assignments, about intermediate results, and about the overall plan. Each agent enters the coalition with a partial view: ClinEvidence knows about evidence synthesis workflows, GenomicsAgent understands variant analysis requirements, and PolicyReasoner knows coverage determination logic. These partial views must be fused into a coherent shared plan.

The SEEK-Multi framework (IJSRA, 2026) formalized this as a weighted belief fusion protocol for multi-agent coordination. At each round, agent i updates its belief b_i(v, t) over a set of propositions v (e.g., "subtask T2 should precede T3", "the genomic analysis requires pharmacogenomic extension"):

where the weights w_ij satisfy Σ_j w_ij = 1, encode the trust that agent i places in agent j's beliefs, and can be derived from the reputation scores developed in Tutorial II (Trust Without a Central Authority, Section 6). The convergence theorem guarantees that if the communication graph is connected, all agents converge to the same belief vector b*, and the convergence rate is bounded by ||b(t) − b*|| ≤ λ₂(W)^t · ||b(0) − b*||.

3.2 Consensus for Task Decomposition and Assignment

How does consensus apply to the concrete problem of task decomposition? In the orchestrated model, Ω decomposes the prior authorization request into sub-tasks T1 (evidence synthesis), T2 (genomic analysis), T3 (policy reasoning), and T4 (form generation). In the leaderless model, decomposition itself must be consensual.

// Phase 1: Each agent proposes a task decomposition based on its expertise
on CoalitionFormed(task, members):
    my_decomposition = propose_decomposition(task, my_capabilities)
    // ClinEvidence proposes: [evidence_review, grade_assessment]
    // GenomicsAgent proposes: [variant_analysis, pharmacogenomic_check]
    // PolicyReasoner proposes: [policy_lookup, coverage_determination]

    broadcast(members, DecompositionProposal { 
        agent: self.id,
        subtasks: my_decomposition,
        confidence: 0.85,     // how confident am I in this decomposition?
        dependencies: my_deps   // which subtasks must precede which?
    })

// Phase 2: Belief fusion over received proposals
on ReceiveProposals(proposals[]):
    // Build a unified task graph by merging all proposals
    // Weight each proposal by the proposer's reputation and domain relevance
    merged_graph = empty_task_graph()
    for p in proposals:
        weight = reputation(p.agent) * domain_relevance(p.agent, task)
        merged_graph.merge(p.subtasks, p.dependencies, weight)

    // Phase 3: Iterative consensus on the merged graph
    for round in 1..MAX_ROUNDS:
        broadcast(members, BeliefUpdate { graph: merged_graph, round: round })
        neighbor_graphs = receive_all(members, BeliefUpdate)
        merged_graph = weighted_fusion(merged_graph, neighbor_graphs, trust_weights)
        
        if convergence_check(merged_graph, neighbor_graphs, ε=0.01):
            break  // consensus reached

    // Phase 4: Self-assignment — each agent claims subtasks matching its skills
    my_tasks = merged_graph.subtasks.filter(t => capability_match(t, self) > 0.8)
    broadcast(members, TaskClaim { agent: self.id, tasks: my_tasks })

    // Phase 5: Conflict resolution via second consensus round
    // If two agents claim the same subtask, resolve by capability score

The critical observation is that the decomposition protocol has three phases (propose, fuse, and claim), and each phase involves only peer-to-peer communication. No agent acts as a central authority. The fusion step naturally incorporates domain expertise: GenomicsAgent's proposal about genomic sub-tasks carries more weight than ClinEvidence's opinion about genomics, because GenomicsAgent has higher domain relevance for those tasks.

3.3 LLM Agents and Consensus: Empirical Results

Kaesberg et al. (ACL 2025) conducted one of the first systematic comparisons of consensus-based versus voting-based decision protocols for LLM agent groups. Their study tested seven distinct protocols across knowledge-based and reasoning tasks using Llama-3 (8B and 70B) agents. The results were nuanced: consensus-based protocols (where agents iteratively discuss until agreement) and voting-based protocols (where agents independently vote after fixed-length deliberation) achieved comparable performance, but with fundamentally different failure modes. Consensus protocols converged more slowly, requiring 2–3× more communication rounds, but produced higher-confidence decisions when they did converge. Voting protocols were faster but susceptible to cascading errors when the majority happened to be wrong.

For coalition coordination in the agentic web, this suggests a hybrid strategy: use fast voting for low-stakes coordination decisions (e.g., which output format to use) and deliberative consensus for high-stakes ones (e.g., task decomposition, subtask dependency ordering). We will formalize this hybrid approach in Section 9.

4. Stigmergic Coordination — Indirect Communication Through Shared State

Consensus requires direct message exchange. Stigmergy achieves coordination without direct communication at all. Coined by the French biologist Pierre-Paul Grassé in 1959 to describe termite nest construction, stigmergy is coordination through environmental modification: agents leave traces in a shared environment, and those traces influence the behavior of other agents. Ant pheromone trails are the canonical example: ants do not communicate the location of food to each other; they deposit pheromones on paths they've walked, and other ants probabilistically follow stronger trails.

4.1 The Shared Task Board — Stigmergy for Agent Coalitions

In multi-agent AI systems, the "environment" that mediates stigmergic coordination is a shared data structure such as a distributed task board, a shared knowledge graph, or an artifact registry. Agents post work products, status updates, capability gaps, and intermediate results to this shared state. Other agents read the shared state and adjust their behavior accordingly. No direct negotiation is required.

// The Shared Task Board (STB) is a distributed, eventually-consistent store
// accessible to all coalition members. It replaces the orchestrator.

struct TaskBoard {
    task_graph:     DAG<Subtask>,       // the agreed decomposition
    claims:         Map<SubtaskId, AgentId>,  // who is working on what
    artifacts:      Map<SubtaskId, Artifact>, // completed work products
    capability_gaps: List<CapabilityGap>,     // unresolved needs (like pheromone trails)
    heartbeats:     Map<AgentId, Timestamp>,  // liveness signals
}

// Each agent runs an autonomous loop: observe → decide → act → post
function agent_loop(self, board: TaskBoard):
    loop:
        // 1. Observe: read the board's current state
        state = board.snapshot()

        // 2. Decide: find unclaimed subtasks that match my capabilities
        available = state.task_graph.subtasks
            .filter(t => t.id not in state.claims)
            .filter(t => t.dependencies_met(state.artifacts))
            .filter(t => capability_match(t, self) > 0.7)

        if available.is_empty():
            // Check for capability gaps I can fill (pheromone following!)
            gap = state.capability_gaps.find(g => can_address(g, self))
            if gap:
                // Create a new subtask to address the gap
                new_subtask = create_subtask_from_gap(gap)
                board.atomic_insert(task_graph, new_subtask)
                board.atomic_claim(new_subtask.id, self.id)
            else:
                sleep(POLL_INTERVAL)
                continue
        else:
            // 3. Act: claim the best-matching subtask (atomic CAS operation)
            target = available.best_match(self)
            success = board.atomic_claim(target.id, self.id)
            if !success: continue  // another agent claimed it first — retry

            // 4. Execute the subtask
            result = self.execute(target, inputs=gather_inputs(state, target))

            // 5. Post: write the artifact to the board
            board.post_artifact(target.id, result)

            // 6. Signal capability gaps if discovered during execution
            if result.gaps:
                for gap in result.gaps:
                    board.post_capability_gap(gap)  // ← the "pheromone deposit"

        // 7. Heartbeat: signal liveness
        board.update_heartbeat(self.id, now())

The capability gap mechanism is the digital equivalent of pheromone deposition. When GenomicsAgent discovers the CYP2D6 poor metabolizer status and recognizes a need for drug interaction analysis (Tutorial I, Section 5, Phase 3), it does not need to negotiate with an orchestrator. It simply posts a CapabilityGap to the shared board, leaving a trace in the environment. A DrugInteractionAgent, running its own autonomous observe-decide-act loop, eventually reads this gap, determines it can address it, creates a new subtask, claims it, and executes. The coalition grows not through centralized command but through environmentally mediated self-organization.

4.2 Emergent Collective Memory

Recent research demonstrates that stigmergic coordination produces emergent properties beyond mere task routing. Investigations into decentralized multi-agent frameworks with multi-categorical environmental traces (arXiv:2512.10166, December 2025) found that agents operating with stigmergic communication develop a form of collective memory that exists not in any single agent but in the distributed pattern of traces they leave. In the prior authorization setting, the shared task board gradually accumulates not just completed artifacts but a navigable record of how the coalition solved the problem: which gaps were discovered, which agents filled them, and which dependency orderings worked. This collective memory is available to future coalitions, enabling cross-coalition knowledge transfer (the gossip-based knowledge propagation from Tutorial I, Section 7) at the level of coordination strategies, not just agent identities.

5. Peer-to-Peer Negotiation — From Contract Nets to LLM Agents

Consensus produces shared beliefs. Stigmergy enables indirect coordination. But many coordination decisions require explicit negotiation: agent A offers to perform a subtask, agent B counter-offers a different scope, agent C argues for a different dependency ordering. When agents have heterogeneous preferences, private cost structures, and strategic interests, negotiation is the natural coordination primitive.

5.1 The Contract Net Protocol — The Classic Foundation

The intellectual ancestor of agent negotiation is the Contract Net Protocol (CNP), introduced by Smith & Davis in 1980 and still, forty-five years later, the most widely deployed coordination mechanism in multi-agent systems. The CNP defines three roles: a manager (who needs work done), contractors (who bid to do the work), and the protocol (announce → bid → award → execute).

The key insight of CNP for our purposes is that the manager role rotates with the task rather than remaining a fixed assignment. Any agent can be a manager for the subtask it identified, and a contractor for subtasks identified by others. This distinguishes CNP from orchestration: there is no permanent Ω. Authority is task-local.

// Any agent that identifies a subtask becomes its temporary manager
function peer_contract_net(subtask, coalition):
    // The identifying agent acts as manager for THIS subtask only
    manager = self  // whoever found the need is the manager

    // Step 1: Announce — broadcast the task to all coalition peers
    announcement = TaskAnnouncement {
        subtask:     subtask,
        manager:     self.id,
        deadline:    subtask.deadline,
        constraints: subtask.constraints,
    }
    broadcast(coalition, announcement)

    // Step 2: Collect bids — peers assess and respond
    bids = collect_with_timeout(coalition, Bid, timeout=5s)
    // Each bid includes: agent_id, estimated_cost, estimated_quality,
    //   estimated_latency, capability_evidence (VC from Tutorial II)

    // Step 3: Award — select the best bidder
    // Use the multi-attribute scoring from Tutorial III, Section 3.2
    winner = bids.max_by(b => multi_attr_score(b, weights={
        quality:  0.4,
        cost:     0.25,
        latency:  0.2,
        trust:    0.15,
    }))

    send(winner.agent_id, Award { subtask: subtask })
    broadcast(coalition, AwardNotification { subtask: subtask, winner: winner })

    // Step 4: The manager's role ends when the subtask is assigned
    // The winner executes independently and posts results to the board
    return winner

// Example: GenomicsAgent detects CYP2D6 gap → becomes manager for T2b
// GenomicsAgent broadcasts TaskAnnouncement for "drug interaction analysis"
// DrugInteractionAgent bids → GenomicsAgent awards → manager role dissolves

5.2 LLM Agents as Natural Language Negotiators

The Contract Net Protocol assumes structured messages such as bids, awards, and rejections that follow rigid schemas. LLM agents introduce a transformative capability: they can negotiate in natural language, making nuanced arguments about why they should or shouldn't take a subtask, proposing creative reformulations of the problem, and reaching agreements that no pre-defined schema could capture.

The supply chain consensus-seeking framework (Taylor & Francis, December 2025) demonstrated this concretely. LLM agents acting as decentralized supply chain actors negotiated order quantities through natural-language exchanges, achieving consensus that outperformed centralized demand-driven allocation, even though each agent pursued selfish economic incentives (EOQ-based ordering). The agents developed emergent negotiation strategies: early concessions to build goodwill, conditional offers ("I'll increase my order if you extend the delivery window"), and appeals to shared metrics.

The practical implication is that negotiation protocols for the agentic web should be structured but extensible: a rigid schema for commitments (bids, claims, deadlines) supplemented by natural-language fields for justification, counter-arguments, and context. The schema ensures accountability; the natural language enables nuance.

6. Learning-Based Coordination — Emergent Protocols via Multi-Agent RL

The three approaches examined so far (consensus, stigmergy, and negotiation) are designed coordination protocols: humans specify the rules, and agents follow them. An alternative paradigm is learned coordination: agents discover effective coordination strategies through experience, using multi-agent reinforcement learning (MARL). The appeal is that learned protocols can adapt to specific task domains, agent populations, and environmental dynamics in ways that hand-crafted protocols cannot.

6.1 Centralized Training, Decentralized Execution (CTDE)

The dominant paradigm in MARL is Centralized Training, Decentralized Execution (CTDE). During training, a centralized critic observes the global state and all agents' actions, providing rich gradient signals. During deployment, each agent executes its learned policy using only local observations. The critic is discarded. This is analogous to a team that practices together with full visibility (the coach sees everyone's moves) but plays the game with each player making independent decisions.

CTDE elegantly sidesteps the NEXP-completeness of Dec-POMDPs by using centralized information only during training; the deployed system is fully decentralized. The trade-off is that the learned policies are optimized for the distribution of tasks and agent populations seen during training. When the distribution shifts (a new agent type joins, or a task domain changes), the policies may perform poorly.

6.2 Emergent Communication in Learned Agents

One of the most striking findings in MARL research is that agents trained to coordinate in partially observable environments spontaneously develop communication protocols. When given the ability to send discrete messages to teammates, agents learn to encode task-relevant information in these messages, effectively inventing their own signaling language. Graph neural networks and attention-based architectures allow agents to route messages to the most relevant peers, creating learned communication topologies that adapt to the task at hand.

6.3 The Coordination–Learning Tension

Learned coordination faces two fundamental challenges that designed protocols do not. First, the co-adaptation dilemma: when agent A updates its policy based on rewards, it changes the environment that agent B experiences, which may invalidate B's learned policy. Simultaneous learning by all agents creates non-stationary dynamics that can prevent convergence. Second, the credit assignment problem: when the coalition succeeds or fails, how should each agent's policy update reflect its individual contribution? This is precisely the Shapley attribution problem from Tutorial III (Section 4), manifesting at the level of gradient updates rather than economic payments.

For practical deployment in the agentic web, this suggests that purely learned coordination is most suitable for repeated, homogeneous tasks where agents can accumulate training experience, such as a fleet of form-filling agents that coordinate on standard prior authorization templates. For novel, heterogeneous tasks (a rare genomic variant requiring an unexpected agent coalition), designed protocols remain essential. The coordination stack must accommodate both.

7. Failure Modes — Deadlock, Oscillation, and Strategic Exploitation

Decentralized coordination introduces failure modes that simply do not exist in centralized systems. An orchestrator can deadlock only with itself; a decentralized coalition can deadlock in complex, multi-agent patterns that are difficult to detect and harder to resolve. Understanding these failure modes is essential for designing robust protocols.

7.1 Deadlock — Circular Waiting

Deadlock occurs when two or more agents are each waiting for a resource held by another. In the prior authorization setting, consider: ClinEvidence claims T1 but needs GenomicsAgent's output from T2 before it can complete. GenomicsAgent claims T2 but discovers it needs ClinEvidence's partial output from T1 (an unexpected bidirectional dependency). Neither can proceed. In the orchestrated model, Ω would detect this circular dependency and restructure the task graph. Without Ω, the coalition is stuck.

// Each agent maintains a local view of what it's waiting for
on WaitingForInput(dependency: SubtaskId):
    wait_record = WaitRecord { 
        waiter: self.id, 
        blocked_on: dependency,
        since: now() 
    }
    board.post_wait_record(wait_record)

// Periodic deadlock check — any agent can run this
function detect_deadlock(board):
    waits = board.get_all_wait_records()
    
    // Build a waits-for graph: agent → agent it's waiting for
    graph = build_waits_for_graph(waits, board.claims)
    
    // Detect cycles in the waits-for graph
    cycles = find_cycles(graph)
    
    if cycles:
        // Resolution: the agent with lowest reputation in the cycle
        // yields its claim (releases the subtask for re-assignment)
        for cycle in cycles:
            victim = cycle.min_by(agent => reputation(agent))
            board.release_claim(victim.claimed_subtask)
            board.post_event(DeadlockResolved {
                cycle: cycle,
                resolved_by: "lowest-reputation yield"
            })

7.2 Oscillation — The Symmetry Breaking Problem

Oscillation occurs when agents repeatedly switch between two or more states without converging. In the task claiming context: agent A claims T1, then agent B claims T1 (A's claim is revoked), then A re-claims T1, and so on. This is a manifestation of the symmetry breaking problem: when multiple agents are equally qualified and equally motivated, deterministic protocols cycle.

The LoopBench benchmark (arXiv:2512.13713, December 2025) studied this phenomenon directly by placing LLM agents in over-constrained graph coloring problems where greedy heuristics provably oscillate. The study found that advanced reasoning models (o3-series) could discover emergent symmetry-breaking strategies: in a "eureka" moment, agents independently developed patience-based "hold" policies that allowed the system to escape oscillation loops. The key mechanism was meta-cognitive reasoning: agents that could reflect on the interaction history ("we've been flipping back and forth for three rounds") developed asymmetric strategies that broke the deadlock.

7.3 Strategic Exploitation — Agents That Benefit from Ambiguity

In decentralized systems, the protocol itself is an attack surface. A strategic agent can exploit coordination ambiguity in ways that are impossible when a single orchestrator controls all assignments. Consider three exploitation strategies:

These attacks illustrate a principle articulated in the security literature: decentralization shifts the threat model from infrastructure attacks to protocol attacks. Centralized systems can be attacked by compromising the orchestrator; decentralized systems can be attacked by exploiting the coordination protocol itself. The defense is not to return to centralization but to design protocols that are incentive-compatible, meaning honest participation becomes each agent's dominant strategy. The mechanism design tools from Tutorial III (VCG auctions, Shapley attribution, staking) are the primary instruments here.

8. Worked Example — Orchestrator-Free Prior Authorization

We now replay the complete prior authorization scenario from Tutorial I, but with a fundamental change: there is no orchestrator Ω. The five agents (ClinEvidence, GenomicsAgent, DrugInteractionAgent, PolicyReasoner, and FormBuilder) must self-coordinate using the mechanisms developed in Sections 3–7. We use a hybrid coordination stack: consensus for task decomposition, stigmergy for execution coordination, and peer negotiation for conflict resolution.

9. Architectural Synthesis — A Coordination Stack for the Open Agentic Web

The four coordination mechanisms examined in this tutorial are not competing alternatives but complementary layers in a coordination stack. Each addresses a different phase of the coalition lifecycle and has different trade-offs in latency, robustness, and expressiveness.

The stack operates as follows during a coalition's lifecycle. At formation time, consensus (Layer 1) produces the shared task decomposition and assignment plan. During execution, stigmergy (Layer 2) handles routine coordination tasks (artifact posting, dependency resolution, and capability gap signaling) with zero direct messaging overhead. When conflicts arise (competing claims, unexpected dependencies, failed agents), negotiation (Layer 3) provides the escalation path for explicit peer-to-peer resolution. Over many coalitions, learning (Layer 4) refines each agent's routing decisions, specialization, and coordination behavior. The trust infrastructure (Tutorial II) provides the identity and reputation inputs for trust-weighted consensus, and the economic infrastructure (Tutorial III) ensures that participation in the coordination protocol is incentive-compatible.

10. Open Frontiers

10.1 Consensus Convergence Under Byzantine Agents

The belief fusion protocol in Section 3 assumes that every agent reports its true beliefs honestly. In adversarial settings, a Byzantine agent can report arbitrary beliefs to different peers, preventing convergence or steering the consensus toward a manipulated outcome. Zhu et al. (IEEE/CAA Journal of Automatica Sinica, July 2025) demonstrated that blockchain-based PBFT and Raft consensus algorithms can provide Byzantine fault tolerance for multi-agent coordination, but at significant communication cost. Adapting these approaches to LLM agent coalitions, where "beliefs" are natural-language task decompositions rather than numeric values, remains an open problem.

10.2 Shared State Consistency at Scale

The stigmergic shared task board requires eventual consistency across all coalition members. For small coalitions (5–10 agents), this is straightforward using CRDTs (Conflict-Free Replicated Data Types) or a lightweight distributed store. For coalitions spanning hundreds of agents across organizational boundaries with network partitions, maintaining consistency without a central database becomes a distributed systems challenge in its own right. The CAP theorem constrains the design space: the board can be consistent and available, or available and partition-tolerant, but not all three.

10.3 Emergent Role Hierarchies

Our protocol eliminates the permanent orchestrator but allows temporary roles (the convener in T₀, the rotating manager in contract net). Empirical studies of LLM agent groups consistently observe the emergence of informal hierarchies: some agents naturally take on coordinating roles even without explicit authority. Whether these emergent hierarchies are beneficial (efficient specialization) or harmful (re-centralization by the back door) depends on whether they remain fluid. Research into mechanisms that promote role rotation and prevent any single agent from accumulating persistent coordination authority is nascent.

10.4 Coordination Overhead Budgets

Amdahl's Law (Tutorial I, Section 8.3) applies to decentralized coordination even more severely than to centralized coordination. In the orchestrated model, the serial fraction is Ω's processing time. In the decentralized model, the serial fraction includes consensus rounds, contention resolution, and board synchronization latency. Quantifying the coordination overhead budget (the maximum fraction of total execution time that can be spent on coordination before the coalition becomes slower than sequential execution) and designing protocols that stay within that budget is an open engineering challenge.

10.5 Privacy-Preserving Coordination

In the healthcare prior authorization setting, the shared task board may contain protected health information (PHI) that is subject to HIPAA regulation. A fully shared board violates the minimum-necessary standard: FormBuilder does not need to see the patient's raw genomic variant data. Designing stigmergic coordination with selective disclosure, where each agent sees only the board entries relevant to its claimed subtasks, requires integrating the zero-knowledge credential infrastructure from Tutorial II (Section 4) with the shared state architecture. This intersection of privacy-preserving computation and decentralized coordination is a frontier challenge.

Coordination Mechanism Comparison Matrix