4-Agent Multi-LLM Architecture Overview

• 4-Agent Multi-LLM Architecture is a modular system that assigns distinct roles for problem interpretation, decomposition, verification, and execution, ensuring clear separation of concerns.
• It leverages diverse coordination regimes—such as hierarchical orchestration, selective deliberation, and shared-workspace control—to adapt workflows across varied domains.
• Empirical studies show that this architecture improves predictive validity, efficiency, and auditability in fields ranging from operations research to software design.

Searching arXiv for the cited papers to ground the article in current literature. A 4-Agent Multi-LLM architecture is a multi-agent LLM system organized around four explicitly differentiated roles that communicate through structured artifacts, staged handoffs, or a shared state in order to improve decomposition, verification, interpretability, and execution over single-agent pipelines. In recent arXiv literature, this pattern appears across operations research, stealth assessment, software architecture design, payments, feature selection, geospatial analysis, control, and reasoning systems, but with markedly different coordination regimes: hierarchical orchestration, selective deliberation, domain decomposition, graph-based routing, decentralized execution, and shared-workspace control (Li et al., 25 Jun 2026). The recurring design claim is not that “four” is intrinsically optimal, but that four role-specialized components often provide a workable balance between separation of concerns and coordination overhead. This suggests a stable architectural motif: one layer for problem interpretation, one for generation or decomposition, one for verification or judgment, and one for execution, integration, or final synthesis.

1. Architectural definition and role decomposition

The most explicit recent formalization is COOPA’s instantiation as a “4-Agent Multi-LLM Architecture,” a hierarchical, modular multi-agent system that maps natural-language operations research problems to executable solver runs with interpretable artifacts (Li et al., 25 Jun 2026). In that formulation, the four roles are: Problem Understanding & Provenance Agent, Formulation Agent, Evaluation & Verification Agent, and Solver Routing & Execution Agent. Responsibilities are sharply partitioned. The first agent parses the problem text and extracts modeling elements with quoted source spans; the second produces multiple candidate mathematical formulations; the third scores those candidates across modeling dimensions and selects among them; the fourth classifies the selected formulation by problem class, routes it to the appropriate optimizer, executes solver code, retries on error, and returns a solution with execution logs.

A comparable four-part decomposition appears in MAAD, where Analyst, Modeler, Designer, and Evaluator autonomously and collaboratively transform software requirements into multi-view architectural blueprints with quality attribute assessments (Li et al., 31 May 2026). Although the domain differs, the division is structurally similar: requirement interpretation, artifact construction, documentation or concretization, and evaluative control. HMASP adopts another hierarchical variant in payment workflows, with a Conversational Payment Agent, Supervisor agents, Routing agents, and Process summary agents, again separating intake, delegation, workflow activation, and outcome summarization (Chua et al., 27 Feb 2026).

Across these systems, the recurrent abstraction is a four-stage control chain in which each agent owns a distinct representation space. COOPA uses schema-validated JSON plus optional LaTeX; MAAD uses FR/NFR/ASR artifacts, PlantUML, and architectural documentation; HMASP uses role-partitioned state and structured handoffs; LLM-FS-Agent uses per-feature score-and-rationale records through Initiator, Refiner, Challenger, and Judge (Bal-Ghaoui et al., 7 Oct 2025). A plausible implication is that the four-agent pattern is favored when the problem requires at least one generative phase and one adjudicative phase, but still benefits from an explicit execution or synthesis layer rather than collapsing all reasoning into debate.

2. Coordination patterns and information flow

The literature exhibits several distinct coordination regimes for four-agent systems. COOPA uses hierarchical orchestration with persistent intermediate artifacts: the original problem $P$, candidate models $M_i$, element-level SourceReference, confidence scores and explanations $\{(c_{i,d}, e_{i,d})\}$, the selected model $M^\*$, the routing decision, and final solver execution logs (Li et al., 25 Jun 2026). All agents exchange structured messages validated by a Pydantic schema, and downstream stages never parse ad hoc text. This is a strongly typed pipeline in which orchestration depends on explicit state/history.

By contrast, Agentic BKT organizes four phases around behavioral trajectories from a serious game: event logging, event-level rubric labeling, four domain-specific agents specializing in risk mitigation, investing, spending, and credit/debt, and a judge agent that synthesizes per-domain Bayesian Knowledge Tracing mastery probabilities into an overall mastery score (Santos et al., 24 Jun 2026). Here the decomposition is not sequential artifact refinement of a single object, but partitioned reasoning over domain-specific evidence streams. The controller aggregates inputs and routes outputs among classifier, domain agents, BKT components, and judge.

CascadeDebate represents a third regime: selective multi-agent deliberation inserted at uncertainty boundaries in a cascade. Its canonical chain alternates single-model inference with multi-agent stages, with four agents per deliberative stage and confidence-based routers deciding whether to accept, escalate, or abstain to humans (Chang et al., 14 Apr 2026). The architecture is therefore not simply “four specialized roles,” but “four parallel deliberators” activated conditionally. Agreement rate becomes the stage confidence, and uncertainty can trigger escalation instead of local resolution.

Other architectures replace central pipelines with shared-workspace or concurrent coordination. BIGMAS organizes specialized agents as nodes in a dynamically constructed directed graph and coordinates exclusively through a centralized shared workspace $B = (B_{ctx}, B_{work}, B_{sys}, B_{ans})$, with a global Orchestrator selecting the next node after each validated write (Hao et al., 16 Mar 2026). CMA, in contrast, removes a central control loop: concurrent modules communicate through MQTT and a single shared ChromaDB-backed global state, and coherent behavior is said to emerge from language-mediated interactions among asynchronous processes (Maruyama et al., 26 Aug 2025). These systems show that a four-agent architecture need not imply a fixed serial pipeline; it may instead denote a bounded set of differentiated nodes embedded in a graph, bus, or blackboard system.

3. Structured representations, provenance, and memory

A major differentiator in recent four-agent systems is the degree of formalization in internal representations. COOPA defines a structured model representation carrying ParameterDefinition, VariableDefinition, ObjectiveDefinition, and ConstraintDefinition, each with required source quotes, and each linked to element-level provenance and confidence explanations (Li et al., 25 Jun 2026). The linkage schema explicitly maps variables, parameters, constraints, and objectives to quoted source text, creating what the paper describes as an audit trail from problem text to mathematical model.

MAAD similarly enforces strict structured artifacts at every stage: the Analyst outputs structured FRs, NFRs, and ASRs with IDs and rationale; the Modeler produces exactly 11 standardized UML diagrams in PlantUML aligned with the 4+1 views; the Designer generates production-ready architectural documentation; and the Evaluator produces mismatch and ATAM reports that require requirement IDs and diagram/component IDs in every mismatch entry (Li et al., 31 May 2026). Traceability is therefore not merely documentary; it is embedded in the artifact schema and refinement protocol.

GeoJSON Agents adopts a planner–worker–integrator division around structured GeoJSON operation commands, including task identifiers, operation names, backend specification, inputs, parameters, expected outputs, and constraints, with outputs integrated into reusable, standards-compliant GeoJSON files (Luo et al., 10 Sep 2025). HMASP implements a related principle through role-based state partitions—PayAgentState, CardsState, and PaymentState—plus shared state variables and decoupled message states, explicitly distinguishing persistent workflow data from local agent message history (Chua et al., 27 Feb 2026).

Memory architectures vary accordingly. MAAD employs working, episodic, and semantic memory; CMA uses a shared vector-based memory in ChromaDB for perceptions, thoughts, plans, and actions; AgentNet gives each agent separate routing and execution RAG pools; BIGMAS centralizes all information in a global workspace (Li et al., 31 May 2026). These designs converge on one technical premise: multi-agent architectures benefit when internal state is externalized into typed, inspectable records rather than left implicit in conversational context windows. This suggests that four-agent systems are often as much about representation engineering as about role engineering.

4. Verification, deliberation, and decision rules

The verification layer is a defining feature of contemporary four-agent designs. In COOPA, the Evaluation & Verification Agent scores candidate formulations over four dimensions—parameters, variables, objective, and constraints—with scores on $[0,100]$, normalized to $[0,1]$ for the decision rule, and selects via the unweighted max–min criterion

$f^\* = \arg\max_i \min_{d \in D} c_{i,d}.$

A generalized weighted variant

$f^\* = \arg\max_i \min_{d \in D} w_d \cdot c_{i,d}$

is presented as an extension, permitting emphasis on high-impact dimensions such as objective correctness (Li et al., 25 Jun 2026). The architectural motivation is explicit: max–min selection addresses “single bad component” failure modes.

LLM-FS-Agent instantiates a different deliberative pattern. The Initiator provides an initial semantic relevance assessment, the Refiner adds structured context and a refined score $S_{\text{refined},j}$, the Challenger contributes an adversarial critique and $M_i$0, and the Judge produces the final score using

$M_i$1

subject to $M_i$2 and $M_i$3 (Bal-Ghaoui et al., 7 Oct 2025). The crucial property is explicit weighting of competing arguments, producing a fully logged, auditable trail of rationales per feature.

CascadeDebate treats deliberation itself as a conditional computation primitive. At multi-agent stages, four agents generate independent answers, majority vote determines the provisional answer, and agreement rate functions as confidence:

$M_i$4

Confidence-based routers then decide whether to accept or escalate (Chang et al., 14 Apr 2026). In this design, four-agent architecture is less about permanent specialization and more about dynamic ensemble resolution.

DecentLLMs provides yet another verification model, though under a worker/evaluator split rather than four unique roles. It uses evaluator score vectors over five criteria and geometric median aggregation, but its own analysis notes that with only four total agents, a $M_i$5 split yields no Byzantine tolerance under the formal honest-majority bounds (Jo et al., 20 Jul 2025). That observation is significant for the broader topic: a four-agent architecture can improve transparency or modularity without automatically providing adversarial robustness or consensus guarantees. Verification quality depends on the specific aggregation and trust assumptions, not merely agent count.

5. Representative domains and empirical performance

The four-agent motif has been deployed in multiple technical domains, often with measurable gains over simpler baselines. COOPA evaluates on ComplexLP, IndustryOR, and BWOR, spanning 211 LP/MILP problems, 100 real-world OR cases across LP/IP/MIP/NLP/others, and 80 textbook LP/IP/MIP problems. Across eight LLM backbones and four baselines, it achieves the highest macro-average accuracy on 6 of 8 backbones, with a cross-model macro-average of 64.8% versus 61.6% for OR-LLM-Agent, 61.3% for OptiTree, and 60.1% for Chain-of-Experts; iterative confidence-based modeling raises cross-model mean from 61.8% to 64.8% (+3.0 pp), improving 7 of 8 backbones (Li et al., 25 Jun 2026).

Agentic BKT applies four-agent reasoning to stealth assessment of financial literacy in serious games. Evaluated on 193 K–12 participants and 264 sessions, the full pipeline yields mastery estimates correlated with learning gain ($M_i$6, $M_i$7) and post-test scores ($M_i$8, $M_i$9), while showing no correlation with pre-test scores. The multi-agent architecture approximately triples predictive validity relative to a single-LLM baseline ($\{(c_{i,d}, e_{i,d})\}$0, not significant) (Santos et al., 24 Jun 2026).

MAAD evaluates on 10 software architecture case studies and reports average improvements over MetaGPT in coupling degree (1.77 vs 1.87), cohesion (0.69 vs 0.36), interface complexity (2.08 vs 0.00), and structural complexity (0.03 vs 0.17), with practitioners also reporting that its Evaluator-produced mismatch and ATAM reports reduce manual validation effort (Li et al., 31 May 2026). LLM-FS-Agent, in the cybersecurity domain on CIC-DIAD 2024, reports average downstream XGBoost training time reduced from 0.205 s to 0.111 s, approximately 46%, with $\{(c_{i,d}, e_{i,d})\}$1 and Cohen’s $\{(c_{i,d}, e_{i,d})\}$2, while producing superior or comparable classification performance relative to LLM-Select and PCA (Bal-Ghaoui et al., 7 Oct 2025).

Other systems demonstrate the breadth of the pattern. GeoJSON Agents reports 85.71% accuracy for Function Calling and 97.14% for Code Generation on a 70-task benchmark, both substantially above a 48.57% general-purpose model baseline (Luo et al., 10 Sep 2025). HMASP reports for Qwen2.5:32b task success of 96.4 on card registration, 98.8 on card retrieval, and 95.6 on payment processing, with handoff F1 scores of 98.1, 99.7, and 99.0 respectively (Chua et al., 27 Feb 2026). These results do not establish a universal advantage for four agents, but they do indicate that carefully partitioned four-agent workflows can be empirically competitive across heterogeneous domains.

6. Limitations, trade-offs, and open directions

Despite repeated adoption, the literature identifies recurrent limitations. COOPA explicitly notes that iterative modeling increases token usage and latency, with measured cost about 7× OR-LLM-Agent on sampled runs, and that confidence scores are informative but imperfect (Li et al., 25 Jun 2026). HMASP similarly depends on strict state partitioning, interrupt-driven human input, and deterministic function modules to control hallucination risks in payment workflows; the system demonstrates feasibility in a simulated environment rather than production deployment (Chua et al., 27 Feb 2026). Agentic BKT currently runs post-session because of latency and cost, at approximately 93 API calls per session and about $0.048 per student (Santos et al., 24 Jun 2026).

A second limitation concerns correlated failure. LLM-FS-Agent uses the same backbone across all four roles in each run, which can propagate model-specific biases through the entire deliberative chain (Bal-Ghaoui et al., 7 Oct 2025). MAAD reports that architecture quality depends heavily on the underlying LLM’s reasoning capacity, with GPT-5.2 and Qwen3.5 outperforming DeepSeek-R1 and Llama3.3 (Li et al., 31 May 2026). This suggests that multi-agent decomposition does not erase backbone limitations; it often amplifies the value of strong reasoning models while regularizing weaker ones.

A third issue is that “four agents” does not uniquely determine topology. BIGMAS uses dynamic directed graphs with centralized shared workspaces; CMA uses fully asynchronous modules coordinated by MQTT and ChromaDB; AgentNet uses decentralized DAG-style routing with per-agent routing and execution memories (Hao et al., 16 Mar 2026). Consequently, the same nominal count can conceal very different control-theoretic properties: central orchestration, selective deliberation, decentralized routing, or blackboard coordination. Common misconceptions arise when four-agent architectures are treated as a single method rather than a design family.

Open directions are already present within the surveyed systems. COOPA identifies extensions including a fifth agent for domain adaptation or data validation, formal verification, broader solver support, and weighted max–min selection (Li et al., 25 Jun 2026). MAAD points toward adaptive knowledge routing, domain-specific fine-tuning, hybrid LLM orchestration, and stronger integration of dynamic QA simulation into its Evaluator (Li et al., 31 May 2026). LLM-FS-Agent proposes heterogeneous backbones per role, tool-augmented Refiner and Challenger stages, and dynamic or learned aggregation weights (Bal-Ghaoui et al., 7 Oct 2025). A plausible implication is that the future of 4-Agent Multi-LLM Architecture lies less in fixing the number of agents and more in refining the contracts among them: typed state, grounded retrieval, explicit verification, and principled escalation paths.

7. Conceptual significance

Taken together, recent arXiv systems indicate that the 4-Agent Multi-LLM architecture has become a reusable systems pattern for imposing structure on LLM workflows that would otherwise remain monolithic, opaque, or fragile. Its significance lies in the repeated separation of interpretation, generation, evaluation, and execution or synthesis into distinct computational responsibilities. In some systems this yields auditability through provenance and typed artifacts; in others, higher predictive validity through domain decomposition; in others, better cost–accuracy trade-offs through selective deliberation; in still others, cleaner traceability from requirements to design or from prompts to payment state transitions (Li et al., 25 Jun 2026).

The pattern is therefore best understood not as a fixed topology but as an architectural family defined by role differentiation under bounded agent count. Four agents are sufficient to express a nontrivial control loop—problem framing, constructive reasoning, critique, and effectuation—without incurring the coordination complexity of larger societies of agents. This suggests why the pattern recurs in domains as diverse as operations research, educational assessment, software architecture, geospatial analysis, feature selection, and payment orchestration: it is large enough to separate critical concerns, yet small enough to remain engineerable, inspectable, and measurable.