foundations-team-theory

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 (mechanism design, auctions, debates)
• Single agent / single-shot decision under uncertainty → use foundations-decision-theory
• Communication itself is the bottleneck on a known structure → use foundations-information-theory (channel capacity)
• The problem is recursive control of a viable system, not a one-shot team decision → use foundations-cybernetics-vsm
• All agents see the same information — there is no team problem; centralize trivially

Contents

• Quick Reference
• Primitive Index
• Formal Supporting Theory
• Anti-Patterns
• Decision Checklist
• Composition Recipes
• Workflow
• ASCII Flow
• Navigation
• Related Skills
• Fact-Checking

Quick Reference

Full definitions, inputs, outputs, failure modes, and worked examples: references/primitives-overview.md.

Primitive Index

Formal Supporting Theory

See references/primitives-overview.md for the formal-theory map and theorem statements.

Anti-Patterns

Decision Checklist

• Shared payoff? If no, exit to foundations-game-theory. 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 — make it explicit before writing any code.
2. Apply the task-type rule. Parallelizable subtasks with no shared state (e.g., reviewing independent files, generating independent sections) → decentralized partition, zero cross-agent context. Sequential or tightly-coupled subtasks → centralized or hierarchical; pass only the predecessor's decision output, not its full reasoning trace.
3. Strip context to decision-relevant signals (#7). Each token in a subagent's context window is an observation cost. Give the subagent only what changes its action. If a document section never alters the subagent's output, remove it from its context.
4. Check for signaling (#6). If subagent A's output becomes part of subagent B's context (e.g., B reads A's draft), you are in non-classical territory. Do not assume A's optimal policy is the same as if it were working in isolation — A should write with B's downstream use in mind (nonlinear policy).
5. Compute value of communication before adding agent-to-agent messaging (#4). Does mid-task chatter between subagents increase the joint answer quality by more than the latency + token cost? Default answer is no for most parallelizable tasks; require evidence before adding it.
6. For >4 subagents on parallelizable work, prefer decentralized + late synthesis over a central orchestrator reading everything — observation cost is O(N) in the centralized form vs. O(1) per agent in the decentralized form (#8, Dochkina 2026).

Workflow

1. Confirm common-task condition (#10). If payoffs diverge, exit to game-theory.
2. Map the information structure (#2): one agent per row, one observation source per column, fill the matrix.
3. Cost the observations (#7) and the communication channels (#4).
4. Pick organizational form (#8) — centralized, decentralized, hierarchical — justified against alternatives.
5. Check LQG conditions (#5); if met, use the closed-form rule. If not, watch for signaling (#6) and allow nonlinear policies.
6. Verify joint optimum (#3), not just per-agent optimum.
7. For sequential problems with state, frame as Dec-POMDP (#9) and pick an MARL solver.

ASCII Flow

Cooperative multi-agent decision
  -> Confirm shared payoff and common-task condition
     +-- payoff diverges -> exit to game theory
     +-- shared payoff holds -> map information structure
  -> Cost observation and communication channels
  -> Choose centralized, decentralized, or hierarchical form
  -> Check joint optimum and sequential-state needs
  -> Return team design, information lanes, communication rule, and solver path

Navigation

• Domain-agnostic primitives overview: references/primitives-overview.md
• Formal theory map and production boundaries: references/formal-theory-map.md
• Patterns, scenarios, and traps for multi-agent / subagent design: references/patterns-scenarios-traps.md
• Sources: data/sources.json

Related Skills

• foundations-game-theory — exit here when payoffs diverge
• foundations-decision-theory — single-agent uncertain choice
• foundations-information-theory — pricing the channel
• foundations-cybernetics-vsm — recursive viable-system control
• foundations-grounding-communication — how agents share state once you decide they should (see also: temporal information structure in human-AI teams — primitive #2, npj AI 2025)
• agents-subagents — applied subagent patterns
• agents-swarm-orchestration — applied multi-agent orchestration

Fact-Checking

• Marschak (1955) "Elements for a Theory of Teams." Management Science 1(2). Founded the field.
• Marschak and Radner (1972) Economic Theory of Teams. Yale. Canonical text.
• Radner (1962) "Team Decision Problems." Annals of Mathematical Statistics 33(3). LQG theorem.
• Witsenhausen (1968) "A Counterexample in Stochastic Optimum Control." SIAM J. Control 6(1). Nonlinear-dominance result.
• Bernstein, Givan, Immerman, Zilberstein (2002) "The Complexity of Decentralized Control of Markov Decision Processes." Math. of Operations Research. Dec-POMDP framing — NEXP-complete.
• Oliehoek and Amato (2016) A Concise Introduction to Decentralized POMDPs. Springer.
• Numeric thresholds (cost-of-communication, observation budgets) are domain-specific. Verify against primary references before using as decision authority.
• Brooks, F.P. (1975/1995) The Mythical Man-Month. Addison-Wesley. Source for the team-size / coordination-cost curve (#8b): pairwise coordination links grow combinatorially with team size, used here as a qualitative mechanism, not a quantitative team-theory result.
• Eldor, Hodor, and Cappelli (2023) "The limits of psychological safety: Nonlinear relationships with performance." Organizational Behavior and Human Decision Processes 177, article 104255. Primary empirical source for the curvilinear boundary condition cited via Edmondson & Bransby (2023). Title, authors, volume, and article number confirmed 2026-08-14; full text remains paywalled. No independent replication located as of 2026-08-14, and the paper has drawn (non-peer-reviewed) methodological criticism over supervisor-rated performance measures and the arbitrariness of the 80–90th-percentile turning point — do not present the inverted-U as a settled effect.
• Collective-intelligence caveat: Rowe, Hattie, and Hester (2021) "g versus c: comparing individual and collective intelligence across two meta-analyses." Cognitive Research: Principles and Implications. Pooled 857 groups across nine criterion tasks; c-factor correlates r=.26 (95% CI .10–.40) with group performance, and all but four studies failed to control for members' individual intelligence. Rowe, Hattie, and Munro (2024, PLOS ONE 19, e0307945, N=85 individuals in 29 groups) favor a two-factor fluid/crystallized model over Woolley et al.'s (2010) single c-factor. Small samples on both sides — cite as "contested," not "refuted."
• Expertise aggregation failure: Pappu, El, Cao, di Nolfo, Sun, Cao, and Zou (2026) "Multi-Agent Teams Hold Experts Back." arXiv:2602.01011, ICML 2026. Self-organizing LLM teams underperform their strongest member by up to 41.1% on ML benchmarks, even when told who the expert is; mechanism is integrative compromise, worsening with team size. Consensus-seeking simultaneously improves adversarial robustness — a genuine tradeoff, not a pure defect.
• DPI argument for single-agent dominance: Tran & Kiela (2026, arXiv:2604.02460) demonstrate empirically across four model families and five MAS architectures that single-agent systems match or exceed multi-agent on multi-hop reasoning under equal token budgets, with theoretical grounding in the Data Processing Inequality.
• Latent-space inter-agent communication: LatentMAS (Zou et al. 2025, arXiv:2511.20639, ICML 2026 Spotlight) demonstrates that sharing last-layer embeddings between LLM agents achieves lossless information exchange with 14.6% accuracy gains and 4× inference speedup over text-based multi-agent baselines across 9 benchmarks. Code at github.com/Gen-Verse/LatentMAS.
• Emergent self-organization at scale: Dochkina (2026, arXiv:2603.28990, IEEE Access) demonstrates across 25,000 tasks and 8 model families that self-organizing agents with minimal structure outperform designed hierarchies by 14% (Cohen's d=1.86) and scale sub-linearly to 256 agents. Corroborated by CARD (Wu et al., ICLR 2026) and MegaAgent (ACL 2025).
• Human-AI teaming mode as information structure: Systematic review (npj AI, Nature portfolio, December 2025, N=52 clinical studies) finds simultaneous human-AI observation outperforms sequential mode; corroborated by PRISMA review of 104 studies (Kargarnovin et al., Frontiers in Robotics and AI, 2026) and PNAS Nexus complementarity framework (Gonzalez et al., 2026).

Learnings Loop

Before applying this skill on a non-trivial task, read learnings.consolidated.md in this directory (and learnings.md if present).

After applying it, if you encountered a pattern worth remembering, a mistake worth preventing, or a domain fact that surprised you, append one dated bullet to learnings.md via agents-skills-feedback-loop/scripts/append_learning.py. Do not modify SKILL.md itself.