Toward an Organizational Science of Multi-Agent LLM Systems: Decoupling Who, How, and Which Algorithm

Multi-agent frameworks built on large language models (LLMs) routinely entangle three logically distinct concerns: who is on the team (organization), how members align (coordination), and which algorithm fuses their work (collaboration protocol). IMACS (Intelligent Multi-Agent Collaboration System) separates the three into orthogonal, independently swappable layers. Classic organizational theory (Belbin roles, Mintzberg coordination, RACI accountability) becomes executable, validated configuration, and the framework places six published collaboration algorithms behind a common interface while exposing roles, coordination, and accountability as independently configurable factors. We use this separation to conduct controlled comparisons in which organizational assignments vary while the collaboration protocol is held fixed. It also turns protocol choice into a variable that can be learned: Adaptive Org Routing, a contextual-bandit meta-protocol, selects a protocol per task under an explicit quality–cost tradeoff, outperforms every fixed protocol in a controlled study, and trains online on real benchmark and LLM-judge rewards. The ablations expose a mechanism. Accountability placement changes outcomes exactly when the protocol routes the deliverable through the accountable agent, and the winning placement flips across model families, so organizational design cannot be hard-coded; it must be re-validated, or learned, for each model binding.

Introduction. Large language models (LLMs) have moved from singleshot prompting to multi-agent collaboration, in which multiple model instances critique and build on one another’s reasoning. A growing toolbox of collaboration algorithms now exists—Mixture-of-Agents (Wang et al. 2025), Multi- Agent Debate (Du et al. 2024), Self-Consistency (Wang et al. 2023b), LLM-Blender (Jiang, Ren, and Lin 2023), Plan-and- Execute (Hong et al. 2024), Reflexion (Shinn et al. 2023)— alongside agent frameworks such as AutoGen, CAMEL, and MetaGPT.

The entanglement problem. Despite this progress, most frameworks tangle three logically independent concerns into one implementation:

1. Organization (WHO): which agents exist, what roles they play, which models back them, and who is accountable.

2. Coordination (HOW): the mechanism by which members align, whether informal mutual adjustment, a supervisor issuing orders, or standardized procedures and outputs. 3. Collaboration protocol (the ALGORITHM): the procedure that fuses individual contributions into a result, such as debate, voting, or planning.

When these are fused, swapping the aggregation algorithm means rewriting the team. The cost is threefold: teams cannot be reconfigured without touching algorithms; decades of organizational theory (Belbin 2010; Mintzberg 1979) cannot be applied as a first-class design surface; and collaboration algorithms cannot be compared on an equal organizational footing, since each ships its own implicit team.

Our thesis: decouple the three concerns. We argue these concerns are orthogonal and model them as independently swappable layers. IMACS (Intelligent Multi-Agent Collaboration System) realizes this: organizations are declared in YAML and grounded in Belbin’s nine roles (Belbin 2010); coordination is one of Mintzberg’s five mechanisms (Mintzberg 1979); and the collaboration protocol is a pluggable object behind a single interface. RACI is a cross-cutting tag with a validated at-most-one-Accountable constraint, and any layer can be replaced without touching the others (Proposition 1). To show the organization layer is culturally pluggable, IMACS ships three presets: belbin (default), adhocracy, and three-departments (the Tang-dynasty ministry system in Belbin terms).

Why decouple? Once the three factors are independently swappable, organizational variables (roles, coordination, RACI) can be held fixed or ablated while the protocol stays constant; to our knowledge, no prior multi-agent LLM framework supports such controlled ablation of who and how independent of which algorithm. Protocol choice also becomes a free variable. We exploit both consequences in this paper.

Related work. Multi-agent LLM frameworks. Prior frameworks couple roles, coordination, and aggregation (Guo et al. 2024): conversational systems like AutoGen, CAMEL, and AgentVerse fix the dialogue loop as the protocol (Wu et al. 2024; Li et al. 2023; Chen et al. 2024), while MetaGPT and ChatDev bind roles to a fixed software-company pipeline (Hong et al. 2024; Qian et al. 2024). A complementary line optimizes the communication topology itself—GPTSwarm learns over agent graphs (Zhuge et al. 2024), DyLAN prunes dynamic agent networks (Liu et al. 2024)—but within one algorithmic family, without declarative roles or accountability. Purposebuilt evaluations have followed: MultiAgentBench scores collaboration across coordination topologies with milestone KPIs (Zhu et al. 2025); AgentsNet poses formally verifiable coordination problems over agent networks (Grötschla et al. 2025). IMACS instead treats organization, coordination, and collaboration as orthogonal layers over a generic runtime (we build on AgentScope 2.0 (Gao et al. 2024)), so a team and an algorithm combine freely.

Collaboration algorithms. We treat published collaboration algorithms as interchangeable protocols: Mixtureof-Agents (Wang et al. 2025) (proposer/aggregator layers), Multi-Agent Debate (Du et al. 2024) (critique-revise rounds), Self-Consistency (Wang et al. 2023b) (sample-andvote), LLM-Blender (Jiang, Ren, and Lin 2023) (rank-andfuse), Plan-and-Execute in the Plan-and-Solve / MetaGPT line (Wang et al. 2023a; Hong et al. 2024) (decomposethen-execute), and Reflexion (Shinn et al. 2023) (verbal selffeedback). IMACS ships each behind a common interface, so they can be compared on the same team and selected automatically per task.

Organizational theory. Belbin (Belbin 2010) identifies nine team roles (thought-, people-, actionoriented) a balanced team covers; Mintzberg (Mintzberg 1979) identifies five coordination mechanisms and forms such as the adhocracy; RACI assigns Responsible/Accountable/Consulted/Informed tags, classically one Accountable per deliverable. While agent “personas” are common, IMACS makes these theories a first-class, declarative, validated design surface, with cultural pluggability via the three-departments preset (the Tang ministry system; Fei, Guo, and Xiao 2026 also cast historical institutions as agent topologies, but as fixed architectures, not a swappable layer).

Bandits for model and protocol selection. LinUCB (Li et al. 2010) is the canonical linear-payoff contextual bandit (Auer, Cesa-Bianchi, and Fischer 2002; Chu et al. 2011) with ̃O( √ T) regret. Adjacent selection problems use the same machinery, routing queries to models (Chen, Zaharia, and Zou 2024; Shnitzer et al. 2024; Ong et al. 2025; Poon et al.

Method. The IMACS Framework IMACS is organized as a stack of seven layers (Figure 1). Lower layers provide atomic capabilities; upper layers compose them. The three middle layers (organization, collaboration, and the runtime that hosts them) are where the decoupling lives.

Layers L1 Atomic capabilities. Model adapters, tools, MCP servers, and the provider-facing ModelGateway. The ModelGateway owns provider credentials and resolves opaque model handles, keeping credentials below the agent boundary. Models are restricted to an author-defined experimental registry: callable through available provider APIs, compatible with the common AgentScope chat interface, and spanning distinct provider families. It is an implementation allowlist, not an external certification or quality endorsement. An offline deterministic stand-in keeps tests and demos running without credentials or network access.

L1 Atomic — ModelGateway + model adapters / tools / MCP L2 Agent — role-typed model handle + tools (ReAct) L3 Organization (WHO / HOW) Belbin roles · RACI tags · Mintzberg coordination (YAML) L4 Collaboration Protocol (ALGORITHM) voting · MoA · blender · debate · reflexion · plan-execute · adaptive L5 Runtime — Conductor + observable Blackboard (Team interface) L6 API Gateway — FastAPI REST + SSE L7 Application — Vue arena / project UI L2 Agent. A role-typed wrapper binding a model handle, a system prompt, and tools; agents act via a ReAct-style reason-act loop (Yao et al. 2023) when tools are involved. L3 Organization (WHO/HOW). A declarative team: Belbin-typed roles, each bound to a registered model and a RACI tag, plus a Mintzberg coordination mechanism. Loaded from YAML presets and formalized below (Definition 1). L4 Collaboration protocol (ALGORITHM). The pluggable fusion algorithm behind the single interface of Definition 2. Ships voting, MoA, blender, debate, reflexion, planexecute, and the adaptive meta-protocol (Adaptive Org Routing). L5 Runtime. A Conductor instantiates a Team from an organization and drives a protocol over a shared Blackboard on which every intermediate message is posted, a transparent room with human-in-the-loop and SSE hooks. L6 API Gateway. A FastAPI boundary exposes the L5 Conductor through REST and streams Blackboard events through SSE. It delegates model resolution to L1’s Model- Gateway and does not expose provider credentials to applications. L7 Application. A Vue application provides two canonical demos: an arena (models compete per query) and a project (a task decomposed across roles).

Formalization Definition 1 (Organization). An organization is a tuple O = (R, μ, κ, ρ) where • R = {r1, . . . , rn} is a set of roles, each ri ∈B drawn from Belbin’s nine team roles B; • μ : R →M is a model binding from roles to the configured model registry M (the gateway guarantees im(μ) ⊆M); • κ ∈ K is a single coordination mechanism from Mintzberg’s five mechanisms K; • ρ : R →{R, A, C, I} is the RACI assignment, subject to the single-owner constraint {r ∈R : ρ(r) = A} ≤1.

Here R, A, C, and I denote Responsible, Accountable, Consulted, and Informed; Greek symbols name organization components rather than reusing these RACI initials. The single-owner constraint is validated at load time. A Team T is the instantiation of O: a set of agents {ai} where ai wraps model μ(ri) under role ri, sharing a coordination context derived from κ.

Definition 2 (Collaboration protocol). A collaboration protocol is a function π : (Task, Team, Blackboard) −→Result, that, given a task, an instantiated team, and a shared blackboard, executes a fusion algorithm and returns a result, while posting every intermediate utterance to the blackboard. The set of protocols Π is extensible: a new algorithm is a new π ∈Π registered by name.

A protocol is deliberately agnostic to which roles populate the team and to κ; it sees a pool of role-typed agents, never a fixed cast. Conversely, an organization carries no commitment to any π.

Conclusion. Most multi-agent LLM frameworks hard-wire who collaborates into how results are fused. IMACS separates these concerns: organizational theory becomes executable configuration, controlled ablations expose mechanisms, and protocol choice becomes learnable. Adaptive Org Routing outperforms every fixed protocol in the controlled study and trains online on real rewards. Roles, coordination, and accountability can thus be optimized alongside fusion algorithms, enabling inspectable comparisons across organizations, protocols, and model bindings.

Limitations. The synthetic oracle is a controlled stand-in. The regret/accuracy study uses a simulated oracle calibrated to literature trends (Du et al. 2024; Shinn et al. 2023; Hong et al. 2024): learning under known ground truth with exact regret; real-benchmark and real-reward results supply absolute quality.

Linearity, arms, and scale. LinUCB assumes payoffs approximately linear in the 7 features; kernelized or neural bandits could capture nonlinear structure at higher cost. Extending arms to (protocol, coordination) or per-role bindings is well-defined under Proposition 1 but enlarges exploration; our real runs are small-N feasibility runs, not tuned policies.

Cost and statistical scope. The router uses model-call multiplicity rather than provider-specific billing, so deployment costs require local recalibration. Real-model cells contain only N=10 items and the RACI study only three repeats; we therefore report latency, dispersion, sign consistency, and paired effects instead of leaderboard or significance claims. The process-global policy is suited to sequential learning; concurrent services should isolate or synchronize updates.