---
name: foundations-team-theory
description: Team-theory primitives for cooperative multi-agent decisions, subagent allocation, communication value, Dec-POMDPs, and decentralized control. Use when organizing agents.
compatibility: Portable core only.
version: "1.2"
last_validated: 2026-08-14
---

# Team Theory Foundations


10 canonical team-theory primitives for *cooperative* multi-agent decision problems — agents share a payoff but each sees a different slice of the world. Game theory handles strategic conflict; decision theory handles solo choice under uncertainty; team theory handles the regime in between, which is exactly where subagents and orchestrated AI agents operate.

The field was founded by Jacob Marschak (1955) and formalized by Roy Radner (1962). It is the formal basis for: when to centralize a decision, what each agent must observe, when communication pays for itself, and why decentralized teams can be optimal even with free communication channels. Modern multi-agent reinforcement learning (Dec-POMDPs, MARL) is its computational descendant.

## When to Apply

**Apply team-theory when:**
- Multiple agents with **shared payoff** but **partitioned observations** (the canonical subagent setting)
- Designing what each subagent sees vs. what is centralized
- Choosing between centralized orchestrator, decentralized swarm, and hierarchical structures
- Costing communication: is it worth the latency / token / coordination overhead?
- Building agent teams where role specialization matters (each agent owns a different observation lane)
- Multi-agent RL or Dec-POMDP problem framing

**Skip and use simpler alternatives when:**
- Agents have **divergent incentives** → use [foundations-game-theory](../foundations-game-theory/SKILL.md) (mechanism design, auctions, debates)
- Single agent / single-shot decision under uncertainty → use [foundations-decision-theory](../foundations-decision-theory/SKILL.md)
- Communication itself is the bottleneck on a known structure → use [foundations-information-theory](../foundations-information-theory/SKILL.md) (channel capacity)
- The problem is recursive control of a viable system, not a one-shot team decision → use [foundations-cybernetics-vsm](../foundations-cybernetics-vsm/SKILL.md)
- All agents see the same information — there is no team problem; centralize trivially

## Contents

- [Quick Reference](#quick-reference)
- [Primitive Index](#primitive-index)
- [Formal Supporting Theory](#formal-supporting-theory)
- [Anti-Patterns](#anti-patterns)
- [Decision Checklist](#decision-checklist)
- [Composition Recipes](#composition-recipes)
- [Workflow](#workflow)
- [ASCII Flow](#ascii-flow)
- [Navigation](#navigation)
- [Related Skills](#related-skills)
- [Fact-Checking](#fact-checking)

---

## Quick Reference

| # | Primitive | When to Reach For It |
|---|-----------|----------------------|
| 1 | [Team Decision Problem](#1-team-decision-problem) | Frame any shared-goal multi-agent setup before designing it |
| 2 | [Information Structure](#2-information-structure) | Decide what each agent observes; classify centralized / decentralized / partial / nested |
| 3 | [Person-by-Person Optimality](#3-person-by-person-optimality) | Local optimality check — necessary but not sufficient for team optimum |
| 4 | [Value of Communication](#4-value-of-communication) | "Should agents share state?" — quantify expected payoff lift vs. cost |
| 5 | [Radner's LQG Theorem](#5-radners-lqg-theorem) | Linear-quadratic-Gaussian teams admit a closed-form linear optimal rule |
| 6 | [Witsenhausen Counterexample](#6-witsenhausen-counterexample) | Why naive linearity fails when one agent's action signals to another |
| 7 | [Information Cost](#7-information-cost) | Bound observation/communication budgets; rationalize bounded rationality |
| 8 | [Organizational Forms](#8-organizational-forms) | Pick centralized vs. decentralized vs. hierarchical structure; see #8a (centralize/decentralize decision test) and #8b (team-size/coordination-cost curve) in `references/primitives-overview.md` |
| 9 | [Dec-POMDP / MARL Extension](#9-dec-pomdp--marl-extension) | Sequential team problems with state dynamics — modern computational form |
| 10 | [Common-Task Condition](#10-common-task-condition) | Boundary condition: when does shared payoff actually hold? |

Full definitions, inputs, outputs, failure modes, and worked examples: [`references/primitives-overview.md`](references/primitives-overview.md).

---

## Primitive Index

| # | Primitive | Failure Mode It Addresses |
|---|-----------|--------------------------|
| 1 | Team Decision Problem | Modeling cooperative agents as either a single decision-maker (loses decentralization value) or as strategic players (overstates conflict) |
| 2 | Information Structure | Agents observing redundant signals; missing observations; uncosted communication assumed free |
| 3 | Person-by-Person Optimality | Local-optimum trap: each agent optimal given others' fixed rules, but the joint policy is suboptimal |
| 4 | Value of Communication | "Add a Slack channel between agents" with no expected-payoff justification; channel may cost more than it earns; inter-agent message routing also degrades information efficiency via Data Processing Inequality even at zero explicit channel cost |
| 5 | Radner's LQG Theorem | Reinventing optimization for LQG teams when a closed-form linear rule exists |
| 6 | Witsenhausen Counterexample | Assuming linear policies are optimal when an agent's action carries signaling content |
| 7 | Information Cost | Designing perfect-observation agents in a world where observation has latency, token, and money cost |
| 8 | Organizational Forms | Defaulting to a central orchestrator when a decentralized or hierarchical form would dominate |
| 9 | Dec-POMDP / MARL Extension | Treating each timestep as a fresh team problem; ignoring history and state |
| 10 | Common-Task Condition | Calling a system a "team" when payoffs actually diverge — game theory regime, not team regime |

---

## Formal Supporting Theory

| Theory Area | Use When | Applied Primitives It Grounds |
|---|---|---|
| Marschak–Radner team theory | Need normative framing of cooperative multi-agent decisions | #1, #2, #3, #4, #5, #8 |
| Decentralized stochastic control | Action of one agent affects information of another | #6, #9 |
| Information economics | Need to cost observation and communication | #4, #7 |
| Organization economics | Compare centralized hierarchy, decentralized markets, polyarchy | #8 |
| Dec-POMDP and MARL | Sequential team problems with state dynamics | #9 |
| Mechanism design boundary | Where shared payoff breaks down | #10 (then exit to game-theory) |

See [`references/primitives-overview.md`](references/primitives-overview.md) for the formal-theory map and theorem statements.

---

## Anti-Patterns

| Anti-Pattern | Team Theory Diagnosis | Fix |
|---|---|---|
| One central orchestrator reads everything, decides everything | Centralized information structure used where decentralized partition is cheaper and equally optimal under Radner conditions | Apply #2 + #5: if the team is LQG-like and observations are local, a decentralized linear rule matches centralized payoff at lower cost |
| Each subagent given full system context "just in case" | Information cost (#7) ignored; redundant observations dominate token budget | Partition observations to what each agent's action depends on; redundancy must justify itself |
| Local optimization per subagent declared "team-optimal" | Person-by-person optimality (#3) confused with team optimum; PBPO is necessary, not sufficient | Verify joint optimum by varying any two policies simultaneously, not one at a time |
| "Add a comms channel between agents" added without payoff analysis | Value of communication (#4) not computed; channel may cost more than it earns | Compute expected payoff with vs. without the channel; if delta < cost, drop it |
| "Multi-agent by default for complex tasks" | Coordination overhead costs are O(N²) in token accumulation; DPI shows message routing loses conditioning information available in unified context | Default to single-agent for sequential reasoning tasks; require empirical evidence that parallelization actually helps before adding agents (Tran & Kiela 2026) |
| "Assume natural-language inter-agent messages are lossless" | Natural-language agent-to-agent messages are lossy compressions; semantic drift accumulates across rounds even with no explicit error (Rath 2026); embedding-space exchange is lossless at lower token cost (LatentMAS, ICML 2026 Spotlight) | For high-precision cooperative tasks, route inter-agent signals through shared latent representations rather than text (primitive #2 information structure design) |
| "Default to all-to-all communication between agents" | Dense topologies amplify error propagation in LLM multi-agent systems (Shen et al. 2025); moderately sparse topologies outperform both fully dense and fully sparse | Design inter-agent communication graphs at moderate sparsity; use adaptive topology if task structure changes dynamically (CARD, ICLR 2026) |
| "Put the expert on the team and the team will use them" | Aggregation rule, not expertise identification, is the binding constraint. Self-organizing LLM teams underperform their own strongest member by up to 41.1% because they converge on integrative compromise — averaging expert and non-expert views instead of weighting by competence — and the gap widens with team size (Pappu et al., ICML 2026). Teams identify the expert correctly and still fail to defer | Make deference explicit rather than emergent: route the decision to the competent agent instead of pooling opinions, or weight contributions by a verifiable competence signal. Note the tradeoff — the same consensus-seeking that suppresses expertise also buffers against adversarial members, so keep pooling where robustness matters more than peak accuracy |
| Assume linear/affine policies optimal in non-LQG team | Witsenhausen (#6) shows nonlinear policies can dominate when signaling exists | Check if any agent's action affects another agent's observation; if yes, allow nonlinear policies |
| Treat all multi-agent setups as game-theoretic | Common-task condition (#10) holds — agents share a goal — so mechanism-design overhead is wasted | Skip incentive compatibility; design for joint optimization directly |
| Treat all multi-agent setups as team problems | Common-task condition (#10) fails — agents have divergent goals — team theory underestimates conflict | Switch to game theory (auctions, mechanism design) |
| "Optimize the team's collective intelligence (c-factor)" (human teams) | The single-factor c-factor (Woolley et al. 2010) is weaker than its popular reception implies. Meta-analysis puts its correlation with external group performance at r=.26, and all but four of the pooled studies failed to control for members' individual intelligence (Rowe, Hattie & Hester 2021); Rowe, Hattie & Munro (2024, PLOS ONE) favor a two-factor (fluid/crystallized) structure over a unified c. Earlier non-replications exist for virtual text-based groups | Do not treat "collective intelligence" as a single tunable team property. Select on task-relevant individual competence and the information structure (#2) first; treat composition heuristics from this literature as hypotheses to test locally, not established effects |
| "Psychological safety assumed universally positive" (human teams) | Curvilinear boundary condition (Edmondson & Bransby 2023, Annual Review of OB, citing Eldor, Hodor & Cappelli 2023): high psychological safety may harm routine in-role performance by redirecting attention to exploration; benefit is robust for learning/adaptive tasks only; accountability structures moderate the downside. The curvilinear result rests on one five-study paper with no independent replication as of August 2026 — treat as a boundary condition worth testing, not settled. Also commonly conflated with comfort/niceness — see patterns-scenarios-traps.md for misreads | Apply psychological safety practices to adaptive/learning contexts; pair with accountability norms for routine-execution tasks; do not assume monotonic benefit; don't mistake candor-friendly for conflict-free |
| Hierarchical orchestrator-worker with no information flow back up | Polyarchy/hierarchy structure (#8) chosen by default; loses bottom-up signal that decentralized form preserves | Add upward observation channel or switch to decentralized form; for tasks with parallelizable subtasks at scale (>4 agents), consider emergent self-organization protocols where agents self-assign roles — this form dominates fixed hierarchy at scale (Dochkina 2026) |
| "Just add more agents/people, coordination scales for free" | Team-size/coordination-cost curve (#8b): pairwise coordination channels grow ~n(n-1)/2 with team size under high coupling; the marginal member's coordination cost can exceed their contribution (Brooks's Law) | Before adding a member/agent, count how many existing members it must (not could) coordinate with; if most, cut coupling first (modularize, assign a single owner for shared state) rather than adding capacity |
| "We are a centralized [org/agent system]" or "we are a decentralized one" applied blanket-wide | Centralize-vs-decentralize is a per-decision judgment (#8a: information compressibility, reversibility, coupling, blast radius of a wrong local call), not a company-wide or system-wide constant | Apply the four-question test per decision class; expect most real orgs and agent systems to be centralized on some decisions (shared state, brand, safety) and decentralized on others (local execution) |

---

## Decision Checklist

- [ ] **Shared payoff?** If no, exit to [foundations-game-theory](../foundations-game-theory/SKILL.md). If yes, continue (#10)
- [ ] **What does each agent observe?** Map the information structure explicitly (#2)
- [ ] **Are observations redundant?** Trim — observation has cost (#7)
- [ ] **Is communication channel justified?** Compute expected payoff lift; reject if < cost (#4)
- [ ] **For multi-agent topologies with N>2 agents: is the topology moderately sparse?** Dense (all-to-all) connections amplify error propagation in LLM systems and degrade beyond a threshold (#2, #4)
- [ ] **Is the team LQG-like (linear dynamics, quadratic payoff, Gaussian noise)?** If yes, closed-form linear rule available (#5)
- [ ] **Does any agent's action affect another agent's observation?** If yes, signaling exists — allow nonlinear policies (#6)
- [ ] **Sequential decisions over time with state?** Frame as Dec-POMDP (#9)
- [ ] **Picked an organizational form?** Centralized / decentralized / hierarchical — justify choice against the alternatives (#8)
- [ ] **Verified team-optimum, not just person-by-person optimum?** Vary joint policies, not single-agent policies (#3)
- [ ] **Does the aggregation rule weight by competence, or does it pool?** If agents differ in task-relevant skill, opinion pooling destroys the expert's advantage; route or weight instead (#3, Pappu et al. 2026). Check the single-best-member baseline before shipping any team design
- [ ] **Virtual/distributed team?** Match communication medium to task type — divergent/generative tasks are virtuality-tolerant; convergent/evaluative tasks require video-first (Sinnemann & Weiss 2025 meta-analysis, N=7,004 teams, no significant main effect; moderation by task type and medium is significant)

---

## Composition Recipes

### Designing a subagent team for a research task

_Context_: Orchestrator needs to dispatch N subagents on a multi-source research task with a shared answer goal.

1. Verify common-task condition (#10): all subagents and orchestrator share the payoff "produce one accurate answer." If not, exit to game-theory.
2. Map information structure (#2): which sources/files/tools does each subagent observe? Avoid redundant assignment. For human-in-the-loop teams: the temporal ordering of observation matters — simultaneous presentation of human and AI outputs outperforms sequential (human-first then AI) on average (npj Artificial Intelligence 2025, N=52 clinical studies). Design observation lanes with this moderator in mind. **CTP conditions (Hemmer et al. 2024, EJIS 2025)**: human-AI complementarity — performance exceeding either agent or human alone — requires either (a) information asymmetry (human has local context AI lacks) or (b) capability asymmetry (human provides judgment on novel cases AI cannot handle). If neither condition holds, removing the human from the loop and relying on AI alone typically dominates. Verify both conditions before designing a human-in-the-loop step.
3. Cost observations (#7): each tool call has token + latency cost. Allocate observations so that marginal payoff per token decreases monotonically.
4. Compute value of communication (#4): does mid-task chatter between subagents lift expected payoff more than its cost? Default: no — most subagent teams are decentralized with synthesis at the end.
5. Pick organizational form (#8): single orchestrator + parallel decentralized workers (the "split-and-merge" pattern) is the LQG-analog default. Hierarchical only if subgoals are themselves teams.
6. Verify team-optimum (#3): inspect whether changing two subagent prompts simultaneously could improve joint payoff. If yes, the design is person-by-person optimal but not team-optimal.

### Choosing between orchestrator-led and swarm forms

_Context_: A product team must pick between a single planner agent that delegates everything (centralized) and a peer-to-peer agent network (decentralized).

1. Check #5 conditions: linear dynamics, quadratic-like payoff, Gaussian-like noise. Few real agent systems meet this — but it gives the upper bound.
2. Cost the communication channel: orchestrator-led requires every observation to flow up and every decision to flow down. Decentralized requires only local observation but needs convergence on the synthesis.
3. Apply #8: under high information cost and low signaling content, decentralized dominates. Under low info cost and high coupling between agents' actions, centralized dominates. For tasks with 4+ agents and parallelizable subtasks, add a fourth option: emergent self-organization with minimal structure (sequential protocol + autonomous role assignment). At 256 agents this scales sub-linearly; fixed hierarchies do not. Justified by Dochkina (2026, arXiv:2603.28990) and CARD (Wu et al., ICLR 2026).
4. Worked example: code review across 5 files. Files are independent (no signaling, low coupling). Decentralized form (5 parallel reviewers + final aggregator) dominates orchestrator-led. Code review across one tightly-coupled module: signaling is high (one agent's finding changes another's interpretation); centralized or hierarchical wins.

### Sizing the orchestrator's context budget

_Context_: How much should the orchestrator observe vs. push down to subagents?

1. Apply #7: every token in the orchestrator's context has cost. The orchestrator should hold only what is needed to decide *who decides what*, not the underlying domain content.
2. Apply #2: orchestrator's information structure should be the meta-state (task graph, subagent roster, success signals), not the object-level state.
3. Anti-pattern: orchestrator reads all source files and then asks subagents to summarize them — observation paid for twice. Fix: orchestrator observes file *list*; subagents observe file *contents*.

### Designing subagent context as an information-structure problem (AI app builders)

_Context_: You are building a multi-agent AI application and must decide what context (system prompt, retrieved docs, tool permissions, conversation history) each subagent receives.

1. **Name the information structure first (#2).** For each subagent, write a one-row entry: `agent | observation sources | action produced`. This is the `η` partition —