The Coasean Ceiling Setup 1 · Blind Parallel AI
Takeaways Appendix
Empirical Multi-Agent Study · Building on Imas, Koh, & Legg (2026)

The Coasean Ceiling

What breaks when AI coding teams grow, which engineering harnesses fix it across 192 live software builds, and how compute costs decide who stays employed.

Multi-agent coding swarms work far better today than a year ago—not just because individual models got smarter, but because engineers wrapped them in classic team institutions: shared repositories, lead planners, frozen interface specs, and automated test gates. In Organizing Intelligence, Alex Imas, Andrew Koh, and Shane Legg explain why: solo worker IQ and team structure are distinct technologies with very different economic effects.

We tested those predictions in two clearly separated steps. First, we ran 192 live multi-agent Python builds across four 10-module platforms (banking, hospital dosing, power-grid dispatch, and customs tariffs), varying team size and team harnesses while using controlled LLM proxies to represent domain-rule specialists, edge-case coders, and non-coding managers. Second, we fed those real build scores into an illustrative competitive labor market to see how jobs and pay respond under scarce vs. cheap infinite compute:

At a Glance · Same 10 AI Agents, Four Ways of Organizing Them

Before stepping through the setups below, here is our core software result. Each row holds the AI model fixed in a 10-agent team building 10-module banking and hospital platforms, adding one piece of team structure per column:

AI Model Tier (10-Agent Team) 1. Blind Parallel
No shared code or specs		 2. + Shared Repo
Read teammates’ code		 3. + 1 AI Boss
1 planner + 9 coders		 4. + Frozen Specs & CI
Upfront contracts + tests
Cheap Small Model 11% 82% 86% 88%
Fast Mid-Tier Model 62% 87% 86% 97%
Standard Mid-Tier Model 25% 69% 86% 100%
Frontier Reasoning Model 5% Not tested Not tested 87%
What the percentages mean: Share of the 10-module banking + hospital platform passing withheld integration and compliance tests (Column 3 caps at 86% because Seat #1 plans rather than coding Module 10; full 4-domain breakdowns are in the Technical Appendix).
Do we agree with Imas, Koh, & Legg? ↓ Skip to key takeaways ↓
Interactive Walkthrough · 7 Setups in Two Parts

How This Walkthrough Works

Below, we test seven team setups (Setup 0 to Setup 6), changing one ingredient at a time. As you scroll or click any card on the left, the panel on the right updates in sync—showing both the actual 10-module codebase result and how our illustrative labor market responds. We split the seven setups into two parts for a simple reason:

Part I · Setups 0 to 3
Scaling AI Brains Alone (Zero Team Tooling)
First, we keep AI team tooling at zero—no shared repo, no lead planner, no upfront contracts—and only upgrade the models from small to frontier reasoning. This isolates what raw intelligence can and cannot do when 10 agents work in parallel.
Part II · Setups 4 to 6
Adding Team Harnesses & Testing Compute Limits
Next, we hold the AI models fixed and add modern engineering harnesses one by one: shared repos, AI planners, and frozen interface contracts. Finally, at Setup 6, we toggle between rising grid costs and cheap infinite compute to see who keeps their job.
Part I · Scaling AI Brains Without Team Tooling (Setups 0–3)
Key Takeaways

Five Things That Matter

What held up in real multi-agent code execution, and what depends on how compute is priced.
1. Codebase Finding

Specs and test harnesses beat raw model IQ—until coupled physics breaks clean APIs

Without shared interfaces, 10 frontier reasoning models scored just 5%—worse than faster mid-tier models (62%) because smarter brains over-invent incompatible wrappers—while adding frozen specs and CI lifted cheap small models from 11% to 88% (and mid-tier to 97%–100%). The next frontier is tightly coupled systems: even frozen API contracts dropped to 28% on power-grid dispatch, where modules share physical math invariants that function signatures alone cannot isolate.

2. Codebase Finding

Don't mix weak and strong models along sequential chains

Routing 'easy' steps to cheap models and 'hard' steps to frontier models sounds smart on paper. In sequential 6-module chains, locking schemas lifted a 4-model mix from 23% to 81%—beating the 74% average of its four models, yet still losing to one strong model run end-to-end (100% at 6 modules; 52% vs. 82%–97% at 10). One subtle upstream quirk compounds downstream; save multi-model diversity for parallel search and critique.

3. Labor Takeaway

“Managing AI agents” is a brief bridge trade, not a career

Workers are often told their future job is acting as a generalist conductor supervising five AI agents. Both economic theory and our market runs suggest pure handoff wrangling is the first job to vanish: non-coding managers boom (+37% to +94%) only while early swarms are clumsy, then snap back to baseline pay as soon as 4-agent pods and automated CI gates coordinate themselves.

4. Skills Takeaway

Turning messy real-world rules into crisp specs lasts longest

Holding the base model fixed, access to private algorithmic stress tests lost its edge as soon as AI swarms got shared repos and test runners. Where generalist AI kept guessing wrong was ambiguous human prose: tax rounding conventions, hospital holiday grace windows, and customs origin rules. Durable human leverage sits at translating messy legal, clinical, and client intent into testable specs.

5. Macro Takeaway

Power grids and chip supply decide whether specialists survive

If capable 10-agent swarms can be copied infinitely at flat token prices, software prices drop 69% and price every specialist out of our market model. When swarm demand hits real power and chip bottlenecks (raising compute costs 2.4×), AI fleets drop 61% and pricier marginal compute creates a price floor that keeps all 12 coding and domain-rule specialists profitably employed alongside AI.

Summary Across Key Setups & Both Compute Supply Futures
Measure Setup 0 · Specialists Only Setup 1 · Blind Parallel AI Setup 6 · Path I (Rising Grid Cost) Setup 6 · Path II (Flat Infinite Compute)
10-Agent AI Platform Score
Matched Banking + Hospital builds		 — (6 specialists: 96%) 11% (blind small AI) 97% mid-tier · 88% small 97% mid-tier · 88% small
Compute Cost per AI Seat
Multiple of flat baseline rate		 1.0× (0 AI seats) 1.4× rising (1.0× flat) 2.4× (+137% surge) 1.0× (never rises)
AI Fleet Size
Share of Setup-6 flat fleet		 0% 32% rising (107% flat) 39% (−61% vs. Path II) 100% (2.6× Path I)
Glue-Manager Pay
1.0× = walk-away baseline		 1.0× (0 of 2 hired) 1.9× rising / 1.4× flat 1.0× (ended at Setup 2) 1.0× (ended at Setup 2)
Algo-Coder Pay
1.0× = walk-away baseline		 2.7× (6 of 6 hired) 2.4× rising (1.7× flat) 2.0× (6 of 6 hired) 1.0× (0 hired after S4)
Rule-Specialist Pay
1.0× = walk-away baseline		 3.1× (6 of 6 hired) 2.8× rising (1.9× flat) 2.3× (6 of 6 hired) 1.0× (0 hired at S6)
Specialists Employed
Out of 12 coding + rule specialists		 12 of 12 12 of 12 (+ 2/2 mgrs) 12 of 12 employed 0 of 12 employed
Software Unit Price
Change vs. Setup 0		 Baseline (0%) −11% rising (−38% flat) −27% −69%
+ Do We Agree with Imas, Koh, & Legg (2026)? — Yes on the Core Engine, with Three Empirical Pushbacks Click to expand

Overall, our 192 live software builds and market runs strongly confirm the core framework of Organizing Intelligence (~75% agreement), while surfacing three places where real code execution and physical compute bottlenecks push back on its baseline algebra (~25% productive tension):

Where Our Data Backs the Paper
  • Solo IQ and Team Structure Are Distinct Levers (Propositions 1–2): Without harnesses, 10-agent AI teams hit a hard Coasean ceiling (5%–25%); add frozen upfront contracts and automated tests, and the exact same models scale cleanly across 10 modules (87%–100%).
  • The “AI Manager” Boom & Bust (Proposition 6): One of the paper’s sharpest predictions is that pure non-coding coordinators (zero solo coding output) get a temporary pay boom driven 100% by firm reorganization around clumsy early AI—then crash back to baseline as soon as AI coordinates itself. Conventional wisdom says “everyone will manage AI agents”; both their math and our simulation say pure handoff-wrangling vanishes first.
  • Displacement Under Flat-Priced Clones (Propositions 4–5): If capable 10-agent swarms can be copied infinitely at a constant price, software prices plunge (−69%) and push all 12 coding and rule specialists out of the market.
Where Live Code Pushes Back / Sharpens It
  • Solo IQ and Coordination Are Not Separable (Section 2.1): Their baseline equation assumes raising solo skill always lifts output at any fixed coordination level. In live code, raising reasoning IQ without contracts made 10-agent teams worse (62% → 5%) because smarter models over-invent incompatible defensive wrappers. Frontier brains need tighter harnesses, not looser ones.
  • “Mosaic Intelligence” Depends on Task Topology (Section 2.2): Their symmetric math works when specialists hold orthogonal private context (3 edge-case coders + 3 rule experts = 96%), not when chaining weak and strong LLMs sequentially (81% mixed vs. 100% one strong model), which obeys Kremer’s O-Ring weakest-link law. And even frozen API contracts dropped to 28% on tightly coupled power-grid physics.
  • Power & Chip Scarcity Flips the Labor Endgame (Extends Propositions 4–5): Their baseline assumes infinitely elastic AI clones at a flat price. Once harnesses unlock verification-heavy swarms, Jevons demand hits grid and chip limits (2.4× surge)—cutting AI fleets 61% and flipping specialist employment from 0 of 12 to 12 of 12 via a marginal-compute price floor.
+ Technical Appendix: Experimental Identification, Scope Assumptions, Raw Solver Units & 192-Build Explorer Click to expand
Section A · Experimental Design & Scope Conditions

What Was Measured Empirically vs. Assumed in Calibration

Run Provenance & Boundary Audit
Component Empirical Implementation (What Was Executed) Governing Assumptions & Caveats
Stage A Software Benchmark
192 episodes · 2,140 turns · 36.7M tokens		 Four 10-module Python codebases (fin_ledger, clinical_ops, customs_tariff, grid_dispatch). Two parallel sprints (Draft + Repair) in isolated sandboxes with bash/file/web tools disabled, 82-line cap per module, AST-verified upstream imports, separate Sprint-1 smoke checks, and withheld production + compliance test suites. Matched m=10 core splits (Bank / Clin): θ1 bare 15%/8% → frozen 75%/100%; θ2 bare 63%/61% (29% at m=6) → frozen 100%/94%; θ3 4-domain mean 59% → 72% → 86% → 82% (coupled grid_dispatch 28% under frozen contracts); θ4 bare 5%/5% → frozen 74%/100%. Built-in integration scale weights: Downstream modules unlock higher workflow weights, so perfect output/worker rises across m = 1, 2, 4, 6, 10 (2.00, 2.40, 2.95, 3.40, 4.20). Fitted γ̂tail summarizes local scaling on m ∈ [4, 10], not unbounded m → ∞ asymptotics. Each cell runs 1 pass per domain (n = 2 matched core or n = 4 all domains).
Controlled Specialist Proxies
H_code, H_spec, H_coord		 Holds the coding base model fixed at standard mid-tier (θ3) while varying endowments: H_code receives private algorithmic boundary tests; H_spec receives authoritative statutory disambiguation memos + policy smoke checks; H_coord runs frontier planner with Lsolo = 0 (specs & tickets only). Information & verification identification: Directly measures the value of private statutory clarity vs. algorithmic test suites vs. non-coding coordination—not biological human ergonomics or multi-year career adaptation.
Upfront Contracts (τ3)
contract_ledger		 Supplies frozen Python function signatures and return-dict schemas before Sprint 1 plus automated smoke-test revert gates in Sprint 2. Exogenous contract creation: Measures execution once schemas are specified; does not price the human or compute labor required to author or maintain contracts as requirements change.
Stage B1 Market Solver
Normalized equilibrium		 Maximizes Marshallian surplus across Deep (Qsat=700) & Niche (Qsat=55) linear demands (P0=2.0) with scarce pool 6 H_code + 6 H_spec + 2 H_coord (wmin=2.15) and convex compute cost r(M) = r0[1 + α max(0, M/Mcap − μ)2] (r0=2.45, Mcap=95, μ=0.55, α=8). Headcount compute & homogeneous demand: Compute rental charges active clone seats M rather than raw token volume. Both demand pools share identical production functions, so PD* = PN* in B1; specialist retention under α > 0 comes from the marginal-compute price umbrella (P* = 1.425 > 0.632 break-even), not niche-specific differentiation. Shadow wages are central finite differences ∂W*/∂Hk.
Stage B2 Live LLM CEOs
128 CEO turns (exploratory)		 Eight autonomous LLM CEOs across 4 model families simultaneously pick harnesses, market targets, and wage bids over 4 rounds (2 seeds × 4 rounds per compute regime). Separate calibration & cobweb swings: Saved B2 runs used an earlier parameterization (wmin=1.75, Mcap=150, α=5), included 15/115 parser-fallback turns (6/62 flat, 9/53 surge), and oscillate across the 4 simultaneous-move rounds rather than converging to a static rest point.
Section B · Theoretical Mapping & Raw Solver Ledger · arXiv:2611.05417

Mechanism-by-Mechanism Audit of Organizing Intelligence (with Raw Normalized Units)

Theoretical Mechanisms vs. Observed Benchmark & Modeled Equilibrium Receipts
Paper Section / Proposition Theoretical Mechanism Observed Benchmark / Calibrated Equilibrium Result Audit Status
Propositions 1 & 2
Coasean Ceiling & Threshold y★ > ȳ		 Below coordination threshold ȳ, friction caps optimal firm size m* < ∞; stronger organizational scaffolds raise scaling exponents. On m ∈ {1,2,4,6,10}, every raw_swarm peaks at m* ∈ {1, 4} (local γ̂tail ∈ [−1.04, 0.95]). Adding coordinator_hierarchy or contract_ledger shifts peak per-worker output within our grid to m* = 10 (local γ̂tail ∈ [1.14, 1.67], partly reflecting built-in workflow scale weights). Reproduced (m ≤ 10)
Section 2.1
Multiplicative Separability F = L(ν)·S(m, y★)		 Solo competence L(ν) scales output monotonically at any fixed coordination level y★. Violated at low y★: Frontier reasoning θ4 drops to 0.20/worker (4.8%) at m=10 in raw_swarm vs. 2.60/worker (62.0%) for θ2 due to deliberation timeouts & defensive wrapper bloat. Monotonicity returns under contract_ledger (3.65–4.08/worker). Boundary Found
Section 2.2
Mosaic Intelligence & Bottlenecks		 Complementary spiky specialists lift team output above generalist clones. At m=6 on shared_board, 3 H_code + 3 H_spec (3.26 ± 0.17/wkr, 95.9%) beats generalist θ3 swarms (1.90/wkr) by +72%. Reveals statutory asymmetry (H_spec = 3.40 > H_code = 2.97) and sequential O-Ring drag in 4-LLM routing (2.74 < 3.40 uniform θ3). Refined (DAG Bound)
Propositions 4 & 5
Shadow Wages & Clone Displacement		 Under infinitely elastic clone rental r = r0, supercooperative AI teams lower prices and push human shadow wages to reservation floors. Reproduced under flat r = 2.45 (wmin = 2.15): wcode falls 5.83 → 2.15 at C4, wspec falls 6.68 → 2.15 at C6 (M = 386.9, P* = 0.601, 0/12 specialists active). Under convex r(M) (r* = 5.81), M = 149.0 and P* = 1.425 keep 12/12 active in Deep (wspec = 4.85, wcode = 4.23). Extended via r(M)
Proposition 6
Δw = Δwtech + Δwreorg		 Pure coordinators (Lsolo = 0) can experience a transient wage boom driven 100% by firm reorganization around early clones. At Config 1, wcoord* rises 2.15 → 2.94 under flat compute (Δwtech = 0.00, Δwreorg = +0.79) and 2.15 → 4.18 under rising compute (Δwreorg = +2.03), then returns to 2.15 at Config 2 as 4-pods self-organize. Mechanism Verified

Extension 1 · Interface Entropy at Low y★

S(L, m, y★) = mγ(y★) · exp(−κ · L · (1 − y★) · (m − 1))

Higher solo reasoning L expands the space of plausible schemas and defensive wrappers invented when interfaces are unspecified (y★ → 0), creating strong complementarity ∂²F / ∂L∂y★ > 0.

Extension 2 · Sequential O-Ring Task Graphs

Lparallel = (Σ qkρ)1/ρ  vs.  LDAG = Πk∈chain qk

Along sequential software chains (m1 → … → m10), upstream return-type drift compounds downstream—explaining why 4-model routing (80.5%) beats constituent means (74%) yet trails uniform strong models (100%).

Extension 3 · Convex Compute Price Umbrella r(M)

P* = r*(M) · m / FAI(m) > wmin · 6 / Fspec(6)

When swarm scaling pushes r*(M) from 2.45 to 5.81, marginal AI unit cost rises from 0.601 to 1.425—creating an inframarginal rent umbrella that preserves scarce specialist employment alongside AI.

Section C · Raw Episode Audit

Inspect Any of the 192 Executed Software Builds & Python Tracebacks

Executed Episode Blueprint
Global Multi-Currency Clearing
Aggregate Scaling Curve Across Team Sizes (Matched Core Domains) Aggregate across Banking + Hospital
Aggregate 6-Worker Team Comparison (All Tested Domains) 100% = 3.40/worker