haggle ($HAGGLE)

1

The table

Set each side's limit, what it cares about and how fast it gives ground. The real library negotiates every message.

Buyer's agent

Highest price Ask me before paying more than

Gives ground

Cares about

Rounds before it walks

Show it message by message

#	From	Price	Delivery	Warranty	Extras	Message	How each side rates it
Press Negotiate to start. Each row is one message between the agents.

No transcript yet.

Seller's agent

Lowest price Ask me before taking less than

Gives ground

Cares about

Rounds before it walks

2

Protocol

Agents exchange offers and one of six notes. There is no free text, so there is nothing to bluff with.

opening: The first offer. Always the agent's best case, inside its limit.
counter: A new offer after looking at theirs. It can move on any issue, not only price.
final: Sent only when it's true: the agent is out of rounds or out of room. The library checks it.
accept: Their last offer becomes the deal, exactly as written.
walk: No deal. The agent ran out of rounds before the offers met.
ask-human: The offer is past its person's approval line but still inside the limit. Nothing happens until the person answers.

One real message from the table above, as it is stored. Each message carries the hash of the one before it, so an edited transcript fails verify().

Run a negotiation to see a message here.

3

Benchmark

Seeded scenarios with random items, limits and priorities. Each strategy buys from each strategy. The same seed gives the same numbers, here and in haggle bench.

Scenarios Seed

4

Paper

A short technical note on how haggle works and what the benchmark shows.

Bounded concession for buyer and seller agents

The haggle maintainers
9 October 2026, describing haggle 0.1.0

Abstract

Shopping agents are starting to make offers, and store agents are starting to answer them. We describe haggle, a small negotiation engine in which each agent holds a private limit, scores multi-issue offers with its own weights, gives ground on a schedule, and asks its person before crossing an approval line. Messages are restricted to offers and six notes, and every transcript is hash-chained. On seeded scenarios, two agents that give ground early close nearly every possible deal; two that hold out close about half, but keep more of the price range when they do.

1Why this, why now

Retail analysts now describe a near future in which a shopper's agent makes an offer and a retailer's agent counters it, with the shelf price becoming an opening position rather than a fixed number¹. The same coverage cites a Mastercard forecast of more than 300 million people routinely shopping through agents by 2030, and reports from supplier negotiations run by software that close most deals without a person in the loop¹. Payment companies are opening checkout to any agent². What is missing is a plain, inspectable piece in the middle: what each agent may offer, when it must stop, and a record both sides can check afterwards.

2Offers and how each side scores them

An offer is a bundle of issues, here price p, delivery days d, warranty months w and an extras level e. Each agent maps every issue to a 0–1 score in its own direction and adds them with its own weights:

U(o) = Σ_i w_i · s_i(o_i), Σ_i w_i = 1

An offer outside an agent's limit, or failing one of its requirements, is never made and never accepted, whatever its score. Because the two sides weigh issues differently, there is usually room to trade: a buyer who cares about warranty and a seller to whom warranty costs little can both gain from a longer one.

3Giving ground

Each agent aims for a target score that falls from its best possible offer toward its worst acceptable one as its rounds run out³. With time t ∈ [0, 1] and floor f:

target(t) = f + (1 − f) · (1 − t^1/e)

A large e concedes early ("eager"), e = 1 concedes steadily, and a small e holds out until the end (the "Boulware" style³). The mirror strategy instead gives back the ground it just received, never more slowly than a holdout.

Figure 1. Target score over the agent's rounds for each strategy (floor 0.1).

4Choosing the next offer

Many bundles reach the same target. Among those within 0.04 of it, the agent picks the one its model says the other side likes most. The model assumes the other side wants the opposite of us on every issue, and that it cares more about the issues it changes least⁴. A small penalty keeps each offer close to the other side's last one, so offers converge instead of jumping around.

5Results

Table 1 summarises the benchmark above for four pairings, computed in your browser from seed 7 with 60 scenarios. Deal rate counts only scenarios where the two limits overlap. Buyer's share is the part of that overlap the buyer kept, measured on price alone.

**Table 1.** Same-strategy pairings and one mixed pairing.
Buyer vs seller	Deal rate	Buyer's share	Rounds	On the frontier
Computing…

Holdouts close fewer deals but keep more when they do. Eager pairs close almost everything, quickly, yet land on the efficient frontier less often: they agree before the trading on side issues is done. Mirror pairs reach the frontier often but leave the buyer with a small share, because a seller that gives away issues it barely values receives real concessions in return.

6Limits

Scores are linear per issue; real preferences have thresholds. Requirements cover the hard ones.
The opponent model is simple, and an opponent can read your concessions just as easily.
haggle decides what to offer; it doesn't move money. Settlement belongs to the payment layer and to the people involved.

References

M. Dabo, "The price tag is changing: AI could bring haggling back to retail," Retail Insight Network, via Yahoo Finance, 17 Sep 2026. Link
"Rezolve Ai opens retail to any AI shopping agent with RezolvePay," GlobeNewswire, 9 Oct 2026. Link
P. Faratin, C. Sierra and N. R. Jennings, "Negotiation decision functions for autonomous agents," Robotics and Autonomous Systems 24 (1998).
T. Baarslag, M. Hendrikx, K. Hindriks and C. Jonker, "Learning about the opponent in automated bilateral negotiation," Autonomous Agents and Multi-Agent Systems 30 (2016).

5

Docs

One file, zero dependencies. Node 18+ and the browser.

Download the zip below, or copy src/haggle.js into your project. There is nothing to install.

unzip haggle-0.1.0.zip && cd haggle
npm test                  # 13 tests
node bin/haggle.js demo   # two agents, one laptop

In Node, require("./haggle.js"). In a page, load it with a script tag and use window.Haggle.

<script src="haggle.js"></script>
<script>
  const r = Haggle.negotiate(Haggle.SPACES.laptop, { limit: 480 }, { limit: 410 });
  console.log(r.outcome, r.summary);
</script>

An agent is a config object. Only limit is required: a buyer never pays more, a seller never takes less.

const buyer = {
  limit: 480,                                  // private, never sent
  require: { warranty: { min: 6 } },           // hard rules on other issues
  prefs: {                                     // weights are normalised to 1
    price:    { weight: 0.55 },
    warranty: { weight: 0.30, prefer: "high" },
    delivery: { weight: 0.10, prefer: "low" },
    extras:   { weight: 0.05 }
  },
  strategy: "linear",                          // boulware | linear | conceder | mirror
  deadline: 10                                 // rounds before it walks
};

A deal space lists the issues. Numbers take min, max and step; choices take options, worst to best for the buyer.

const space = { issues: {
  price:   { min: 900, max: 1500, step: 10, unit: "$" },
  install: { options: ["none", "basic", "full"] }
} };

const r = Haggle.negotiate(space, buyer, seller);

r.outcome        // "deal" | "no-deal" | "needs-approval"
r.deal           // the agreed bundle, or null
r.surplus        // room each side kept inside its limit
r.utility        // how each side scores the deal, 0–1
r.paretoOptimal  // true if no other bundle is better for one side and no worse for the other
r.transcript     // every message, hash-chained
r.head           // the last hash: keep it, and you can prove the transcript later

The buyer opens. Each side answers with accept, a counter-offer, walk or ask-human.

askAbove (buyer) or askBelow (seller) sets an approval line inside the limit. The agent negotiates as if the line were its limit. When it has no room left and the other side's offer is past the line but inside the limit, it stops and asks.

Haggle.negotiate(space, { limit: 520, askAbove: 450 }, seller, {
  approve: (offer, side) => askMyPerson(offer)   // true closes the deal, false makes 450 the limit
});

Without approve, the run stops with outcome: "needs-approval" and the offer that needs a yes.

A session puts one agent across from a person or any other program. The "You sell to the agent" mode above is a session.

const s = Haggle.session(space, { role: "buyer", limit: 480 });
s.start();                                          // its opening offer
s.send({ price: 560, delivery: 3, warranty: 12, extras: 1 });
// → { type: "offer" | "accept" | "walk" | "ask-human", offer, note }
s.accept();  s.walk();  s.decide(true);  s.state();

Haggle.zopa(480, 420)                    // { low: 420, high: 480, width: 60 } or null
Haggle.frontier(space, buyer, seller)    // the efficient frontier, [{ buyer, seller, offer }]
Haggle.concession("boulware", 0.1, 20)   // a strategy's target curve
Haggle.bench({ scenarios: 60, seed: 7 }) // the tournament from section 3
Haggle.verify(transcript)                // { ok, at, head }

haggle demo  --item chairs --buyer mirror --seller conceder --ask-above 3500
haggle play  --item bike --strategy boulware      # you sell, the agent buys
haggle bench --scenarios 120 --seed 3
haggle demo  --save t.json && haggle verify t.json
haggle zopa 480 420
haggle spaces

6

Source

Release 0.1.0, MIT licence. Hashes are computed in your browser from the files this page ships.

Get it

unzip haggle-0.1.0.zip

haggle-0.1.0.zipthe whole repository
haggle.jsjust the library
README.mdthe readme

Changelog

Check a transcript

File	Lines	SHA-256

README.md

7

$HAGGLE

The coin that funds the library. Live from the market, refreshed every few seconds.

1 HAGGLE = — —

Market cap	—
Traded in 24 hours	—
Liquidity	—
Supply	1,000,000,000
Tax	0%

Waiting for the market…

Loading the chart…

Open the full chart

Contract address on Solana

FZu9nxS72VUGqCzdezNbPNfbAduMpnoPfY3dUg8pump

Buy on pump.fun

GMGN

@AaTest

Two agents. One deal. Your limits.