Multi-LLM Coordination Architecture

• Multi-LLM coordination architecture is the design of inter-agent communication protocols, memory systems, and tool integration strategies to optimize collaborative performance.
• It encompasses various models—from centralized controllers to decentralized DAGs and shared-state substrates—that manage information exchange, conflict resolution, and efficiency.
• Research shows that well-designed coordination protocols can outperform simple agent scaling by reducing errors, lowering token usage, and maintaining stability under adversarial conditions.

Multi-LLM coordination architecture denotes the structural and algorithmic organization of multiple language-model agents: how they are wired together, how they exchange or withhold information, how disagreement is exploited without losing stability, how memory and tools are allocated, and how collective behavior is evaluated. Recent work treats the topic as a problem of graph design, protocol specification, shared-state management, and budgeted control rather than prompt engineering alone, with architectures ranging from centralized controller–expert systems to decentralized DAGs, shared-state substrates, typed negotiation exchanges, and formally projected communication protocols (Javed, 23 Feb 2026, Nguyen et al., 29 Mar 2026).

1. Design space and architectural dimensions

A broad synthesis is given by a four-dimensional taxonomy comprising architecture pattern, coordination mechanism, memory architecture, and tool integration (Nguyen et al., 29 Mar 2026). In that formulation, multi-LLM coordination architecture is the set of structural choices about how multiple language-model agents are organized, how they communicate and resolve conflicts, what they remember, which tools they call, and how all of this is evaluated. The same survey formulates the Coordination Primacy Hypothesis (CPH): inter-agent coordination protocol design is a primary driver of decision quality, often exerting greater influence than model selection, but it presents CPH as a falsifiable research hypothesis supported by tiered structural evidence rather than as an empirically validated conclusion (Nguyen et al., 29 Mar 2026).

Within this design space, a recurrent distinction is between architecture pattern and coordination mechanism. Architecture pattern concerns the topology of agents and control/data flow; coordination mechanism concerns who speaks when, what information is shared, how conflicts are resolved, and which agents are activated. The survey is explicit that these dimensions are independent: one can have hierarchical debate, role-based competition, or a pipeline with internal voting (Nguyen et al., 29 Mar 2026). This separation is important because it prevents topology from being mistaken for protocol.

Pattern	Structural form	Coordination consequence
Single-agent baseline	Monolithic workflow	One model handles the full pipeline
Hierarchical / role-based	Tree or star around manager	Specialists report upward; manager weighs conflicting inputs
Debate-based	Peer-to-peer or judge-mediated	Multi-round turn-taking critique
Pipeline	Fixed sequence	Low latency, minimal coordination, no intrinsic error correction
Market / competitive	Competing agents plus evaluator	Diversity maintained through competition

The same taxonomy also clarifies a common misconception: adding more agents is not, by itself, a coordination strategy. The survey notes that increasing agent count without optimizing the coordination topology yields diminishing returns and increased interference, which reframes scaling as an orchestration problem rather than a mere multiplicity problem (Nguyen et al., 29 Mar 2026).

2. Organizational topologies and communication substrates

The literature spans several concrete topological families. A centralized controller–expert design is exemplified by CoRL, where a controller LLM selectively coordinates a frozen pool of expert models and treats expert invocations as structured tool calls embedded in a multi-step text trajectory (Jin et al., 4 Nov 2025). A closely related but more explicitly adaptive pattern appears in document understanding systems that build a task dependency graph, assign subtasks to role agents, trigger parallel execution for ambiguous subtasks, and use an evaluator agent plus feedback bus for revision and rerouting (Xia et al., 22 Jul 2025). In both cases, orchestration authority is concentrated, but the control surface differs: CoRL learns a budget-conditioned policy over expert calls, whereas the document-understanding framework uses heuristic dynamic routing, bidirectional feedback, and evaluator-driven selection.

A second family is structure-guided orchestration. MACA casts coordination as posterior inference over structure and orchestration, learns a task- and budget-conditioned structural prior over agent participation and interactions, and then uses a policy-based orchestrator to approximate posterior inference under that prior (Li et al., 25 May 2026). The architecture therefore separates a learned prior over who may participate and communicate from the online policy deciding which agent to call next. This suggests a middle ground between fixed topologies and unconstrained controllers.

A third family is decentralized coordination. AgentNet removes the central orchestrator altogether and embeds routing and execution inside each agent as a dual-role node with a local router, a local executor, and role-specific RAG memories (Yang et al., 1 Apr 2025). Tasks are represented as states that move through a dynamically structured DAG, with forwarding, decomposition, and execution decisions made locally. In this setting, specialization emerges from evolving capability vectors, edge weights, and memory content rather than from a globally assigned plan.

A fourth family replaces message-centric coordination with shared-state observation. CodeCRDT uses a CRDT document as the coordination substrate, so agents coordinate by monitoring a convergence-guaranteed shared state rather than by explicit message passing (Pugachev, 18 Oct 2025). Observable updates, deterministic convergence, and monotonic progress become the central invariants; task allocation is implemented through an optimistic claim-and-verify protocol over shared TODO state rather than through manager-issued assignments. In a different direction, LLM-X provides a negotiation-oriented exchange substrate composed of federated gateways, topic-based routing, typed envelopes, and policy enforcement, thereby making direct LLM-to-LLM negotiation a systems problem of message routing and schema control rather than only a prompt-level interaction pattern (Lorenzoni et al., 12 May 2026).

These families are not mutually exclusive. Centralized planners can operate over shared-state blackboards, decentralized agents can still use typed exchanges, and structural priors can be layered over negotiation buses. The accumulated literature therefore describes coordination architecture less as a single blueprint than as a compositional stack of topology, substrate, and policy.

3. Agreement, correctness, and adversarial robustness

One research line formalizes coordination as a signed, directed dynamical system. In the graph-theoretic agreement framework, each agent has a scalar reasoning state

$$x_i(t)=\ln\left(\frac{P(v_+ \mid \text{context}_i)}{P(v_- \mid \text{context}_i)}\right),$$

derived from Transformer log-odds, and the joint dynamics satisfy

$\dot{x}(t)=-L_s x(t),$

where $L_s$ is the signed Laplacian of the interaction graph (Javed, 23 Feb 2026). Positive edges model reinforcement; negative edges model critique. The central result is that structural balance governs whether critique is stabilizing or frustrating. If every undirected cycle has positive sign, the graph is structurally balanced; if there is a cycle with an odd number of negative edges, the network is unbalanced and can exhibit divergence or persistent oscillation. The same framework shows that hidden prompts or unobservable latent states can behave as topological Trojan horses, because the visible verbal graph can appear balanced while the latent graph remains frustrated (Javed, 23 Feb 2026).

The same work introduces topological repair conditions. Restricting interaction graphs to chordal graphs allows polynomial-time Perfect Elimination Ordering verification, and rank-one spectral perturbations are used to break expertise symmetry and shift degenerate eigenvalues into the stable half-plane (Javed, 23 Feb 2026). It also distinguishes between bipartite consensus, which is stable but polarized, and unipolar consensus, which requires a single root SCC, structural balance, and unequal total expertise weights across the balance-induced factions. A related corrective theorem concerns “democratic” coordination: if all expertise weights are equal, average consensus requires strong connectivity, structural balance, and Laplacian balance; otherwise a seemingly democratic architecture can behave effectively as a dictatorial one (Javed, 23 Feb 2026).

A second research line addresses correctness at the protocol level rather than through spectral stability. The Message Sequence Chart framework introduces a domain-specific language in which global workflows specify messages, local actions, and owned control flow, while LLM computations remain opaque typed functions (Bollig et al., 19 Apr 2026). A syntax-directed projection generates local agent programs from the global specification, and the induced distributed programs are deadlock-free by construction. The significance of this separation is that coordination properties—deadlock-freedom, message typing, branch alignment—can be established independently of LLM nondeterminism (Bollig et al., 19 Apr 2026).

A third line studies explicitly adversarial environments. DecentLLMs separates worker agents, which generate answers concurrently, from evaluator agents, which score answers along five dimensions—factual contradiction, factual fabrication, instruction inconsistency, context inconsistency, and logical inconsistency—and then robustly aggregate those score vectors using the geometric median (Jo et al., 20 Jul 2025). The protocol is leaderless, uses Byzantine Reliable Broadcast, and assumes honest majorities in both worker and evaluator sets:

$$f_w < \left\lfloor \frac{N_w - 1}{2} \right\rfloor,\qquad f_e < \left\lfloor \frac{N_e - 1}{2} \right\rfloor.$$

This moves Byzantine tolerance away from leader rotation and toward concurrent proposal generation plus robust evaluation.

An alternative formalization draws on economic coordination rather than graph theory or protocol projection. In the market-making framework, a market-maker agent maintains a belief $p_t \in [0,1]$, trader agents argue to shift that belief, and convergence is declared when the last three probabilities fall within a threshold $T=0.2$ (Gho et al., 18 Nov 2025). The architecture thereby replaces voting or debate winners with a stable probabilistic belief trajectory.

4. Memory, observability, and information partitioning

A major axis of coordination design concerns what information is stored, what is shared, and what remains latent. A memory-centric orchestration engine for personalized assistance combines a temporal graph database with a vector database: user interactions are stored as time-stamped nodes and edges in Neo4j, private data are embedded in FAISS, and the orchestrator uses graph-derived context to steer vector retrieval before coordinating multiple LLMs and an iterative reflection loop (Rasal, 2024). The graph acts as long-term structured memory; the vector store supplies factual detail; the orchestrator mediates both.

In graph-structured document understanding, shared memory is elevated from a passive store to a coordination backbone. The architecture includes shared memory containing document segments, intermediate extractions, summaries, QA answers, and metadata such as task IDs, agent IDs, and confidence; an asynchronous feedback bus carries critique and revision requests; and an evaluator agent reviews intermediate outputs and triggers reassignment (Xia et al., 22 Jul 2025). The ablation study is unusually explicit: removing shared memory or removing feedback loops produces more than a 20% drop in coverage and coherence, indicating that memory and feedback are not accessory modules but central coordination mechanisms (Xia et al., 22 Jul 2025).

A different solution is to partition information rather than maximize sharing. In gated coordination for long-horizon Minecraft construction, each agent maintains a private execution state

$$m_t^{\text{priv}}=\langle I_t, T_t, P_t, B_t, H_t\rangle$$

and only escalates to a public coordination channel when a structured issue is detected and a cost-sensitive gate authorizes communication (Jian et al., 21 Apr 2026). The escalation score is

$S = w_C C + w_R R + w_I I - w_L L - w_H H,$

with calibrated weights $[4,2,2,2,1]$ and asymmetric thresholds $T_{\text{low}}^*=0.4$, $\dot{x}(t)=-L_s x(t),$0 (Jian et al., 21 Apr 2026). Communication is thus transformed from a default reaction into a selective decision.

Observability appears as a deeper concern in the graph-theoretic framework. There, latent agent state evolves internally while only verbal output is visible to peers, and the dimension of the unobservable subspace is $\dot{x}(t)=-L_s x(t),$1, where $\dot{x}(t)=-L_s x(t),$2 is the observability matrix (Javed, 23 Feb 2026). Hidden system prompts or internal mechanisms that evolve within $\dot{x}(t)=-L_s x(t),$3 are undetectable from token outputs and can later surface as antagonistic behavior; this is the formal basis for describing hidden prompts as topological Trojan horses (Javed, 23 Feb 2026).

Shared state may also be external and multimodal. IndoorR2X uses a centralized coordination hub to fuse robot observations and IoT sensor reports into a global semantic state

$\dot{x}(t)=-L_s x(t),$4

which is then serialized into a planning prompt for a central LLM (Yang et al., 20 Mar 2026). Although the setting is embodied robotics rather than pure multi-LLM reasoning, the architectural principle is directly relevant: a shared semantic blackboard can substitute for direct peer-to-peer communication when partial observability is the main bottleneck.

5. Budget, evaluation, and efficiency

Coordination architecture is inseparable from evaluation methodology. The financial multi-agent survey identifies five pervasive evaluation failures—look-ahead bias, survivorship bias, backtesting overfitting, transaction cost neglect, and regime-shift blindness—and argues that these can reverse the sign of reported returns (Nguyen et al., 29 Mar 2026). It therefore proposes minimum standards including contamination control, point-in-time inputs, rolling-window reporting, net-of-cost returns or net benefit, and regime coverage. Within that framework, the Coordination Breakeven Spread (CBS) is defined as

$\dot{x}(t)=-L_s x(t),$5

with coordination economically justified only if $\dot{x}(t)=-L_s x(t),$6 (Nguyen et al., 29 Mar 2026). More generally, the survey insists that CPH remains a falsifiable hypothesis because the field still lacks the evaluation infrastructure required for definitive validation (Nguyen et al., 29 Mar 2026).

Budget-aware coordination can also be embedded directly into training. CoRL formulates centralized multi-LLM coordination as reinforcement learning with dual objectives—maximize task performance and minimize inference cost—and introduces budget-conditioned behavior through prompt-level budget modes and a hard budget reward:

$\dot{x}(t)=-L_s x(t),$7

In this design, a single controller learns how aggressively to invoke experts under low, medium, and high budget conditions (Jin et al., 4 Nov 2025).

MACA combines structural priors with budget-aware orchestration and reports that joint adaptation of structure and orchestration outperforms adaptive multi-agent baselines by an average of 8.42% while using 43.19% fewer tokens (Li et al., 25 May 2026). The reported mechanism is suppression of redundant interactions: structure constrains the support of possible interactions, and policy learning decides which of the plausible ones are worth paying for.

Shared-state systems show that efficiency gains are architecture-dependent rather than monotonic. CodeCRDT reports up to 21.1% speedup on some tasks, up to 39.4% slowdown on others, and 100% convergence with zero merge failures, while also identifying semantic conflict rates of 5–10% (Pugachev, 18 Oct 2025). The result is not that concurrency is universally advantageous, but that structural convergence at the state layer does not eliminate semantic coupling costs. Similarly, gated communication in Minecraft improves blueprint completion quality and execution chain length by turning communication into a selective, cost-sensitive action rather than a default response (Jian et al., 21 Apr 2026).

At the infrastructure layer, LLM-X makes the policy–performance trade-off explicit. Its empirical evaluation shows that stricter negotiation policies improve robustness and fairness but increase latencies and message volume, while extended runs confirm stable behavior under sustained load with bounded latency drift (Lorenzoni et al., 12 May 2026). This suggests that exchange policies should be regarded as architectural hyperparameters, not merely transport settings.

6. Empirical domains, representative results, and open issues

The diversity of experimental settings indicates that multi-LLM coordination architecture is not a domain-specific curiosity but a general systems problem spanning reasoning, personalization, robotics, markets, blockchains, and social dilemmas.

Domain	Representative finding	Citation
Long-form document understanding	Full system: Factual Coverage 0.92, Compliance Accuracy 0.94, Completion Time 115 s	(Xia et al., 22 Jul 2025)
Personalized assistance	ROUGE-1 47.3, ROUGE-2 21.7, ROUGE-L 31.6, Accuracy 61%	(Rasal, 2024)
Indoor robot coordination	R2X: SR 92%, 108 action steps, 88 m path length, 42,438 tokens	(Yang et al., 20 Mar 2026)
Demand response on social network	Compiled directives: 33.3% cooperation vs 27.0% unstructured and 28.0% no intervention	(Curtò et al., 9 Jun 2026)
Byzantine-robust answer selection	DecentLLMs: 71% accuracy vs 64% for 2/3-quorum and 50% for majority-quorum	(Jo et al., 20 Jul 2025)
Market-based belief coordination	Market-based coordination yields accuracy gains of up to 10% over single-shot baselines	(Gho et al., 18 Nov 2025)

These results also clarify the limits of current architectures. Evaluation infrastructure remains insufficient for definitive validation of coordination-centric claims (Nguyen et al., 29 Mar 2026). Formal protocol approaches still identify stale or non-returning LLM calls, timeout mechanisms, and their semantic consequences as unfinished work (Bollig et al., 19 Apr 2026). Decentralized evolutionary systems identify heterogeneous agents, router exploration versus exploitation, and routing complexity in large networks as open problems (Yang et al., 1 Apr 2025). Graph-theoretic agreement models likewise point to stochastic token noise, time-varying topologies, and richer vector-valued state representations as natural extensions of current theory (Javed, 23 Feb 2026).

A plausible implication is that future coordination architectures will increasingly combine several of the paradigms now studied separately: structural priors or typed protocols for correctness, budget-aware controllers for cost, shared semantic state for observability, selective public channels for noise control, and robust aggregation or market-style updates for adversarial or epistemically diverse settings. The current literature does not yet converge on a single dominant design, but it does converge on a stronger claim: multi-LLM performance depends less on the existence of multiple agents than on the architecture that determines how they are allowed to become a system.