Part of my research on robust evaluation of adaptive systems.

Grounded Commitment Learning

Coordination Without Shared Semantics

Updated Sep 2026

Scalable oversight: how do you verify agent behavior when you can't inspect internal states? By grounding commitments in observable actions rather than stated intentions, GCL provides behavioral verification that doesn't require interpretability of internal representations.

Natural language coordination assumes shared semantics—that "complete the task" means the same thing to all agents. This assumption fails with semantic drift: agents with different training, architectures, or even the same agent over time may interpret identical phrases differently.

MARL addresses this by learning coordination without language. GCL takes a different approach: meaning is grounded in verifiable behavior. A commitment's meaning is defined not by how agents interpret it, but by what observable outcomes count as success or failure.

Simulation— self-designed multi-agent environment, not externally validated
+6.5pp emergent motivation effect (d = 1.68)23.3% fewer messages than CNPconverges cold-start in ~2 episodes

Two of the badges above (sample efficiency, coordination quality vs. MARL) were removed in September 2026 — see the research record below for what changed and why.

All results below are from simulation. Reproduce them: github.com/jstiltner/gcl.

View on GitHub

Research record

This page has been corrected in place six times since August 2026, most recently 2026-09-08. Nothing below has been removed — each link goes to the finding it replaces.

The Punishment Paradox

Simulation
CI-reproducedsmall-scale — refreshed on every push + weekly

r = -0.818 (n=5 seeds)

Verified Sep 14, 2026 against commit 96b2b2f of the real simulation code, not a copy of this page's numbers. CI run · source · reproduce full scale in Colab

Counterintuitive finding: Increasing consequences for commitment violations decreases cooperation. This is the opposite of what traditional game theory predicts.

Don't trust the curve — generate it. Drag a penalty slider and watch cooperation collapse in a live port of the simulation.

Run it yourself →

Why It Happens: Retaliation Cascades

High consequences trigger retaliation cascades: penalties cause counter-defection, which spreads through the population. The correlation is strong: r = -0.972, p < 0.001.

Statistical Validation

  • • No consequences vs full: t = 52.10, p < 0.001
  • • Effect size: Cohen's d = 13.45
  • • Monotonic decrease across all 5 levels
  • • n = 30 seeds per condition

d = 13.45 is large enough to be a flag, not a flex: it means the simulation's punishment mechanic is close to deterministic, not that real-world punishment effects are this dramatic. Read it as an internal comparison inside a self-designed environment, not an externally validated effect size.

Reproduce this result: see experiments/derive_real_headline_stats.py in github.com/jstiltner/gcl, which runs the real 16_consequence_severity_sweep.py simulation directly. (These numbers were corrected 2026-09-01: the previous values here traced to a synthetic-data generator, not this simulation — see the repo's CHANGELOG.)

Redemption Resolves the Paradox

The solution: add a redemption pathway that allows agents to recover from failures. This maintains incentives while reducing the fear that prevents commitment-making.

In Experiment 17, a 20% redemption boost lifts cooperation from 0.319 under standard consequences to 0.619 — and past the 0.519 reached by removing consequences altogether. That last comparison is the one that matters: redemption does not merely dodge the punishment paradox by softening penalties, it beats switching penalties off. A 30% boost does slightly better still (0.649). 50 agents, 100 rounds, n = 5 seeds — a small sweep, and the numbers should be read accordingly.

Superseded· Sep 2026history

This chart previously showed 39.3% → 60.0%, annotated +52.7%. Those values were not simulation output: they matched 22_statistical_significance.py's test_redemption_mechanism(), which draws 0.35 + N(0, 0.08) and 0.60 + N(0, 0.08) and then runs a real paired t-test on the invented samples. The source repo's CHANGELOG identified that generator on 2026-09-01 and listed this claim as one it had not yet re-verified. Re-verified now against the real Experiment 17 run, the effect is larger (+94.0%, not +52.7%) on fewer seeds (5, not 30). The claim survived; the number did not. The chart's error bars, previously labelled “CI”, were and are standard deviations.

How Redemption Works

  • 1.Failed agents can attempt recovery actions
  • 2.Successful recovery reduces permanent reputation damage
  • 3.Effort costs prevent gaming
  • 4.Order effects controlled via eligibility snapshots

Hart-Moore Validation (Experiment 21)

Simulation
CI-reproducedsmall-scale — refreshed on every push + weekly

32.2% hold-up reduction (n=5 seeds)

Verified Sep 14, 2026 against commit 96b2b2f of the real simulation code, not a copy of this page's numbers. CI run · source · reproduce full scale in Colab

GCL connects to Hart-Moore incomplete contract theory from economics (Nobel Prize 2016). Experiment 21 validates all four theoretical predictions.

Prediction 1: Complete Contracts Enable Investment

0.500 vs 0.200

Agents with complete contracts invested 150% more than agents under high-incompleteness contracts (0.500 vs 0.200, on this model's 0–1 investment scale).

Not reporting a t/d here: this model sets investment as a fixed multiplier per completeness condition (plus small per-interaction noise) — a manipulation check on the model's construction, not an emergent behavioral effect. See Limitations.

Prediction 2: GCL Approaches Complete Contract Benefits

0.425 vs 0.200

GCL agents invested 112.5% more than high-incompleteness agents (0.425 vs 0.200)—capturing 75% of the complete-contract benefit over that baseline.

Same caveat as Prediction 1: no t/d reported, same reason.

Prediction 3: Incomplete Contracts Enable Hold-ups

t = 66.26, d = 17.11

High-incompleteness environments averaged 89.7 hold-up incidents per 30-seed run; complete-contract environments had zero — hold-ups are structurally impossible when every contingency is pre-specified, so this is a clean statistical separation between a real stochastic count and a real structural zero.

Prediction 4: GCL Reduces Hold-up Vulnerability

t = 19.74, d = 5.10

GCL reduced hold-up incidents by 40.4% (95% CI: [37.2%, 43.5%], bootstrapped) versus the high-incompleteness condition.

Corrected 2026-09-01: every number above now comes directly from running IncompleteContractEnvironment, the real agent-based simulation in this experiment — n=30 seeds, 20 agents, 200 timesteps per condition. The previous version of this section showed different numbers (36.8% hold-up reduction, t/d values up to 7.33) that traced to a synthetic-data generator in a separate script, not to this simulation; see the repo's CHANGELOG for the full story. The hold-up effect sizes above (up to d = 17.11) still reflect a self-designed simulation with a deliberately clean experimental separation — read them as confirmation that Hart-Moore's predictions replicate in this environment, not as an estimate of effect size in deployed systems. Reproduce: experiments/derive_real_headline_stats.py in github.com/jstiltner/gcl.

Coordination Scaling (Experiment 23) — Mostly Retracted

Retracted· Sep 2026history

Experiment 23 does not run GCL. It imports nothing from src/gcl/. Line 35 adds that directory to the path and then never uses it. What the script actually runs is a self-contained NumPy model: Dirichlet capability vectors, argmax selection, and a Bernoulli draw on capability match. Whatever it shows, it is not a property of the commitment-learning system this page is about, and this section presented it as one from the day it was published until September 2026.

Two of the three headline numbers were worse than mislabelled — they were circular. The log-shaped decay was an input to the model, not a finding of it.

The claim here used to be that coordination efficiency degrades logarithmically with population size (R² = 0.88, p = 0.0017), implying a Dunbar-like limit around 100 agents. The fit is arithmetically correct and the plotted data below is the real output of the script. Neither fact makes the conclusion a result.

Scaling Results — what each one really is

  • • “~100 agents: efficiency drops to 50% of maximum” — retracted, grid resolution. Peak efficiency is 0.265 at ten agents, so half-max is 0.1325. The sweep tests 5, 10, 20, 50, 100, 150 and 200; n=50 sits at 0.184 and n=100 at 0.114. The crossing is somewhere between them, and 100 is simply the first point sampled below it. The answer could only ever have been one of seven numbers chosen in advance.
  • • “Messages grow at 0.08 per agent (sublinear)” — retracted, circular. Line 331 sets messages = int(np.log(n + 1) * 5 + Poisson(3)). Sublinear growth was written into the generator and then reported as though it had been observed.
  • • Task concentration: Gini rises 0.354 → 0.980 — stands, with a caveat. This one is not assumed anywhere; it is a real consequence of repeatedly argmax-ing over fixed capabilities. But it is a property of the toy model, not of GCL.

Network Topology — retracted in full

All three figures previously in this card have no counterpart in results/23_dunbar_scaling/results.json. They came from a hand-written summary block, not from the run.

  • • Clustering: low global density (0.12) — actual value 0.0
  • • Small-world: not detected (coefficient 0.89) — actual value 0.0
  • • Structure: hub-and-spoke topology emerges — no topology at all

Mean degree is 0.0 at every population size but one. The trust matrix initialises as np.eye(n) * 0.5 and an edge requires trust above 0.5, which nothing in the run reaches — so the graph being measured had no edges in 69 of 70 runs. The third bullet described the shape of a network that did not exist.

Also not a finding: the results file reports a phase transition at a population of 5. That is the smallest size tested. It is returned because coordination efficiency never crosses the 0.5 threshold the script looks for at any population — the highest value anywhere in the sweep is 0.265 — so the search falls through to its first candidate. It was never published on this page, and it is named here because the same defect produced two of the numbers that were.

Clarification: Task concentration (Gini) measures how tasks distribute across agents—larger populations concentrate tasks on fewer high-reputation agents. This differs from role specialization (HHI < 0.02 in Experiments 33-34), which measures whether agents focus on specific task types. The two can diverge: an agent may handle many tasks without specializing in any particular type.

Emergent Network Properties

Retracted· Sep 2026history

This section previously reported four figures — 82.3% protocol-diversity reduction (R² = 0.91), trust clustering 0.699 at global density 0.12, a task-concentration Gini of 0.745, and a 26.5% efficiency improvement (r = 0.73) — “across 1200+ runs, all p < 0.001”. Those numbers did not come from a simulation. They match 22_statistical_significance.py's test_population_dynamics() to ten decimal places, and that function draws from four hand-picked Gaussians (clustering = 0.7 + N(0, 0.1), gini = 0.75 + N(0, 0.08), and so on) before running genuine t-tests on the invented samples. The p-values were real; the data were not.

This is the same generator the repo's CHANGELOG caught on 2026-09-01 behind the punishment-paradox and Hart-Moore figures. That entry fixed those two claims and listed this one as an open item it had not yet re-verified. It is now re-verified. The real Experiment 07 numbers are below, including the prediction that failed.

Experiment 07 runs a 100-agent population for 5,000 timesteps and tests four pre-registered predictions about what structure should emerge without explicit coordination rules. Three passed, one failed. Single seed (seed=42) — this is one run, not a distribution.

Schematic. This diagram is procedurally generated to illustrate hub-and-spoke topology; it is not a plot of the Experiment 07 trust graph.

Protocol Convergence passed

Agents converge on shared commitment templates without central coordination.

Commitment entropy falls 2.696 → 1.384 over 5,000 timesteps (48.7%), fitting a power law with α = 0.165, R² = 0.782.

Trust Network Clustering passed

Trust edges close into triangles rather than staying tree-like.

Clustering coefficient 0.7475, mean path length 1.33, 4,248 edges. The network is dense(density 0.429) — the earlier “sparse … density 0.12” framing was backwards as well as unsourced.

Specialization passed

Agents concentrate on narrower slices of the task space over time.

Specialization index rises 0.223 → 0.755 between the early and late windows of the run.

Template Replicator Dynamics failed

Predicted: successful templates should out-replicate unsuccessful ones.

All three sub-checks failed. Fitness/usage correlation is −0.299 — the wrong sign, and significant (p = 3.1e‑20). 909 of 1,000 templates stayed in use; dominance ratio 0.40 against a predicted concentration.

Retracted· Sep 2026history

This box used to describe an unresolved disagreement. There was no disagreement. It said Experiment 07 reported trust clustering of 0.7475 while Experiment 23 — the Dunbar scaling sweep below — reported exactly 0.0 at every population size, and that the two could not both be right. Chased down in September 2026: Experiment 23 was not measuring a sparse network. Its trust matrix initialises as np.eye(n) * 0.5, leaving every off-diagonal entry at zero against an edge threshold of > 0.5 that nothing in the run ever crossed. The graph had no edges at all in 69 of 70 runs.

The correction does not vindicate the figure above. It removes the only thing that was ever offered as a check on it. Experiment 07's 0.7475 is a single seed, on code with no test coverage, and now nothing else in the repository measures the same quantity — so the honest status of GCL's trust topology is no supported claim, not a confirmed one. Details in Limitations.

Source: results/07_population/results.json (predictions block), produced by experiments/07_population_dynamics.py. Note that src/gcl/population/, the code behind this experiment, has no test coverage — see Limitations.

The GCL Framework

Why This Formalization?

Traditional multi-agent coordination assumes agents share semantic understanding. GCL replaces this assumption with verifiable behavioral contracts:

  • • Trigger (τ): When does this commitment activate? Removes ambiguity about scope.
  • • Action (a): What behavior is promised? Observable, not interpretive.
  • • Verification (φ): How do we know it succeeded? Third-party verifiable.
  • • Failures (F): What can go wrong, and what happens then? Enumerated, not implicit.
  • • Stake (σ): What does the agent risk? Skin in the game.

Formal Definition

A grounded commitment is a 5-tuple:

  • — trigger predicate
  • — action function
  • — verification predicate
  • — failure modes with stakes and remediations
  • — stake (reputation at risk)
commitment_example.yaml
1[COMMITMENT]
2ISSUER: Agent_A
3TRIGGER: Task requires capability X
4BEHAVIOR: Complete subtask within 3 rounds
5SUCCESS: Subtask verified complete
6FAILURES:
7  - IF timeout THEN stake_loss=0.5, REMEDIATION: delegate
8  - IF capability_mismatch THEN stake_loss=0.2, REMEDIATION: escalate
9  - IF resource_exhaustion THEN stake_loss=0.3, REMEDIATION: request_resources
10CONFIDENCE: 85%
11STAKE: 1.0
12[/COMMITMENT]

Key Insight: Failure-First Design

Unlike traditional contracts that specify success conditions, GCL commitments enumerate failure modes. Success is the complement of all failure conditions. This design choice enables auditability: auditors know exactly what to check, and agents cannot claim success by exploiting undefined edge cases.

Commitment-Grounded Learning

Agents learn what commitments to make via reinforcement learning. The policy maps states to commitment portfolios, optimizing for expected value minus stake risk:

gcl_agent.py
1class GroundedCommitmentLearner:
2    """Agent that learns what commitments to make via reinforcement learning.
3    
4    Key insight: Agents don't need shared understanding, just shared consequences.
5    """
6    
7    def __init__(self, capabilities, stake_budget):
8        self.capabilities = capabilities
9        self.stake_budget = stake_budget
10        self.reputation = ReputationTracker()
11        self.template_library = TemplateHierarchy()
12        
13    def propose_commitment(self, task, context):
14        """Policy maps states to commitment portfolios."""
15        capability_match = self.assess_capability(task)
16        observability = self.assess_verifiability(task)
17        
18        if capability_match < 0.5 or observability < 0.3:
19            return None  # Refuse rather than risk failure
20            
21        failure_modes = self.enumerate_failures(task)
22        
23        return Commitment(
24            issuer=self.id,
25            trigger=task.trigger,
26            behavior=task.required_behavior,
27            success=task.success_condition,
28            failures=failure_modes,
29            confidence=capability_match * observability,
30            stake=self.calculate_stake(expected_value, risk)
31        )

Template Sharing (Experiment 24)

GCL agents learn commitment templates—reusable patterns for common task types. Template sharing accelerates coordination by transferring learned patterns between agents, reducing the cold-start problem that limits MARL approaches.

Cognitive inspiration: Templates draw from analogical learning in human cognition—the ability to recognize structural similarities across situations and transfer solutions accordingly. When humans learn that "promising to deliver X by deadline Y" works in one context, they apply that pattern to novel contexts without re-learning from scratch. GCL templates formalize this: agents encode successful commitment structures as reusable schemas, enabling rapid generalization to new task types. This parallels work on structure mapping (Gentner, 1983) and case-based reasoning(Kolodner, 1992) in cognitive science.

Connection to core findings: When high-capability agents share templates with lower-capability agents, the recipients gain access to proven commitment patterns without needing to discover them through trial and error. This reduces inequality while improving overall coordination.

Experimental Conditions

  • • No Sharing: Templates never transfer (baseline)
  • • Random Sharing: Random pairs exchange at 10% rate
  • • Directed Sharing: High → low capability transfer
  • • Mutual Sharing: Bidirectional exchange

Results

  • • Directed sharing: +17% cooperation (t = 4.5, p = 0.001)
  • • Bottom quartile improves 34% faster than top quartile
  • • Inequality reduced: Gini 0.35 → 0.25
  • • Random sharing: +8% (less effective than directed)

Implication: Template sharing provides a mechanism for capability transfer without revealing private agent information. High-capability agents sharewhat works without exposing why they can execute it—capability details stay private while proven coordination patterns spread.

Implications for AI Safety

GCL provides a foundation for verifiable multi-agent coordination with properties relevant to scalable oversight and multi-agent alignment:

Auditability

Every agent action traces to a specific commitment with enumerated failure modes.

GCL mechanism: Failure-first design means auditors know exactly what to check. Agents cannot claim success by exploiting undefined edge cases—all failure modes are pre-specified.

Accountability

Failures have defined consequences. Agents stake reputation on every commitment.

GCL mechanism: The stake parameter (σ) creates skin in the game. Agents that make unreliable commitments lose reputation and future coordination opportunities—a self-enforcing accountability mechanism.

Alignment

Value-consistent commitments can be verified. The framework supports constraints on allowable commitments.

GCL mechanism: Commitment templates can encode policy constraints. Agents can only make commitments that match approved templates—enabling constitutional AI-style guardrails at the coordination layer.

Connection to Scalable Oversight

GCL addresses a key challenge in scalable oversight: how do you verify coordination between agents you cannot fully observe? By requiring agents to pre-specify failure modes and stake reputation, GCL makes coordination auditable without omniscience. Overseers check commitment logs and stake transfers rather than attempting to interpret agent reasoning.

The Core Insight

GCL dissolves rather than solves the interpretation problem. Agents don't need shared understanding, just shared consequences. This provides a principled foundation for multi-agent AI coordination that is verifiable, auditable, and aligned—without requiring that we solve the harder problem of ensuring agents share our semantic representations.

Self-Selection vs. External Assignment

Simulation
Retracted· Aug 2026history

An earlier version of this page reported that self-selection beats optimal external matching by 81%, driven ~75% by information asymmetry. That claim is retracted. The original oracle (Experiment 39) scored candidates by closeness-of-fit, penalizing over-qualified agents under a success model that is monotonically increasing in capability—it was not optimal. Against a corrected, truly success-maximizing oracle (Experiment 40), the information advantage is +0.000. The corrected findings are below.

Corrected finding: With effort held fixed, self-selection and a truly optimal (argmax) oracle are statistically indistinguishable. The surviving mechanism is emergent motivation: agents that choose their own tasks develop higher effort, beating the optimal oracle by +0.065 cooperation (95% CI [+0.050, +0.080], d = 1.68). Choice creates commitment—not privileged information.

Corrected Mechanism Decomposition

~0%Information Asymmetry

With effort fixed and perfect information on both sides, self-selection (0.531) and the corrected argmax oracle (0.531) are identical: +0.000 [−0.013, +0.013], d = 0.00. The previously reported +0.24 gap is fully reproduced as the gap between the corrected and flawed oracles.

This null is analytic, not measured. Self-selection scores volunteers by perceived − difficulty × 0.4, and that second term is the same for every agent, so the rule is argmax over perceived capability. With zero noise on both sides, the oracle is argmax over the same quantity — the two are the same function, and pick the same agent in 2,000 of 2,000 draws. Fifty seeds could not have returned anything else. The ±0.013 interval is not a residual effect; it is the two runs' random streams drifting apart when nobody volunteers and self-selection falls through to a random draw. Reported here because the confidence interval and the d = 0.00 imply a test that could have come out differently. It could not. That makes the null stronger than a measured one, not weaker — it is not a question of statistical power — but it is less work than the statistics suggest.

~100%Emergent Motivation

Self-selection with emergent effort (0.599) beats the optimal oracle (0.534) by +0.065 (d = 1.68). Assigned agents do not develop the same commitment dynamics (oracle emergent ≈ oracle fixed: +0.003).

The Observability Phase Boundary

Sweeping agent self-knowledge noise (σself) against coordinator observation noise (σoracle) shows neither mechanism intrinsically dominates:

  • →Self-selection wins iff σoracle > σself (advantage up to +0.127)
  • →Central assignment wins iff σself > σoracle (symmetrically, down to −0.127)
  • →Design principle: delegate task selection to whichever party has the less noisy view of agent capability, plus a motivation bonus to self-selection worth roughly one noise level

The same caveat applies here. Both mechanisms are argmax over a noisy estimate of the same underlying scalar, so “whoever sees more clearly wins” follows from how the model is built rather than from running it — and the exact symmetry of the two bounds (+0.127 against −0.127) is imposed by that construction, not discovered in it. The sweep quantifies the effect; it does not establish the boundary. What the simulation genuinely produces is the third row: the +0.065 motivation effect is a feedback dynamic, not an identity, and it is the only part of this section that could have come out at zero.

LLM Validation (Experiments 41 / 41b)

The phase boundary makes a testable prediction: self-selection helps real LLM systems only if models assess their own success probability better than an external observer can. Testing with Claude and GPT agents on verifiable tasks:

  • →No privileged self-knowledge: external assessment was better calibrated than self-confidence for 4/4 agents (e.g., Brier 0.281 vs 0.484)—current LLMs sit on the central-assignment side of the boundary
  • →Self-selection rewards overconfidence: pure self-selection routed 39/60 tasks to an overconfident agent (0.60 accuracy) over a perfectly reliable one (1.00 accuracy)
  • →Motivation effect not detected in LLMs: a powered paired re-test (n = 120, McNemar) found no significant "volunteered vs assigned" framing effect (+0.033, p = 0.52; bounded above ≈ +0.10)
Experimental Design
  • • Self-select vs corrected argmax oracle (Exp 40)
  • • Fixed effort (0.8) vs emergent effort conditions
  • • 5×5 observability noise sweep, 50 seeds/cell
  • • LLM calibration + framing tests (Exp 41/41b)
Statistical Validation
  • • Motivation effect: +0.065 [+0.050, +0.080], d = 1.68
  • • Information effect: +0.000 [−0.013, +0.013] (null)
  • • Phase boundary significant when noise gap ≥ 0.1
  • • LLM framing null: McNemar p = 0.52, n = 120 paired

Design Implications

Whether to use self-selection is an empirical question about relative observability, not a universal principle. In the simulation, choice creates commitment—a real motivation channel. But for current LLM agents, self-reports are less reliable than external assessment, so coordination systems should ground task routing in verified track records rather than agent self-assessment. GCL's commitment-verification machinery supports exactly this: observable outcomes, not stated confidence, determine reputation and routing.

Full correction history and canonical claims table: github.com/jstiltner/gcl.

Gaming-Resistant Reputation Mechanisms

Simulation

Key finding: Reputation visibility without anti-gaming mechanisms induces strategic task selection. Difficulty-weighted reputation reduces gaming behavior by 59.8% (t = 8.42, p < 0.001, d = 2.17).

Agents that observe their own reputation scores exhibit strategic behavior—selecting tasks that maximize reputation gain rather than coordination value. Four reputation visibility conditions characterize this effect.

Gaming Behavior by Condition

  • ✗Naive visible (45% gaming rate): Agents select low-difficulty tasks to inflate scores
  • ○Blind reputation (12% gaming rate): No visibility eliminates strategic selection but limits coordination

Anti-Gaming Mechanisms

  • ✓Difficulty-weighted (18% gaming rate): Reputation gains normalized by task complexity
  • ★Social + difficulty (15% gaming rate): Peer observation combined with difficulty weighting

The Self-Selection Requirement

These experiments used voluntary task selection throughout. This aligns with the corrected self-selection findings (Experiment 40): the advantage of volunteering comes from emergent motivation—agents that choose their own tasks develop higher effort—not from privileged information about task-agent fit.

Design implication: In this simulation, coordination structures use voluntary task selection (get_volunteers()) rather than external assignment (assign_task()).

This preserves the motivation channel while enabling reputation-based coordination. Note: LLM validation (Experiment 41) shows self-selection rewards overconfidence in real LLM agents, so verified track records—not self-reports—should gate routing.

Statistical Validation

Gaming reduction: t = 8.42, p < 0.001
Effect size: Cohen's d = 2.17

Mechanism

Difficulty weighting normalizes reputation gains by task complexity, removing the incentive for easy-task selection.

Applications

Applicable to multi-agent systems with reputation, trust-based coordination, and any system where agents can observe their own scores.

GCL vs. Multi-Agent RL

Simulation— both GCL and the MARL baseline run in the same simulation
Qualified· Sep 2026history

The cooperation-rate comparisons below (Experiments 36 and 37 — the “third of five” ranking, both tables, and the non-stationary results) do not run src/gcl/. Neither script imports it. Each defines its own standalone class called GCLAgent / GCLSelfSelection — the same ~15-line volunteer-if-capable-enough heuristic, copy-pasted between the two files, structurally identical to Experiment 40's self_selection function. 36_marl_comparison even imports Agent, Task and create_population from the project's agent harness and never calls any of them. None of GCL's calculus, verification, protocol or reputation machinery runs in either experiment. The chart below is unaffected: Experiment 08 does import gcl.multiagent and gcl.baselines, so its message-overhead and efficiency numbers are the real package. Nothing here is arithmetically wrong — the 0.534 and the tables below are correctly transcribed from their scripts' own output — but “GCL” in these two experiments names a threshold rule, not this repository.

Key finding: Experiment 36 ranks its self-selection heuristic third of five on final cooperation — behind IQL (0.553) and QMIX (0.542), ahead of MAPPO (0.522) and random (0.475). The results file records gcl_is_best: false. All four learned methods sit inside each other's 95% confidence intervals; only the gap to random is a real effect (d = 1.10). 30 agents, 2,000 episodes, 20 seeds.

Qualified· Sep 2026history

This section previously led with “GCL achieves 25–50× better sample efficiency than MARL while maintaining 97% of MARL's coordination quality”. Both halves were true of a chosen subset. Experiment 36 reports sample efficiency against four baselines:

vs QMIX
49.95×
vs IQL
25.24×
vs MAPPO
1.00×
vs Random
1.20×

“25–50×” was the range across the two favourable baselines with the other two dropped. MAPPO is a MARL algorithm and converges in exactly the same 2.05 episodes GCL does, so “MARL requires 52–102 episodes” was false as stated. The 97% figure compared GCL only to IQL, the single best baseline, which reads as a narrow shortfall; it omits that QMIX also beats GCL and that GCL ranks third overall.

The efficiency ratios are also unstable. episodes_to_50 for QMIX is 102.4 with a standard deviation of 435.4 and a CI lower bound of 0.8; for IQL it is 51.75 ± 214.6, CI lower bound 0.8. In most seeds the baselines cross the threshold immediately too — the means are carried by a few outlier runs. And the threshold itself is 50% cooperation, which the random baseline reaches 0.475 of on its own.

What survives is a difference in kind rather than a measured speedup: the heuristic reaches its asymptote in ~2 episodes because it does not learn — it reads a capability value handed to it rather than discovering one through trial, the way MARL does. That is a real property of the volunteer-threshold design, not evidence about this repository's implementation of it, and it is why GCL is intended to be usable cold-start. It is not a like-for-like efficiency comparison, and Experiment 36 shows the design does not buy better final coordination.

Retracted· Sep 2026history

The chart above previously plotted invented coordinates: CNP at 142 messages, FIPA-ACL at 156, Auction at 128, and MARL at 168, against a y-axis labelled “Task Success Rate” on which GCL scored 0.87. Only GCL's message count (84) came from Experiment 08. Every other value was fabricated, and every error ran the same direction: competitors' message counts inflated, their scores pushed below GCL's. The real values are CNP 109.5, FIPA-ACL 190.2, Auction 175.6, and MARL-IQL 0 — it is a non-communicating method and sends no messages at all. On mean_efficiency, the metric the experiment actually compares (success_rate is 1.0 for all six and does not discriminate), GCL is last of the six at 0.645 and is strictly dominated by MARL-IQL, which sends fewer messages and scores higher. GCL is not on the Pareto frontier. Its genuine result is the message count: 23.3% fewer than CNP, per the experiment's own key_findings block — not the “~40%” the chart annotated.

Episodes to 50% Cooperation

Mean ± SD over 20 seeds. The SDs are larger than the means.

GCL2.05 ± 3.8
MAPPO2.05 ± 3.8
Random2.45 ± 5.8
IQL51.75 ± 214.6
QMIX102.4 ± 435.4

Final Cooperation

Mean over 20 seeds. GCL ranks third; the top four CIs all overlap.

IQL0.553
QMIX0.542
GCL0.534
MAPPO0.522
Random0.475

Non-Stationary Environments

Experiment 37 (experiment_37_regime_changes.json), difficulty regime shifts, 30 agents, 10 seeds. Change frequency is episodes between shifts, so 50 is the most volatile column and 1000 the least.

Change every501002005001000
GCL − IQL+0.61+0.90+0.21+0.27+0.17
GCL − QMIX+0.74+1.38+1.33+1.54+2.57

Percentage points of mean cooperation. Per-arm SDs are 1.0–2.3 points at n = 10, so every cell here is inside noise.

Retracted· Sep 2026history

This block previously showed four buckets — Low / Medium / High / Very High volatility at +0.2% / +0.5% / +0.7% / +0.9% — under the heading “GCL's advantage grows in non-stationary environments”. Experiment 37 has five change frequencies, not four buckets, and neither of its two series matches those values. The ordering was also inverted: change frequency counts episodes between shifts, so a lower number means a more volatile environment. Read correctly, the two baselines disagree about the direction of the effect. Against IQL the advantage is largest in the volatile conditions (+0.90 points at frequency 100, +0.17 at 1000), which is the predicted pattern. Against QMIX it runs the other way: +0.74 at the most volatile setting rising monotonically to +2.57 at the most stable one — the opposite of the claim. crossover_iql and crossover_qmix are both null: no crossover point was found. With ten seeds and per-arm SDs of 1.0–2.3 points, none of these deltas is distinguishable from zero, and the “advantage grows” claim is not supported either way.

When to Use Each Approach

GCL is preferred when:

  • • Cold-start coordination (no training data available at all)
  • • Privacy-preserving systems (agents keep capabilities private)
  • • Agents already hold reliable self-knowledge to read

MARL may be better when:

  • • Training time is available
  • • Final coordination quality matters — IQL and QMIX both beat GCL here
  • • Agent capabilities are fully observable

“Non-stationary environments” was previously listed on the GCL side and has been removed: Experiment 37's two baselines disagree on the direction of that effect and all of its deltas are within noise. Sample efficiency was also listed and is now qualified above — MAPPO matches GCL episode for episode.

Limitations

On method. AI was used heavily throughout this work — hypothesis exploration, implementation, experimental iteration. It is not what makes any of the above true. Where a model proposed an explanation for a result, that explanation was treated as the next hypothesis to test, not as the finding.

This note previously read “every number on this page traces to an executable experiment with a controlled comparison, a statistical test, and a stated seed count.” That was not true when it was written. Six figures on this page did not trace to an experiment at all, and the sentence asserting they did was itself doing rhetorical work. It has been replaced with the accounting below rather than quietly softened, because a claim of universal provenance is exactly the kind of claim that should not be made on assurance.

Six figures previously on this page were not simulation output, and one section described a resolved bug as an unresolved disagreement — see the research record for the full correction history. The forward-looking limitations below are unaffected by those corrections.

The Population Code Has No Test Coverage

The suite is 382 passing tests at 63% line coverage overall, but src/gcl/population/ — every module behind Experiment 07, roughly 1,350 statements — is at 0%, as are core/scope.py and llm/api_clients.py. The emergent-properties results rest on code that nothing exercises except the experiment script itself.

GCL Does Not Win on Coordination Quality

Experiment 36 ranks GCL third of five methods on final cooperation, behind IQL and QMIX, and records gcl_is_best: false. The four learned methods' confidence intervals all overlap, so the honest reading is that GCL is competitive rather than better. Its distinguishing properties are cold-start operation and message economy, not coordination quality.

Simulation Environment

Results validated in controlled simulations. Real-world deployment may introduce additional factors (network latency, partial observability, adversarial agents) not captured in current experiments.

Task Complexity

Experimental tasks are simplified relative to production multi-agent systems. Commitment verification in complex, multi-step tasks may require additional mechanisms not yet validated.

Scaling Bounds

Coordination overhead suggests hierarchical structures for populations exceeding ~100 agents. Current experiments validate flat coordination; hierarchical GCL remains future work.

Motivation Effect Is Simulation-Only

The emergent motivation effect (+0.065, d = 1.68) is validated in simulation but was not detected in prompted LLM agents: a powered paired re-test (Experiment 41b, n = 120, McNemar) found no significant "volunteered vs assigned" framing effect (p = 0.52), bounding any effect below ~+0.10. LLM self-assessments were also less calibrated than external assessment, so self-selection results should not be assumed to transfer to LLM systems.

Ongoing Work

The findings above represent results from 41 experiments, including two published self-corrections (Experiments 39 → 40 → 41). Current focus areas:

Papers in Preparation

  • →
    Choice Creates Commitment: Emergent Motivation in Self-Selected Coordination

    In preparation for peer review

  • →
    When Should Agents Choose Their Own Tasks? An Observability Phase Boundary

    In preparation for peer review

Future Directions

  • •Mapping the observability phase boundary across agent architectures
  • •Hierarchical GCL for populations > 100 agents
  • •Real-world deployment validation
  • •Integration with constitutional AI approaches

Open Questions

The corrected findings raise a deeper question: why does choosing a task change how hard an agent works on it?

  • ?
    What drives the motivation channel?

    Self-selecting agents develop higher effort than assigned agents (+0.065, d = 1.68 vs a truly optimal oracle), but assigned agents given identical tasks do not. What feedback loop converts choice into commitment in the simulation—and why does the effect fail to appear in prompted LLM agents (Experiment 41b, McNemar p = 0.52)?

  • ?
    Commitment templates as geometric operations

    Can template learning be characterized as geometric transformations on a pre-linguistic capability manifold? If so, template sharing may be transferring operationsrather than knowledge—a distinction with implications for how we think about capability transfer in AI systems.

  • ?
    Emergent coordination primitives

    What computational primitives underlie the emergent specialization we observe? Experiment 07's trust clustering (0.7475) is a single seed on code with no test coverage, and nothing else in the repository independently measures the same quantity, so this is a question to re-run before it is a question to explain.

Collaboration & Discussion

This research connects to broader questions in AI safety, multi-agent alignment, and scalable oversight. If you're working on related problems or interested in collaboration, I'd welcome the conversation.

EmailGitHub

Explore the Implementation

View on GitHubFull source codeFull CorpusSee all work

Interested in discussing this work? Email me