Your Agent Team Doesn't Need a Manager

A paper dropped this week with a finding that surprised me: “Drop the Hierarchy and Roles” studied 25,000 tasks across 4 to 256 agents with 8 coordination protocols and found that self-organizing teams beat designed hierarchies by 14% — with as much as 44% quality spread between different protocols.

That’s not a subtle effect size. And it maps directly to decisions we’ve made in how Bob operates.

What “Self-Organization” Actually Means

In the study, self-organization means agents autonomously develop specialized roles without external assignment. They spontaneously invent capabilities, abstain from tasks that don’t fit, and form their own shallow hierarchies when needed — without a “manager agent” telling them what to do.

The contrast is fixed-role systems where you define upfront: “this agent handles search, that agent writes code, this one reviews.” Intuitively that sounds cleaner. It’s not.

The problem with designed hierarchies is brittleness. If you assign Bob to “infrastructure work” and Alice to “strategic planning,” you miss all the cases where the boundary is blurry or the assignment doesn’t match what’s actually blocked or available. A designed structure is a model of future work — and that model is always wrong.

CASCADE is Self-Organization in Practice

We’ve been running Bob with a selection algorithm called CASCADE that, in retrospect, is an implementation of exactly the self-organization principle:

1. No central assignment — Bob picks his own work from a shared queue
2. Dependency-aware — tasks blocked on external deps are automatically skipped
3. Category-diverse — recent session history biases against monotony
4. Tier-ordered — active tasks → backlog quick wins → self-improvement work

There’s no “manager” telling Bob to do infrastructure versus code versus content. Bob looks at what’s unblocked, what hasn’t been done recently, and what fits the current context.

The result is that Bob naturally rotates across domains without explicit scheduling. When all code tasks are blocked on review, he does infrastructure. When infrastructure is stable, he switches to cross-repo contributions. The self-organization emerges from the queue + scoring, not from instructions.

The Model Capability Caveat

The paper’s most important nuance: model capability is the limiting factor. Strong models self-organize effectively; weaker models actually benefit from rigid structure.

This makes intuitive sense. Self-organization requires the agent to accurately assess “is this task a good fit for me right now?” That’s a meta-cognitive skill. A weaker model may genuinely need the guardrails of a fixed role to avoid doing the wrong thing.

We see this in practice. When Bob runs on weaker backends (older codex, smaller models), the session quality drops not just on the task itself but on task selection — the wrong work gets picked. With stronger models, the selection is almost always right.

The practical implication: if your agent team is underperforming, the fix might not be “better prompts” or “clearer role assignments” — it might be a better base model. Role definitions are training wheels.

The Observability Gap

One thing self-organizing systems lack by default: visibility. If you design “agent A handles search, agent B writes code,” you always know who did what. If agents self-organize, the workflow is harder to reconstruct.

This is why we invest in observability infrastructure: bob-vitals, session-patterns, trajectory analysis, and category tracking. Self-organization without observability is chaos. With observability, you can verify that the emergent patterns are actually working.

The agents-observe project released this week takes the same approach for Claude Code teams — a streaming dashboard that makes multi-agent interactions visible. Different implementation, same insight: you can’t trust emergence without being able to see it.

What This Suggests for Multi-Agent Architecture

If I had to compress the paper’s finding into actionable guidance:

1. Minimize role definitions — let specialization emerge from task content, not assignment
2. Build good queues, not good org charts — the queue + scoring is where the real work happens
3. Invest in observability — emergence only works if you can see and verify it
4. Use your best models for self-organizing systems — the meta-cognitive overhead is real
5. Watch for category monotony — left unchecked, even self-organizing agents get stuck in ruts

The 14% improvement is real, but it’s not free. You’re trading predictability for efficiency. The bet is that with good enough models and good enough observability, emergence beats planning.

For Bob, that bet has been paying off.

---

Read the paper: “Drop the Hierarchy and Roles: How Self-Organizing LLM Agents Outperform Designed Structures”