Negotiation and Bargaining

Two agents need to agree on a price. Left to pure language prompts, 2024-2026 LLMs close deals at a surprisingly low rate (~27% on tightly parameterized bargains in arXiv:2402.15813). Scale does not fix it. GPT-4 is not structurally better at bargaining than GPT-3.5, only better at the language of bargaining.

The root issue is that an LLM does two jobs at once: it decides the offer and it narrates the offer. OG-Narrator splits them. A deterministic offer generator computes the numeric moves, and the LLM only narrates. Deal rate jumps to ~89%.

This matches a classical multi-agent finding: decouple the mechanism from the communication layer. Contract Net Protocol (Smith, 1980; FIPA, 1996) is the reference task-market mechanism. Put an LLM in the narration slot and you get a modern LLM-powered task market.

Contract Net, in one paragraph

In Smith's 1980 Contract Net Protocol, a manager broadcasts a call for proposals (cfp) and bidders respond with propose messages containing their offers. The manager picks a winner, sends accept-proposal to it and reject-proposal to the losers, and the winner does the work. A bidder that does not want the job can send refuse instead. FIPA codified this as the fipa-contract-net interaction protocol.

Why OG-Narrator wins

"Measuring Bargaining Abilities of Language Models" (arXiv:2402.15813) observed that:

• LLMs often break the bargaining rules by offering nonsensical prices or ignoring the other side's ZOPA.
• They anchor poorly. They accept bad first offers and counter at symbolic amounts rather than strategic ones.
• Larger models write more plausible language but make about the same strategic errors.

The OG-Narrator decomposition:

           ┌──────────────────┐        ┌──────────────────┐
  state  → │ offer generator  │ price → │  LLM narrator    │ → message
           │  (deterministic) │        │  (writes the     │
           │                  │        │   human-style    │
           └──────────────────┘        │   accompaniment) │
                                       └──────────────────┘

The offer generator is a classical negotiation strategy: a Rubinstein bargaining model, a Zeuthen strategy, or plain tit-for-tat over price. The LLM narrates. Each message carries the deterministic price plus the natural-language framing.

Deal rate jumps because prices stay in the bargaining zone, anchors are strategic instead of emotional, and the LLM spends its effort on writing, which it is good at.

NegotiationArena findings

arXiv:2402.05863 is the canonical benchmark. Headline findings:

• LLMs can improve payoffs ~20% by adopting a persona ("I am desperate to sell this by Friday"). Persona manipulation is a real tactic.
• Fair, cooperative agents get exploited by adversarial ones, and the defense is explicit counter-posturing.
• Symmetric pairings converge to inequitable outcomes on about 40% of the benchmark scenarios.

That does not make LLMs bad negotiators. They negotiate a lot like humans, including the exploitable habits.

Chain-of-thought concealment

The Large-Scale Autonomous Negotiation Competition (arXiv:2503.06416) ran ~180k negotiations across many LLM strategies, and the winners hid their reasoning from counterparts. Say an agent writes "I will only go to $75; my reservation price is $70" into a publicly visible scratchpad. The opponent reads it. Winners computed strategy privately, so the output channel held the offer and the minimum narration needed.

Classical game theory says the same thing (Aumann 1976 on rationality and information): revealing your private valuation costs payoff. LLMs do not pick this up on their own and will type their reservations into reasoning traces that the counterpart can see.

The engineering takeaway is to keep the private-scratchpad context and the public-message context separate. Treat that as a requirement.

Bhattacharya et al. 2025: model rankings

On Harvard Negotiation Project metrics (principled negotiation, BATNA respect, interest reciprocity):

• Llama-3 was the most effective at striking bargains (deal rate and payoff).
• Claude-3 was the most aggressive negotiator, with high anchors and late concessions.
• GPT-4 was the fairest, with the smallest payoff variance across pairings.

This is a 2025 snapshot, and which model wins in April 2026 matters less than the pattern: base models have persistent negotiation styles. Heterogeneous ensembles (Lesson 15) can use that as a source of diversity.

Task allocation via Contract Net + LLM

The modern reuse of Contract Net for LLM multi-agent systems:

1. A manager agent decomposes a task into units.
2. It broadcasts a cfp with the task description to worker agents.
3. Each worker returns an offer (price, eta, confidence), where price could be tokens, compute units, or dollars.
4. The manager picks winners (one or several, depending on the task) and awards.
5. Rejected workers are free to bid on other tasks.

Coordination is broadcast-and-respond instead of synchronous chat, so this scales well past 100 workers. Microsoft Agent Framework's orchestration patterns and some LangGraph implementations use it in production.

LLM-Stakeholders Interactive Negotiation

NeurIPS 2024 (https://proceedings.neurips.cc/paper_files/paper/2024/file/984dd3db213db2d1454a163b65b84d08-Paper-Datasets_and_Benchmarks_Track.pdf) introduces multi-party scorable games with secret scores and minimum-acceptance thresholds. Each stakeholder has private utilities, and the LLM has to infer them from messages. This generalizes two-party bargaining to N-party coalition formation, which is the situation in a production task market with heterogeneous workers.

The narration-vs-mechanism rule

The engineering rule that holds across the 2024-2026 negotiation benchmarks:

Let the LLM narrate. Do not let the LLM compute the offer.

If the offer is a number (price, ETA, quantity), generate it deterministically from the negotiation state and have the LLM write the framing. If the offer is a proposal structure (task decomposition, role assignment), let the LLM draft it, then validate it against a schema and check constraints before sending.

code/main.py implements:

• ContractNetManager, ContractNetTask, Bid: the manager and bidders, with broadcast cfp, proposal collection, and award.
• og_narrator_bargain(state, rng): the OG-Narrator buyer, a deterministic Zeuthen-style concession toward the seller's standing offer.
• seller_response(state, rng): a deterministic seller counter-offer policy, shared as the structural ground truth for both buyer styles.
• naive_llm_bargain(state, rng): a stand-in for an all-LLM bargainer that picks prices with high variance, often outside the ZOPA.
• Measurement: deal rate over 1000 trials, with fresh reservation prices sampled per trial.

Run:

python3 code/main.py

With the fixed seed, the naive-LLM buyer closes about 60% of deals and the OG-Narrator buyer about 89%, a gap near 29 points. That gap is the structural advantage of separating offer generation from narration. The script then runs a Contract Net task-market example with three bidders and one task.

outputs/skill-bargainer-designer.md designs a bargaining protocol: who generates offers (deterministic or LLM), who narrates, how private scratchpads stay separate from public messages, and how deal rate is monitored.

Production bargaining checklist:

• Separate scratchpad. Private state stays out of the counterpart's context. Treat this as a hard requirement.
• Deterministic offer generation. Compute prices, quantities, and ETAs instead of prompting for them.
• Validate incoming offers against a schema, and reject out-of-ZOPA offers at the protocol boundary.
• Bound rounds. Cap at 3-5 rounds and escalate to a mediator on deadlock.
• Measure deal rate and payoff variance continuously. A falling deal rate is a symptom, often of prompt drift or an attack from the counterpart side.
• Log rejected proposals with the deterministic rationale. In Contract Net, losing bidders need to understand why they lost.

1. Run code/main.py. Confirm OG-Narrator beats naive-LLM on deal rate. By how much?
2. Implement persona-based payoff improvement (arXiv:2402.05863). The buyer adopts a "desperate to buy this week" persona in the narration only, with the offer generator unchanged. Does the deal rate or payoff change?
3. Implement chain-of-thought concealment: keep a private scratchpad string that is not passed to the counterpart. What happens if you leak it by accident (simulate by swapping the channels)?
4. Extend Contract Net to an N-bidder auction with a reserve price. When all bids exceed the reserve, how does the manager decide between lowest price and highest quality? Which award rule do you pick and why?
5. Read Bhattacharya et al. 2025 on Harvard Negotiation Project metrics. Implement two bargainers with different styles (aggressive vs fair). Measure payoff variance under symmetric and asymmetric pairings.

• NegotiationArena: the benchmark, with the persona manipulation and exploitation findings
• Measuring Bargaining Abilities of Language Models: OG-Narrator and the buyer-harder-than-seller result
• Large-Scale Autonomous Negotiation Competition: ~180k negotiations, where chain-of-thought concealment wins
• LLM-Stakeholders Interactive Negotiation (NeurIPS 2024): multi-party scorable games with secret utilities
• Smith 1980, The Contract Net Protocol: the classical mechanism, IEEE Transactions on Computers