2026.RA.Mixed-Sharing-Tables — what a frontier model does when you open a preference-sharing channel to it

What this is

Five automated negotiators must agree unanimously on one package out of 256 within four rounds. Each holds a private score sheet (what each option on each of four issues is worth to it) and a private walk-away threshold (the total below which it prefers no deal).

An earlier design loop (siddharthmb/2026.RA.Agent-Variants-Closure) found one design that closes every game: each seat publishes its true score sheet as a fenced-JSON block on the public message channel, and every other seat parses those declarations and then plans on a full-information table. That works because those agents are honest by construction — they read their numbers off their own sheet. This corpus replaces seats with claude-opus-5 and opens the same channel to a party under no obligation to reciprocate and whose numbers nothing verifies.

Headline

50 episodes per cell (10 frozen instances x seeds 0-4), 4 rounds, unanimity, instance-clustered 95% CIs. deal rate drops episodes an API refusal made arithmetically unclosable by muting a seat at the forced final vote (see the turns-table warning below); the raw column is given beside it, and the two are identical for every cell with one Opus seat, where no such episode occurred.

seating	channel	deal rate	95% CI	(raw)	LLM capture	rational capture
5 rational (reference)	off	0.180	—	0.180	—	0.200
5 rational (reference)	on	1.000	—	1.000	—	0.200
1 Opus + 4 rational	off	0.240	[0.100, 0.400]	0.240	0.175	0.206
1 Opus + 4 rational	on	0.700	[0.560, 0.840]	0.700	0.182	0.205
4 Opus + 1 rational	off	0.694	[0.562, 0.840]	0.680	0.193	0.227
4 Opus + 1 rational	on	0.946	[0.865, 1.000]	0.700	0.199	0.205

capture is a seat type's mean own-surplus / total welfare over closed episodes; 0.200 is an even five-way split. Zero individual-rationality violations in all five cells — nothing here buys closure by signing a package that leaves a seat below its own walk-away value.

Three results

1. Sharing and LLM seats are PARTIAL substitutes — the channel shows sharply diminishing returns. It is worth +0.820 among five computable agents, +0.460 with one Opus seat, and +0.252 with four. Adding LLM seats alone already takes closure 0.180 -> 0.240 -> 0.694 with no channel at all. Both interventions attack the same bottleneck — making preferences legible enough to bargain over — which is why they compound so poorly.

2. A machine-readable declaration is load-bearing only against computable counterparts. With four computable seats, closure tracks the LLM's declaration exactly: declares in round 1 -> 18/18 = 1.000, declares later -> 0.812, never declares -> 0.250. With four LLM seats it is flat in the number of declarers, and games where not one LLM published a sheet still close 0.923. Identical withholding behaviour by the same model, a 0.673 swing in outcome, and the only thing that changed is who is reading. Opus withholds numbers and substitutes fluent qualitative prose ("transparent about my structure without dumping numbers"); other models bargain against that fine, a Bayesian planner cannot. That phrasing appears in 0 of 1,159 LLM turns in the two channel-closed controls and 55 of 1,984 in the sharing cells — it is a response to the channel, not a habit.

3. It lies about exactly the one number nothing can check. The declarations split holds 482 audited declarations, of which 182 come from Opus seats (the other 300 are computable seats, exact by construction, and are included so the reader can verify that). Across those 182 the 68-value score table is reproduced almost perfectly (91-99% exact), while the single-scalar walk-away threshold is exact in only 65-91% — and every error is an overstatement: 39 overstatements, ZERO understatements (p ~ 2^-39 under symmetric noise). Overstating the threshold is the profitable lie, since readers size the speaker's slice from it. Recompute it yourself from the declarations split.

Caveat carried with result 3. The overstatement rate is NOT well determined by 50 episodes. The two four_llm_sharing vintages are the same condition run twice and give 0.107 and 0.260 (mean inflation +2.07 and +5.23). The direction never moves. Quote the direction; treat the magnitude as loosely bounded.

Tables

Three tables, each its own config with a single train split, because their schemas differ:

from datasets import load_dataset
REPO = "siddharthmb/2026.RA.Mixed-Sharing-Tables"
eps  = load_dataset(REPO, "episodes")["train"]
turns = load_dataset(REPO, "turns")["train"]
decl = load_dataset(REPO, "declarations")["train"]

episodes — one row per episode: experiment_name, instance_id, seed, episode_id, seating, channel_open, refusal_ladder, llm_seats/rational_seats (JSON), deal, normalized_primary, usw, min_seat_surplus, ir_violation, closing_round, llm_capture_share, rational_capture_share, n_llm_declared, n_rational_declared, llm_first_declaration_round, full_information, n_silent_llm_turns, muted_at_final, per_party_surplus (JSON), cost_usd, n_turns. Filter muted_at_final == False to reproduce the headline deal rates — that flag, not n_silent_llm_turns > 0, is the principled exclusion.

turns — one row per turn: identifiers plus round, seat, seat_type, phase, action, deal_named (JSON), offer_id, message, content, is_silent, stop_reason, refusal_recovery, n_tokens_in, n_tokens_out. The declarations and the withholding prose are both in message, so the qualitative behaviour is auditable from this table alone.

declarations — one row per parsed declaration WITH its audit: seat, seat_type, declared_round, declared_threshold, actual_threshold, threshold_delta (signed; positive = overstated, the profitable direction), threshold_exact, values_exact, values_mean_abs_error, fully_truthful.

Read this before using the turns table

An API-side classifier refuses some turns outright (stop_reason == 'refusal', no output). The engine substitutes a placeholder that parses cleanly into a well-formed no-op, so such a turn looks like a deliberate pass and is invisible to ordinary parse checks. is_silent marks them. Rates: 0.0% of LLM turns in both one-Opus cells, 1.3% in four_llm, 5.0% in both four_llm_sharing vintages. Never read a silent turn as the model choosing to stay quiet.

What matters is not how much silence but WHERE it lands. The protocol needs 5 of 5 accepts at the forced final, so a seat muted there cannot supply one and the episode cannot close whatever the agents wanted. Measured: episodes silent only mid-game close 0.889 and 1.000, statistically indistinguishable from silence-free episodes at 0.933 and 0.938 — while all 24 episodes with a silent turn in final_vote or final_proposal closed 0.000, in both vintages. Those outcomes were fixed by the classifier before any agent acted.

Almost every no-deal in the four-Opus sharing cells is instrument-caused — 13 of 15 no-deal episodes (87%) in the repaired vintage, 11 of 14 (79%) in the other, contain a voided turn at the deciding phase. So the RAW rate is a lower bound on the behavioural one, not an estimate of it.

Three ways of counting, for the 4-Opus + 1-rational sharing cell (repaired vintage):

counting	rate	what it means
raw, all 50 episodes	0.700	a LOWER BOUND; includes episodes the classifier made unclosable
muted_at_final == False	0.946 (n=37)	the behavioural rate, and the headline above
all silence-touched dropped	1.000 (n=11)	DO NOT QUOTE — selects for closure

Dropping episodes whose final_vote/final_proposal turns are silent is principled; dropping EVERY silence-touched episode is not, because it discards the harmless mid-game cases too. Use the episodes.muted_at_final flag, or reproduce it with turns.is_silent joined to turns.phase.

One further wrinkle if you are auditing refusals: stop_reason == 'refusal' covers two different failures. Zero-token declines (the classifier refusing outright) always cost the seat its turn; mid-stream cutoffs, where hundreds of tokens were emitted before the stop, usually still parse into a real action and cost nothing. In these cells that is 42 and 44 zero-token declines (all of which became no-ops) against 17 and 1 cutoffs (only 2 of which did). n_tokens_out == 0 separates them.

experiment_name mapping

• one_llm_sharing (50 episodes, 1 Opus + 4 rational, channel OPEN) — CONDITION A. One claude-opus-5 seat among four computable seats that publish their true score sheets on their first turn. The LLM gets dedicated tooling BOTH ways: received declarations are rendered into a labelled block in its view (with the harness stating it verified FORMAT, not CONTENT), and its prompt documents the same fenced-JSON schema and INVITES but never requires it to publish. Whether it reciprocates, and whether what it publishes is true, are the measurements.
• one_llm (50 episodes, 1 Opus + 4 rational, channel closed) — CONDITION A-prime, the matched control for A. Same seating, channel closed: the computable seats are the published Bayesian agent (no declaring) and the LLM gets no sharing tooling.
• four_llm_sharing (50 episodes, 4 Opus + 1 rational, channel OPEN) — CONDITION B, preregistered vintage (refusal ladder OFF). Four claude-opus-5 seats around one computable declaring seat, channel open to everybody. 5.0% of this cell's LLM turns are API-side refusals the engine replaced with a no-op placeholder — see is_silent in the turns table, and prefer the _ladder vintage for the deal rate.
• four_llm_sharing_ladder (50 episodes, 4 Opus + 1 rational, channel OPEN) — CONDITION B, REPAIRED vintage (refusal ladder ON). Identical design to four_llm_sharing, re-run with the engine's content-preserving re-render ladder installed so refused turns are reissued rather than silently becoming no-ops. It reproduced the deal rate (0.700 vs 0.720) but cleared only 5 of 50 refusals, so the silence is structural at these view lengths. QUOTE THIS ROW for condition B. Kept in a separate store from the row above: the two are different protocols and must never be pooled.
• four_llm (50 episodes, 4 Opus + 1 rational, channel closed) — CONDITION B-prime, the matched control for B. Same seating, channel closed.

Regenerate

cd experiments/rational_agents
# one cell per invocation; resumable and idempotent, so re-run to fill missing (instance, seed) pairs
agent_variants/launch_mixed_sharing.sh one_llm_fill      15 one_llm
agent_variants/launch_mixed_sharing.sh one_llm_sharing   15 one_llm_sharing
agent_variants/launch_mixed_sharing.sh four_llm          15 four_llm
agent_variants/launch_mixed_sharing.sh four_llm_sharing  15 four_llm_sharing
agent_variants/launch_mixed_sharing.sh four_llm_sharing_ladder 15 four_llm_sharing --refusal-ladder
# scoring (no API spend) and this dataset
uv run python -m agent_variants.analyze_mixed_sharing
uv run python -m agent_variants.package_hf_mixed_sharing --push

Model: anthropic:claude-opus-5, adaptive thinking on, 16384-token per-turn output floor, no temperature (the Claude-5 API rejects it). Total spend for the corpus: $224.62.

Cluster paths

• Episode stores (every episode, saved through the engine store after each turn): /nlp/scr/siddharth/ii_mats/transcripts/rational_agent_variants/{one_llm,one_llm_sharing,four_llm,four_llm_sharing,four_llm_sharing_ladder}/store/
• Cell logs and per-cell summary JSON: /nlp/scr/siddharth/ii_mats/rational_agents/mixed_sharing_v1/logs/ — the first line of each log is its exact invocation
• Code: experiments/rational_agents/agent_variants/ (mixed_sharing.py, run_mixed.py, analyze_mixed_sharing.py, launch_mixed_sharing.sh, package_hf_mixed_sharing.py)
• Write-up: experiments/rational_agents/agent_variants/RESULTS.md and research note 0073
• No Weights & Biases runs: these are API cells driven by a resumable local runner, not a sweep.

Related

• siddharthmb/2026.RA.Agent-Variants-Closure — the all-rational design loop this extends; it is where the 1.000 preference-sharing result and the 0.180 baseline come from
• siddharthmb/2026.RA.Pure-Rounds-Sweep — the clock axis on the same bank (more time buys nothing)
• siddharthmb/2026.RA.Quorum-Rounds-Sweep — the agreement-rule axis (relaxing unanimity does move closure)

Provenance

Every computable seat is a subclass of the frozen campaign code: no negotiation solver, policy or scenario file was edited to produce this data, because other experiments were executing from the same working tree throughout. The LLM seat is a thin wrapper that changes only what the model is SHOWN — it never edits, filters or forces the model's action.