Agent negotiation & economies

Orchestration assumes a comfortable thing: one owner, one goal, agents that cooperate because you told them to. Drop that assumption and the picture changes. When a buyer agent meets a seller agent from another company, or two agents compete for a scarce resource, they are self-interested — each optimizes its own objective. Coordination is no longer delegation; it is negotiation, and the right toolkit is game theory and mechanism design.

Bargaining: alternating offers toward agreement

The simplest negotiation is bilateral bargaining over one number — a price. Each side has a private reservation value (the seller’s lowest acceptable, the buyer’s highest willing); a deal is possible only if they overlap, and that overlap is the zone of possible agreement (ZOPA). Within it, a common protocol is alternating offers: each side concedes a little each round until the ask meets the offer.

# Alternating-offers bargaining: seller wants high, buyer wants low; both concede
# each round until the ask and the offer meet. The gap they split is the surplus.
seller_ask, buyer_offer, step = 100, 60, 5
rounds = 0
while seller_ask > buyer_offer:
    rounds += 1
    print(f"round {rounds}: seller asks {seller_ask}, buyer offers {buyer_offer}")
    seller_ask -= step
    buyer_offer += step

deal = (seller_ask + buyer_offer) / 2
print(f"agreement at {deal:.0f} after {rounds} rounds")

round 1: seller asks 100, buyer offers 60
round 2: seller asks 95, buyer offers 65
round 3: seller asks 90, buyer offers 70
round 4: seller asks 85, buyer offers 75
agreement at 80 after 4 rounds

The split isn’t arbitrary: whoever concedes faster ends up worse off, so bargaining power — patience, outside options, deadlines — decides who captures more of the surplus.

Many agents: contract-net and auctions

Bargaining is one-on-one. For one task and many candidates, the classic protocol is the contract-net: a manager announces a task, agents bid (their cost or capability), and the manager awards it to the best bid — decentralized task allocation by tender. When the scarce thing is a resource rather than a task, you run an auction, and the auction’s rules shape behaviour:

• English (ascending) — bids rise openly until one bidder remains; simple but slow and reveals information.
• First-price sealed bid — highest secret bid wins and pays its bid; bidders shade (underbid their true value) to avoid overpaying, so bids are strategic.
• Vickrey (second-price sealed bid) — highest bid wins but pays the second-highest price. The twist: this makes bidding your true value the optimal strategy — you can’t do better by lying, because your bid only decides whether you win, not what you pay.

That last property is the whole game. A mechanism where honesty is the best strategy is incentive-compatible, and designing such rules is mechanism design — “game theory in reverse,” choosing the rules so that self-interested play produces the outcome you want.

In one breath

• Orchestration assumes one owner and a shared goal; negotiation is for self-interested agents with conflicting objectives (buyer vs seller, competitors for a resource).
• Bilateral bargaining works over a zone of possible agreement (where reservation values overlap) via alternating offers; whoever concedes faster captures less of the surplus (the demo meets at 80).
• For one task and many agents, the contract-net allocates by announce → bid → award; for scarce resources, auctions allocate — and the rules drive strategy.
• Vickrey (second-price) auctions are incentive-compatible: bidding your true value is optimal, because your bid sets only whether you win, not what you pay.
• Designing rules so honest self-interest yields good outcomes is mechanism design; the hard parts of agent economies are collusion, manipulation, and runaway dynamics.

Quick check

Next

Negotiation needs a transport for agents to reach each other across owners — that’s A2A, the cross-organization agent protocol. For cooperative many-agent reasoning instead of competitive bargaining, see multi-agent debate, and for the topologies underneath it all, multi-agent orchestration.