Part of my research on robust evaluation of adaptive systems.

Grounded Commitment Learning

Coordination Without Shared Semantics

Updated Sep 2026

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.

Alignment connection: This addresses a core challenge in 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.

Simulation— self-designed multi-agent environment, not externally validated
25-50× sample efficiency vs MARL+6.5pp emergent motivation effect (d = 1.68)97% of MARL coordination quality

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

View on GitHub

The Punishment Paradox

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

r = -0.818 (n=5 seeds)

Verified Sep 7, 2026 against commit 363ccc5 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.

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

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

Verified Sep 7, 2026 against commit 363ccc5 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)

Coordination efficiency degrades logarithmically with population size (R² = 0.88, p = 0.0017), suggesting a Dunbar-like coordination limit around 100 agents.

Scaling Results

  • • ~100 agents: Efficiency drops to 50% of maximum
  • • Messages: Grow at 0.08 per agent (sublinear)
  • • Task concentration: Gini increases 0.35 → 0.98 as population grows

Network Topology

  • • Clustering: Low global density (0.12)
  • • Small-world: Not detected (coefficient 0.89)
  • • Structure: Hub-and-spoke topology emerges

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

GCL populations self-organize into structured networks without explicit coordination rules. Four properties emerge consistently across 1200+ runs (all p < 0.001):

Protocol Convergence

Agents converge on shared commitment templates without central coordination.

82.3% reduction in protocol diversity by episode 50. Convergence accelerates with population size (R² = 0.91).

Sparse Trust Networks

Agents form hub-and-spoke topologies rather than dense meshes.

Clustering coefficient = 0.699 (high local clustering). Global density remains low (0.12), enabling efficient coordination.

Task Concentration

High-capability agents attract disproportionate task volume.

Gini coefficient = 0.745 for task distribution. Top 20% of agents handle 68% of tasks—a natural consequence of reputation-weighted selection.

Efficiency Improvement

Coordination efficiency improves over time without parameter tuning.

26.5% improvement in task completion rate from episode 1 to episode 100. Improvement rate correlates with template sharing (r = 0.73).

Note on measurement: Task concentration (Gini = 0.745) measures how tasks distribute across agents. This differs from role specialization (HHI), which measures whether agents focus on specific task types. High task concentration can occur without role specialization—agents may handle many tasks across diverse types.

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

Correction (August 2026): 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.

~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

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

Key finding: GCL achieves 25-50× better sample efficiency than MARL while maintaining 97% of MARL's coordination quality. In cold-start or non-stationary environments, this efficiency advantage dominates.

GCL converges in 2 episodes; MARL requires 52-102 episodes to reach equivalent coordination. This difference stems from GCL's use of agent self-knowledge—information that MARL must learn through trial and error.

Sample Efficiency

GCL Episodes to Converge2
MARL Episodes to Converge52-102
Efficiency Advantage25-50×

Coordination Quality

GCL Coordination0.534
MARL Coordination0.552
Relative Performance97%

Non-Stationary Environments

GCL's advantage grows in non-stationary environments. When environment parameters change, MARL must relearn; GCL adapts immediately via agent self-knowledge:

Low Volatility
+0.2%
Medium
+0.5%
High
+0.7%
Very High
+0.9%

Performance delta vs. MARL across environment change frequencies.

When to Use Each Approach

GCL is preferred when:

  • • Cold-start coordination (no training data)
  • • Non-stationary environments
  • • Privacy-preserving systems (agents keep capabilities private)
  • • Sample efficiency is critical

MARL may be better when:

  • • Training time is available
  • • Environment is stable
  • • Maximum performance is required (3% gap matters)
  • • Agent capabilities are fully observable

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. Every number on this page traces to an executable experiment with a controlled comparison, a statistical test, and a stated seed count. Where a model proposed an explanation for a result, that explanation was treated as the next hypothesis to test, not as the finding. The 2026-09-01 correction noted under the punishment paradox is what that looks like when it catches something.

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 validated results from 41 experiments with 1200+ independent runs, 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? The clustering coefficient (0.699) suggests agents discover coordination structures that weren't designed in. Understanding these primitives could inform how we design multi-agent AI systems that scale gracefully.

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