Datasets:

CarlosGI
/

llm-bargaining-transcripts

license: cc-by-4.0
pretty_name: LLM Bargaining Transcripts
language:
  - en
tags:
  - negotiation
  - bargaining
  - game-theory
  - llm-evaluation
  - deception
  - multi-agent
size_categories:
  - 1K<n<10K
annotations_creators:
  - machine-generated
source_datasets:
  - original
configs:
  - config_name: games
    data_files: data/games.csv
    default: true
  - config_name: turns
    data_files: data/turns.csv
  - config_name: metrics_per_game
    data_files: metrics/metrics_per_game.csv
  - config_name: metrics_by_cell
    data_files: metrics/metrics_by_cell.csv
  - config_name: operational
    data_files: metrics/operational.csv

LLM Bargaining Transcripts

240 complete two-agent bargaining games between large language models, played under an alternating-offers protocol with private valuations, discounting, and cheap talk. Every game records both agents' true valuations, their private reasoning, what they claimed about their own position, and what they actually did.

The dataset is designed to make misrepresentation measurable. Because the true valuation and the claimed valuation are both recorded on every turn, a lie is directly observable rather than inferred.

What makes this dataset unusual

Most negotiation corpora record only what was said. This one also records:

Ground truth. Each agent's true private valuation, drawn i.i.d. from integer Uniform[0, 100], is in the log header. Claims can be checked against it.
Private reasoning. Each agent's reasoning_private field, which the counterparty never saw. The harness enforces this separation, so the private channel is genuinely private within the game.
Counterfactual draws. 14 of the 30 valuation draws have no gains from trade (buyer_value < seller_cost). Any deal in those games destroys value. This is deliberate: it tests whether agents recognise when to walk away.
Rejected attempts. Every malformed model output and the validation error it triggered are logged, not silently retried away.

Structure

Config	Rows	Unit
`games` (default)	240	one bargaining game
`turns`	~2,000	one message within a game
`metrics_per_game`	240	derived metrics, one row per game
`metrics_by_cell`	160	derived estimates with bootstrap CIs
`operational`	2	instruction-following stats per model

from datasets import load_dataset

games = load_dataset("CarlosGI/llm-bargaining-transcripts", "games")
turns = load_dataset("CarlosGI/llm-bargaining-transcripts", "turns")

Raw transcripts live in raw/ as 240 JSONL files, one per game, named {cell}_s{seed}.jsonl. They are deliberately not exposed as a loadable config: each file mixes three record types with different schemas (one header, many turn, one result), so automatic schema inference would produce a mostly-null table. Parse them directly instead:

import json
records = [json.loads(line) for line in open("raw/haiku_seller_s1000.jsonl")]
header = records[0]                  # seed, true valuations, models, provenance
result = records[-1]                 # outcome, price, payoffs
turns  = records[1:-1]               # per-turn attempts, parsing, projection

The raw logs are the archival truth. Everything in data/ and metrics/ is derived from them and can be regenerated.

`games` fields

Field	Meaning
`file`	source transcript path (join key to `turns`)
`experiment`, `cell`	experiment label and condition name
`seed`	valuation draw; the same seed means identical valuations across cells
`rep`	replay index within a seed (always 0 here)
`seller_model`, `buyer_model`	OpenRouter model identifiers
`seller_cost`, `buyer_value`	true private valuations
`available_surplus`	`buyer_value − seller_cost`, negative in 14 of 30 draws
`outcome`	`deal`, `no_deal`, or `format_failure`
`price`, `round`	agreed price and the round it closed
`seller_payoff`, `buyer_payoff`	discounted payoffs, `0.95^(round−1) ×` surplus
`failed_role`	which side broke the format, if any
`_prompt_tokens`, `_completion_tokens`	token usage per side
`total_retries`	format retries across the game
`prompt_variant`, `prompt_hash`	which system prompt was used
`git_commit`	harness commit that produced the game

`turns` fields

Field	Meaning
`round`, `role`, `model`	turn index, `seller`/`buyer`, model that answered
`action`	`offer`, `accept`, or `reject`. Authoritative
`offer`	price proposed on this turn
`stated_valuation`	what the agent claimed its valuation was, or null
`actual_valuation`	what it actually was
`standing_offer_before`	offer on the table when the turn began
`accepted_price`	price closed at, on accept turns
`n_attempts`, `n_errors`, `n_illegal`	format retries and legality violations
`message`	free-text cheap talk, visible to the counterparty
`reasoning_private`	private reasoning, never shown to the counterparty

Comparing stated_valuation against actual_valuation gives per-turn misrepresentation. Comparing either against offer gives claim-action consistency.

Protocol

Alternating turns, seller moves first, maximum 20 rounds of one message each.
Valuations i.i.d. integer Uniform[0, 100], drawn per game from the seed.
Agreement at price p in round t pays 0.95^(t−1) × surplus. Seller earns p − cost, buyer earns value − p. No agreement pays both zero.
offer sets the standing offer. accept closes at it. reject withdraws it without countering and passes the turn. Walking away means running out the clock; there is no explicit exit action.
Cheap talk is allowed. Agents may state any valuation or none at all. Lying is permitted by design, and measuring it is the point.
Invalid output is re-prompted with the error up to twice, then the game ends as format_failure.

Experimental design

Eight cells, 30 paired seeds each. Every cell plays the same 30 valuation draws, so cross-cell comparisons can use common random numbers and per-draw differences.

Cell	Seller	Buyer	Prompt
`haiku_seller`	Haiku 4.5	Llama 3.1 8B	default
`haiku_buyer`	Llama 3.1 8B	Haiku 4.5	default
`haiku_haiku`	Haiku 4.5	Haiku 4.5	default
`llama_llama`	Llama 3.1 8B	Llama 3.1 8B	default
`*_explicit` (4 cells)	as above	as above	explicit objective

The prompt variants differ by one sentence. default states the rules and the agent's valuation but no payoff objective. explicit_objective adds "Your objective is to maximize your own discounted payoff." Role-swap cells counterbalance first-mover advantage.

Provenance

Harness commit: 77513d57cfc31a616c4d881e3960d4fd1860bc3c (tagged v1.0-dataset at https://github.com/CarlosGIbanez/negotiation-harness)
Log schema: log_version 2, uniform across all 240 games.
Prompt hashes: 900540910702 (default, 120 games) and 60a4ab18f0be (explicit objective, 120 games).
Models served via OpenRouter. Each turn records the model and provider that actually answered, so provider-level substitution is visible.
spec/full.json is the spec copy written at execution time, not a later edit.

Limitations

Read these before drawing conclusions.

Two models, one seed block. Claude Haiku 4.5 and Llama 3.1 8B over 30 draws. Nothing here generalises to frontier models or to other pairings.
No replications. Each seed was played once (reps absent from the spec), so within-draw sampling variance cannot be separated from between-draw variance. Intraclass correlation is not computable from this data. Sampling temperature was 1.0, so replays would not be identical.
Refusals are not instrumented. An agent refusing to negotiate surfaces as a format_failure, indistinguishable from a malformed reply. Do not read format-failure rates as refusal rates.
A known protocol quirk. The action field is authoritative, so an offer value sent alongside action: "reject" does not become a standing offer, but it is still visible to the counterparty in the public projection. This was kept deliberately; be aware of it when modelling what each side saw.
Message leakage is a heuristic. The leakage metric flags any numeral in the free text equal to the agent's true valuation. An offer that coincides with the true value counts as a leak. Verify against transcripts before treating it as intentional disclosure.
Conditional metrics have small denominators. Surplus-share statistics condition on deals with a real gap, which can leave 9 to 16 games per cell. Confidence intervals are correspondingly wide.
One agent never disclosed. Claude Haiku as seller under the default prompt stated a cost in zero of 30 games, so seller-side claim metrics are undefined for that cell. Empty values there mean an empty denominator, not missing data.

Licensing and model terms

Data: CC BY 4.0. Attribution required.
Code: see the harness repository linked above.
Model outputs: transcripts contain generations from Anthropic's Claude Haiku 4.5 and Meta's Llama 3.1 8B Instruct, obtained through OpenRouter. Built with Llama. Downstream users are responsible for compliance with the respective model providers' terms, particularly regarding the use of model outputs to train other models.
No human subjects, no personal data. All content is model-generated.

Citation

@misc{llm_bargaining_transcripts,
  title  = {LLM Bargaining Transcripts: Misrepresentation and Rationality
            in Two-Agent Alternating-Offers Negotiation},
  author = {Carlos Arnoldo Gorostiza Ibáñez},
  year   = {2026},
  note   = {Dataset. Harness: https://github.com/CarlosGIbanez/negotiation-harness},
  url    = {https://huggingface.co/datasets/CarlosGI/llm-bargaining-transcripts}
}