Drop the Hierarchy and Roles: How Self-Organizing LLM Agents Outperform Designed Structures

TL;DR

Most multi-agent LLM systems (ChatDev, MetaGPT, AutoGen) work like a human org chart: you pre-assign each agent a fixed role (“architect”, “tester”) and a coordinator hands out tasks. This paper runs the largest experiment to date — 25,000+ task runs, 8 models, 4–256 agents, 8 coordination protocols — and finds that approach is leaving quality on the table. The winner is a hybrid called Sequential: agents act in a fixed order but each one chooses its own role after seeing what everyone before it actually produced. It beats fully-autonomous coordination by 44% and beats a centralized coordinator by 14%. The catch (the “endogeneity paradox”): self-organization only works above a model capability threshold — weak models do worse with freedom and need the rigid structure. The practical payoff: open-source DeepSeek hits 95% of Claude’s quality at 24× lower cost, and piling on more agents past ~64 buys you nothing.

Problem & Motivation

If you’ve built a multi-agent system, you’ve felt this pain: you spend most of your design time writing role descriptions and wiring up a coordinator. You decide there’s a “planner”, a “coder”, a “reviewer”, and you script who talks to whom. That’s borrowing the human org chart — fixed roles, a boss who allocates work, a hierarchy — and stapling it onto agents.

But an LLM agent is not a human worker. The paper makes this point sharply: a human switching from “architect” to “analyst” pays retraining and cognitive-overhead costs, so fixed roles make sense for people. An LLM agent switches specialization at zero cost, can read the entire organizational context in one prompt, and costs nothing when idle. Pre-assigning it a fixed role “replicates human limitations onto entities that lack them.” It’s an anti-pattern.

The field had split into two camps that both dodged the real question:

• Vertical self-improvement (e.g. DGM-Hyperagents): make each individual agent smarter. Useful, but says nothing about how a group should coordinate.
• Horizontal coordination (ChatDev, MetaGPT, AutoGen): structure the group — but with fixed, human-designed roles and hierarchies imposed before execution.

Nobody had systematically asked: across the full spectrum from “central control” to “total autonomy,” what coordination architecture actually produces the best quality/cost/scalability trade-off? That’s the gap this paper fills with brute-force empiricism.

What’s New (Core Contribution)

1. A spectrum, not a binary — exogenous → endogenous coordination. Before: coordination was treated as “centralized vs. decentralized.” Now: the paper defines a continuum from exogenous (structure imposed externally) to endogenous (structure emerging from within) and places 8 protocols on it, then measures each.

2. The endogeneity paradox (the headline result). Before: the implicit assumption was “more agent autonomy = more emergence = better,” or conversely “more control = more reliable.” Now: it’s non-monotonic. The optimum is in the middle. A protocol with minimal structure (just fix the order agents act in) but maximal role autonomy (each agent picks its own role) wins. Fully autonomous (Shared) is the worst; fully centralized (Coordinator) is middling.

3. A measured capability threshold for self-organization. Before: self-organization was assumed to be generically good. Now: it’s a privilege of strong models. Claude gets +3.5% from freedom; GLM-5 gets −9.6% — for weaker models, rigid structure beats autonomy. The threshold requires three abilities: self-reflection (knowing your own competence), deep reasoning, and instruction-following.

4. Emergent organizational phenomena, quantified. Agents spontaneously invent roles (5,006 unique roles from 8 agents), voluntarily abstain when they judge they can’t help (Claude abstains 8.6% of the time), and form shallow hierarchies (depth 1→2 as you scale 4→64 agents) — all with no instruction to do so.

5. Multi-model economics + a governance framework. Open-source DeepSeek = 95% of Claude’s quality at 24× lower cost. Plus a “three-ring constitutional framework” for what humans control vs. what the system auto-tunes.

How It Works (Technically)

The system as a discrete-time dynamical system

The paper formalizes an “AI organization” as a system that steps forward in time. Equation (1) is just bookkeeping notation, don’t let it intimidate you:

$$x_{t+1} = F(x_t, u_t, \tau_t, w_t, \varepsilon_t)$$

In plain English: the next state of the org = a function of (current state, your coordination choices, the task, external shocks, LLM randomness).

• x_t (state) = who has which role right now, who talks to whom (topology), and the accumulated memory.
• u_t (control) = your decisions — which protocol, what routing. This is the knob the whole paper is about.
• w_t (shocks) = an agent dies, a regulation changes, priorities shift (this is how they test resilience).
• ε_t = LLM stochasticity (they run at temperature 0.7, so outputs vary).

The objective (Eq. 2) is also just a weighted scorecard: maximize quality + mission-relevance, minus time, cost, and risk, summed over the run. Nothing exotic — it’s a multi-objective utility, and the “control” you optimize over is the protocol choice.

The four protocols — the actual content

This is the heart. Each protocol is a different recipe for how agents decide their roles and combine their work. Watch what information each agent gets, because that’s the whole story.

The paper’s explanation for why Sequential wins is genuinely the key insight, and it’s about information quality:

• Coordinator gives each agent one agent’s plan — bottlenecked by a single judgment, a single point of failure.
• Broadcast gives each agent everyone’s intentions — but intentions are cheap and change between rounds.
• Shared gives each agent historical patterns — stale, may not fit this task. Worse, because everyone decides simultaneously with no real-time visibility, you get role duplication (three agents all decide to be “the security expert”). This is why Shared is the worst.
• Sequential gives each agent the completed, factual outputs of everyone who went before, for this exact task. Not a plan, not an intention, not history — actual results.

The analogy the author uses (and it’s a good one): a sports draft. Each team picks knowing every prior pick, so they naturally fill complementary positions — no central planner needed, no duplicate picks. The single constraint “you pick in order” is what unlocks the emergent complementarity.

The deep takeaway: minimal structure enables maximal emergence. One tiny exogenous constraint (fixed ordering) is what lets the endogenous magic (role invention, abstention, complementarity) happen. Remove it (Shared) and emergence collapses into chaos.

Architecture & data flow

flowchart TB
  subgraph Inputs
    M[Mission and values]
    T[Task tau_t]
    P[Protocol = Sequential]
  end
  M --> A0
  T --> A0
  P --> A0
  subgraph SequentialRun[Sequential protocol run - fixed order, autonomous roles]
    A0[Agent 1: sees nothing yet -> picks role -> output 1]
    A0 --> A1[Agent 2: sees output 1 -> picks role or ABSTAIN -> output 2]
    A1 --> A2[Agent 3: sees outputs 1,2 -> picks role or ABSTAIN -> output 3]
    A2 --> AN[Agent N: sees outputs 1..N-1 -> picks role or ABSTAIN -> output N]
  end
  AN --> AGG[Aggregate outputs]
  AGG --> J[Independent LLM-as-judge:<br/>accuracy, completeness, coherence,<br/>actionability, mission relevance]
  J --> Q[Quality Q in 0.25..1.0]

Schematic of the four coordination protocols and the information each agent receives. Click a protocol to see how information flows and why Sequential's "completed outputs" beat intentions, history, or a single plan. Quality values are the paper's pilot numbers (Table III).

How quality is scored

Every solution is graded by an independent LLM-as-judge (a different model from the agents, to avoid an agent grading its own homework). Five criteria on a 1–4 scale. Equation (3) aggregates four of them:

$$Q_t = \frac{s_{acc} + s_{comp} + s_{coh} + s_{act}}{16}, \quad Q_t \in [0.25, 1.0]$$

Decoded: four sub-scores, each 1–4, summed (max 16) and divided by 16. The floor is 0.25 because the minimum sub-score is 1, not 0 — so 4/16 = 0.25. There’s also a Balance Index (Eq. 4) that folds in cost, time, and risk with fixed weights — that’s the “all things considered” metric.

The one caveat to internalize: the judge model changed between experiment series (GPT-4o → GPT-5.4). Within a series the judge is held constant (so protocol-vs-protocol comparisons are valid), but absolute Q values across series aren’t directly comparable.

The algorithm, simplified

Here’s the Sequential protocol as code you could actually write. The contribution is the loop, not the plumbing:

# Sequential protocol: fixed ORDER (exogenous), autonomous ROLE (endogenous).
# llm(prompt) -> str is your model call. The novelty is what's in `context`.
def sequential_run(mission, task, agents):           # agents: list in a FIXED order
    completed = []                                    # factual outputs so far, THIS task
    for agent in agents:
        # Each agent sees the mission + the ACTUAL results of everyone before it.
        # Not a plan, not intentions, not stale history -> that's the whole trick.
        context = format_context(mission, task, completed_outputs=completed)

        # Agent first decides IF and AS WHAT to participate (self-reflection).
        decision = llm(f"{context}\nGiven what's already done, what role would you "
                       f"take, or should you ABSTAIN? Answer role or 'abstain'.")
        if decision.strip().lower() == "abstain":     # voluntary self-abstention
            continue                                  # endogenous cost optimization

        # Then it does the work in the role it chose for itself.
        output = llm(f"{context}\nActing as {decision}, contribute to the task.")
        completed.append(output)                      # next agent conditions on this

    return aggregate(completed)                        # combine into final solution

Compare to the loser, Shared, which is almost the same code but fatal: all agents call llm(context_with_only_history) in parallel, so none sees what the others are deciding now — hence duplicated roles and a 44% quality drop. The difference between best and worst protocol is essentially for agent in agents: (sequential, sees real outputs) vs. parallel_map(agents) (simultaneous, blind to peers).

Built on Prior Work

The honest positioning: the components (self-organization, emergence, no fixed roles) aren’t invented here. What’s new is the systematic sweep across the exogenous→endogenous spectrum at unprecedented scale, and the specific finding that the hybrid middle wins.

Results & Evidence

The core protocol comparison (Table III, identical agents/model/tasks):

• Sequential vs. Shared: +44%, Cohen’s d = 1.86, p < 0.0001. (d = 1.86 is a huge effect size — for context, d = 0.8 is already “large.” This is a real, not marginal, difference.)
• Sequential vs. Coordinator: +14%, replicated across 3 strong models (Claude +14.1%, DeepSeek +12.4%, GLM-5 +12.2%, all p < 0.001).

Scaling (Tables V, VI): going from 8→64 agents kept quality flat (Q ≈ 0.95) while cost rose only 11.8%. Pushing to 256 agents showed no significant quality change (Kruskal-Wallis H=1.84, p = 0.61 — i.e., no detectable difference between 64 and 256). At 256, ~45% of agents idled themselves via self-abstention. Lesson: buy a better model, not more agents — 64→256 is 4.6× the cost for zero gain.

The capability threshold (the crucial nuance): in free-form mode, Claude improved with autonomy (+3.5%) but GLM-5 degraded (−9.6%). Self-reflection tracks this: Claude voluntarily abstains 8.6% of the time, GLM-5 only 0.8%. Weak models don’t know what they don’t know, so freedom hurts them.

Economics (Table VIII): DeepSeek = 95% of Claude’s L3 quality at ~24× lower cost, and actually trends ahead on the hardest L4 tasks (+6.0%, though p=0.082, not significant).

Emergence: RSI → 0 (agents reinvent roles every task — 115 unique roles in 10 tasks); hierarchy depth grows 1.0→2.0 with scale and deeper for harder tasks (1.22 at L1 → 1.56 at L4); recovery from agent removal/substitution within 1 iteration.

What the evidence does NOT establish — be skeptical here:

• All quality is LLM-judged, zero human evaluation. The author flags this as the #1 limitation. LLM judges have known biases (e.g., rewarding verbosity). A human study is “future work.”
• All tasks are synthetic. Designed to mimic real complexity (L1–L4), but no validation on real benchmarks or real business workflows. External validity is unproven.
• Single author, single institution, data “available upon acceptance” — i.e., not yet independently reproducible as of this preprint.
• Multiple comparisons without formal correction (the author argues the headline p-values survive Bonferroni; the secondary ones may not).
• Some models/numbers are from the near future (Claude Sonnet 4.6, GPT-5.4, Gemini-3) — this is a March 2026 preprint, so treat exact figures as illustrative.

Net read: the direction (hybrid wins, threshold exists, more-agents-doesn’t-help) is well-supported by effect sizes and cross-model replication. The absolute numbers deserve caution until human eval + real tasks land.

How You’d Use It

This maps almost directly onto how an AI services shop builds and sells multi-agent work.

1. Re-architect existing client multi-agent systems. If you’ve built anything ChatDev/MetaGPT-style with hand-written role prompts and a router, you have a concrete, testable upgrade: replace the coordinator with a Sequential loop. The change is small (it’s the ~25-line function above) and the claimed upside is +14% quality. That’s a sellable “optimization engagement.”

2. Slash inference cost on tier-1 work. The 24×-cheaper open-source finding is the most immediately monetizable result. Route L1/L2 tasks to DeepSeek/GLM, reserve Claude/GPT-5 for L3/L4 adversarial work. For a client running agents at volume, a model-routing layer that preserves 95% quality at a fraction of cost is a clean ROI story.

3. Stop over-engineering agent counts. When a client says “let’s add more agents,” you now have data to push back: past ~64 it’s pure cost. Sell protocol tuning and model quality instead of headcount.

4. The self-abstention feature is a built-in cost control. Strong models idle themselves when they can’t add value (45% at scale). For a usage-billed client, that’s automatic spend reduction — a feature you can surface in reporting.

5. The capability threshold is a deployment guardrail. Before you let agents self-organize on a client’s small/cheap model, test for the threshold. If the model can’t self-reflect (won’t abstain), don’t give it freedom — give it the rigid Coordinator structure. Getting this wrong is how a self-organizing system silently degrades.

6. The three-ring constitution = your governance deliverable. Ring 1 (mission, values, the right to abstain) = human-only. Ring 2 (metrics, audit) = system proposes, human approves. Ring 3 (protocol params, batch sizes) = system auto-tunes via A/B. This is a ready-made governance doc structure for enterprise clients nervous about “autonomous agents.”

Build Your Own (Minimal Recipe)

You can capture ~80% of this paper’s value in an afternoon. The hard parts are the evaluator and the abstention prompt, not the orchestration.

Components (build in this order):

1. Agent pool — N identical agents, each just a model call. No role descriptions. They’re interchangeable until the task arrives.
2. The Sequential loop — the function above. Fixed order list, accumulate completed outputs, pass them forward. This is the core and it’s trivial.
3. The role+abstain decision step — one prompt per agent: “given what’s done, what role do you take, or abstain?” This is where the magic lives. Get the abstention instruction right — too eager to abstain and coverage collapses (the weak-model failure mode).
4. An independent LLM judge — a different model scoring the 5 criteria on a 1–4 scale. This is the genuinely hard part: unstable judges make all your A/B comparisons meaningless. Use temperature 0, fixed criteria with verbal anchors, and hold the judge constant across any comparison.
5. A protocol switch — implement both Sequential and Coordinator so you can A/B them on a client’s real tasks rather than trusting the paper’s synthetic numbers.

Reach for: any orchestration framework you already use (LangGraph, AutoGen, or plain Python — the loop is so simple you barely need one). Models: a strong one (Claude/GPT) + a cheap one (DeepSeek/GLM) so you can replicate the cost-routing result. Total scope: a weekend for the loop + judge; the ongoing work is tuning the abstention and judge prompts on your domain.

The one thing not to skip: measure the capability threshold on whatever model you deploy. Run free-form vs. fixed-role on 50 tasks; if fixed-role wins, your model is below threshold — fall back to Coordinator.

How to Improve It

1. Batched Sequential (the obvious win, author-flagged). Sequential is O(N) latency — agent N waits for all N−1 predecessors. Run agents in groups of K in parallel, then each group sees all prior groups’ outputs. Gets you O(N/K) latency while keeping most of the “see real outputs” advantage. This is the highest-value extension and a great product feature (quality of Sequential, closer to Broadcast’s speed).

2. Replace the LLM judge with a hybrid evaluator. The single biggest credibility gap is LLM-only scoring. Add programmatic checks where possible (does the code run? does the plan satisfy stated constraints?) and a human-rated calibration subset. For your own deployments, anchor the judge to real outcome signals (did the client accept the deliverable?).

3. Adaptive ordering, not just fixed ordering. The paper fixes the order arbitrarily. Test whether ordering by expected competence (cheap agents first for scaffolding, strong agents last to synthesize) beats random order. The sports-draft analogy suggests pick order matters.

4. A real-time visibility layer for Shared. The author diagnoses Shared’s failure as “no real-time visibility → role duplication.” Add a lightweight lock/claim mechanism (an agent broadcasts “I’m taking security” before committing) and see if you can get Shared’s parallelism with Sequential’s complementarity. This directly attacks the worst protocol’s root cause.

5. Combine with vertical self-improvement. The paper claims model capability and protocol are multiplicative. Test it: run self-improving agents (DGM-style) inside the Sequential loop. If the gains compound, you’ve got a genuinely novel result the author explicitly left on the table.

6. Dynamic threshold detection at runtime. Instead of pre-testing the capability threshold, monitor abstention rate live — if a model abstains ~0% or abstains excessively (incomplete coverage), auto-fall-back to a more structured protocol. Turns the threshold finding into a self-healing system.

Glossary

• Exogenous coordination — structure imposed from outside (you assign roles, a coordinator routes work). The “org chart” approach.
• Endogenous coordination — structure that emerges from within — agents pick their own roles based on context. Self-organization.
• Endogeneity paradox — the paper’s headline: neither full external control nor full autonomy is best; a hybrid (fixed order + free roles) wins.
• Sequential / Coordinator / Broadcast / Shared — the four protocols; differ by what info each agent sees (real outputs / a central plan / others’ intentions / stale history).
• Capability threshold — the minimum model strength (self-reflection + reasoning + instruction-following) below which self-organization hurts and rigid structure helps.
• RSI (Role Stability Index) — how much agents keep the same role across tasks. RSI → 0 means they reinvent roles every task (good, in free-form mode).
• Voluntary self-abstention — an agent deciding on its own it can’t add value and sitting out; a sign the model can self-reflect, and a free cost saver.
• Hierarchy Depth (HD) — longest chain of agent dependencies; the system grows this to ~2 layers (flat) and deeper for harder tasks, with no instruction.
• LLM-as-judge — using a separate model to score outputs on rubric criteria; here, a different model than the agents, to avoid self-grading bias.
• Cohen’s d — standardized effect size. d=0.8 is “large”; the paper’s d=1.86 is very large (the protocol difference is real, not noise).
• p-value — probability the result is due to chance; p<0.001 means very unlikely to be a fluke. (p=0.61 for 64→256 agents means “no real difference.”)
• Kruskal-Wallis test — a non-parametric test for whether several groups differ; used here to confirm 64 vs. 256 agents don’t differ in quality.
• Spectral gap (λ₂) — a graph-connectivity measure; staying constant (~1.93) as the system scales means the agent interaction network keeps its structure.
• Vertical vs. horizontal intelligence — making each agent smarter (vertical) vs. making the group coordinate better (horizontal); this paper is horizontal.
• Three-ring constitutional framework — governance model: Ring 1 mission/values (human-only), Ring 2 standards (human-approved), Ring 3 protocols (system-autonomous).