Agent negotiation & economies

At 3:00 p.m., your procurement agent needs one GPU slot for a model run. It can justify paying up to $100. A provider agent has a slot available, but its electricity, staff, and opportunity cost come to $60. The provider will not accept less.

Neither agent is broken. Neither has forgotten the task. They simply want different prices.

If both agents belong to your application, an orchestrator can assign the slot and tell one agent to cooperate. If they belong to different companies, that authority disappears. The agents need rules for:

• making offers
• comparing alternatives
• committing to a deal
• dealing with someone who lies

That is negotiation: coordination between self-interested agents, where each agent optimizes its own objective rather than obeying one shared owner. The rules are studied in game theory. Designing rules that reward good behaviour is mechanism design.

Mechanism design specifies:

• allocations
• payments
• participation rules
• failure states

It does not enforce physical delivery or legal obligations. A signature authenticates who sent a message and what was agreed, but cannot make a provider deliver a GPU slot. Enforcement needs one or more of:

• verification
• escrow or slashing
• trusted execution
• contractual remedies
• legal recourse

The numbers underneath a deal

Start with three values.

A reservation value is the worst deal a party will accept. For our provider, it is $60: anything below that loses money or gives the slot to a worse use. For the buyer, it is $100: anything above that costs more than the model run is worth.

A buyer’s utility is value received minus payment. A seller’s utility is payment minus cost. At a price of $80:

• buyer utility: $100 - $80 = $20
• seller utility: $80 - $60 = $20
• total surplus: $100 - $60 = $40

Surplus is the value created by trading rather than walking away. The price divides the $40; it does not create it.

The zone of possible agreement, or ZOPA, is the interval where both reservation values are satisfied: $60 to $100 here. A price of $50 leaves the provider worse off; $110 leaves the buyer worse off.

A mechanism needs explicit boundaries:

• maximum spend
• minimum payment
• deadline
• quality threshold
• cancellation terms
• the result of non-response or failure

A language model’s polite “fair” number is not a mechanism.

Bargaining: offers, concessions, and deadlines

The simplest protocol is alternating-offers bargaining. One side makes an offer; the other accepts, rejects, or counters. The parties take turns rather than changing numbers simultaneously.

Here is the GPU example. The provider starts at $100, the buyer at $60, and both concede $5 after each rejection:

# Explicit alternating-offers toy protocol.
# The provider proposes; the buyer accepts or counters;
# then the provider makes the next proposal.
provider_ask, buyer_offer, step = 100, 60, 5
rejected_rounds = 0

while True:
    round_number = rejected_rounds + 1
    print(f"round {round_number}: provider proposes {provider_ask}")

    if provider_ask <= buyer_offer:
        deal = provider_ask
        print(f"buyer accepts at {deal}")
        break

    rejected_rounds += 1
    buyer_offer += step
    print(f"buyer rejects and counters {buyer_offer}")
    provider_ask -= step

print(f"agreement at {deal} after {rejected_rounds} rejected rounds")

It prints:

round 1: provider proposes 100
buyer rejects and counters 65
round 2: provider proposes 95
buyer rejects and counters 70
round 3: provider proposes 90
buyer rejects and counters 75
round 4: provider proposes 85
buyer rejects and counters 80
round 5: provider proposes 80
buyer accepts at 80
agreement at 80 after 4 rejected rounds

The $80 outcome comes from the imposed $5 concession rule, not from a theorem about fairness.

A production message should include:

• the item or task
• price and currency
• delivery conditions
• expiry time
• unique negotiation ID
• authority limit
• consequences of acceptance

Without expiry, a quote for a 3:00 p.m. slot might be accepted after capacity has been sold. Without a unique ID, a retry might create two purchases.

The midpoint is not a law of bargaining. An agent with a strong outside option—an alternative provider, customer, or delayed task—can reject deals that are economically possible for the original pair. Deadlines and patience matter because waiting has a cost.

A per-round discount factor is the fraction of next round’s utility worth today. Let the provider’s be δ_P and the buyer’s δ_B, between zero and one. A responder accepts only when the current offer beats both its outside option and its discounted continuation utility, what it expects after rejecting.

Take the same $40 surplus. Assume infinite alternating offers, divisible dollars, complete information, no outside options, provider moves first, δ_P = 0.8, and δ_B = 0.95. If the provider keeps surplus x, the buyer gets 40 - x. If the buyer rejects, it proposes next round and can obtain 40 - 0.8x; discounted by its patience:

40 - x = 0.95 × (40 - 0.8x)

Solving gives the provider about $8.33 and the buyer about $31.67. The price is about $68.33: the provider gets $68.33 - $60 = $8.33, while the buyer gets $100 - $68.33 = $31.67. The more patient buyer captures most of the surplus despite moving second.

This is the Rubinstein result under those assumptions, not a universal bargaining formula. Outside options enter as disagreement payoffs.

If the provider can sell the slot elsewhere for $95, its disagreement utility is $95 - $60 = $35. It rejects an $80 offer even though $80 lies inside the original ZOPA. Only prices from $95 to $100 can then improve both sides, assuming the buyer has no alternative value.

If the buyer’s maximum is $55 and the provider’s minimum is $60, no ZOPA exists. More rounds or better prompting cannot create the missing $5.

To change the outcome:

• change the task
• add a subsidy
• find another provider
• walk away

Many agents: allocate a task or sell a resource

Bargaining fits one buyer and one seller. With many agents, distinguish a scarce task from a scarce resource.

If one manager needs a task completed by one of several providers, use a contract-net protocol:

• announce the task
• collect bids from capable agents
• evaluate them
• award a contract

Define:

• input size
• output schema
• quality target
• deadline
• retry responsibility
• data handling
• payment

Otherwise “bid for document extraction” produces incomparable interpretations of done.

The lowest bid is not necessarily cheapest. If failure causes a costly rerun, compare:

• expected total cost
• quality evidence
• deadline

Do not compare price alone. A lowest-bid award that pays the winner its bid is a reverse first-price auction. Providers generally shade bids relative to estimated cost; the payment rule alone does not guarantee truthful cost reports.

If the scarce thing is one GPU slot or another resource, an auction is clearer:

• English auction: bids rise openly until one bidder remains. Understandable, but potentially slow.
• First-price sealed bid: the highest bid wins and pays its own bid. Simple, but bidders usually shade.
• Vickrey auction: the highest bid wins and pays the second-highest bid. Under specific assumptions, truthful bidding is optimal.

Why Vickrey truthfulness works

Suppose three buyers value one GPU slot at:

• Agent A: $100
• Agent B: $80
• Agent C: $55

In a second-price auction, A wins and pays B’s bid, $80, for utility $100 - $80 = $20.

If A’s true value is $100 and the highest competing bid is $80:

• Bid $70: A loses and gets $0.
• Bid $100: A wins, pays $80, and gets $20.
• Bid $130: A still wins, pays $80, and gets $20.

A higher bid does not lower the price; a lower bid risks losing a profitable trade.

If A’s true value is $75 and the competing bid is $80:

• Truthful bid $75 loses and gets $0.
• Dishonest bid $90 wins, pays $80, and gets $75 - $80 = -$5.

Truthful bidding is a weakly dominant strategy under these assumptions:

• a single item
• private independent values
• risk-neutral bidders
• no collusion
• no budget constraints

The bid determines whether the agent wins; the second-highest bid determines what it pays.

The result does not make agents universally honest. Shared information, bundles, hard budgets, model errors, or fake identities (shill bids) violate the assumptions. A reverse Vickrey auction awards the lowest-cost provider but pays the second-lowest bid. If bids are $60, $70, and $95, the winner receives $70. That extra $10 buys the incentive property and may be worth the overpayment.

Mechanism design is the layer above messages

A message protocol says how an agent sends a request or response. A mechanism specifies:

• legal moves
• allocation
• payment
• participation
• verification
• failure states

Make four choices explicit:

1. Allocation: who receives the task or resource?
2. Payment: who pays whom, and how much?
3. Participation: can an agent refuse without penalty?
4. Verification and remedies: what evidence triggers settlement, and what handles failure?

Common design goals are:

• Efficiency: allocate to the highest-value buyer or best provider.
• Individual rationality: honest participation beats refusing.
• Incentive compatibility: following the reporting strategy is optimal.
• Budget balance: the system does not require unlimited subsidy.

These goals can conflict. Under standard bilateral-trade assumptions, no mechanism can guarantee every attractive property—including efficient trade, truthful reporting, voluntary participation, and a balanced budget—in every case. Choose the guarantee that matters most for the market.

A production negotiation pattern

Use a deterministic orchestrator around model-driven agents:

1. Keep utility and authority outside the model. Store maximum spend, minimum terms, quality thresholds, currencies, and approval rules in code or a policy service.

2. Check capability first. Require evidence that a provider can perform the task before spending negotiation rounds.

3. Publish one mechanism. State the auction or bargaining rule, tie-break, deadline, quote expiry, and cancellation policy.

4. Separate negotiation from commitment. Track states such as:

   • proposed
   • accepted
   • paid
   • executing
   • delivered
   • disputed
   • cancelled

   Make payment transitions idempotent.

5. Verify before settlement. Check identity, signatures, bid deadline, amount, and output quality. When delivery matters, use appropriate enforcement such as:

   • escrow
   • deposits
   • slashing
   • trusted execution
   • contractual remedies
   • legal recourse

6. Record outcomes. Preserve:

   • bids
   • mechanism version
   • timestamps
   • evidence
   • disputes

   Reputation should reflect observed outcomes, not self-description.

As of August 2026, protocols such as A2A can provide transport and capability conversations. They do not decide whether a bid is truthful or payment enforceable. Economic semantics belong in the application.

Which mechanism should you use?

A fixed posted price is often best for standard capacity with ample supply. Negotiation is worth its latency and token cost when any of these matter:

• scarcity
• private information
• flexible terms

Pairwise negotiation also scales badly: 50 agents create 1,225 pairs before multiple rounds, while one manager can broadcast a task and collect 50 bids.

What breaks first

Collusion is coordinated manipulation, such as bidders agreeing not to compete. Vickrey protects against unilateral bid shading, not coordinated bidders. “Truthful” also does not mean correct: an agent may faithfully report a stale or mistaken valuation.

Keep these observable enough to audit:

• valuation
• authority
• settlement

Next

Read:

• A2A for cross-organization agent transport
• multi-agent debate for cooperative reasoning
• multi-agent orchestration for system topologies

Quick check