# Agent Negotiation Strategies

> Use when implementing agent negotiation and bargaining.

- Skill: `loopyluci/agent-negotiation-strategies` (Agent Skill)
- Install (CLI): `npx skillmds@latest add loopyluci/agent-negotiation-strategies`
- Raw SKILL.md: https://api.skillmd.com/api/skills/loopyluci/agent-negotiation-strategies/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- License: MIT
- Author: LoopyLuci (https://skillmd.com/u/loopyluci)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/loopyluci/agent-negotiation-strategies

---


# Agent Negotiation Strategies

Implementing agent negotiation strategies — from bargaining and auctions through game-theoretic negotiation, multi-issue negotiation, and argumentation.

## When to Use

- Agents need to reach agreements on resource allocation
- Implementing auction systems for task distribution
- Multi-issue negotiation between autonomous agents
- Building competitive negotiation agents
- Applying game theory to agent interactions

## Negotiation Protocols

```python
NEGOTIATION_PROTOCOLS = {
    'bargaining': 'Alternating offers between two agents until agreement',
    'english_auction': 'Ascending price, last bidder wins',
    'dutch_auction': 'Descending price, first bidder wins',
    'vickrey': 'Sealed bid, second-highest price wins',
    'contract_net': 'Manager broadcasts task, contractors bid, manager awards',
    'monotonic_concession': 'Agents concede gradually toward agreement',
}

class Negotiator:
    """Agent negotiation with concession strategies."""
    def __init__(self, reservation_price: float, 
                 concession_rate: float = 0.1):
        self.reservation = reservation_price  # walk-away point
        self.concession = concession_rate
        self.round = 0
    
    def propose(self, opponent_offer: float = None) -> float:
        self.round += 1
        if opponent_offer:
            # Concede toward opponent
            concession_amount = abs(opponent_offer - self.initial_offer) * self.concession
            return max(self.reservation, self.initial_offer - concession_amount * self.round)
        return self.initial_offer
    
    def accept(self, offer: float) -> bool:
        return offer >= self.reservation
```

## Common Pitfalls

1. **Irrational opponents** — real agents aren't perfectly rational; model bounded rationality
2. **Information asymmetry** — one agent knows more than another; design for incomplete info
3. **Lying and deception** — agents may misrepresent their preferences; build trust mechanisms
4. **Time pressure** — negotiations must terminate; implement deadlines
5. **Multi-issue complexity** — combining issues (price + timing + quality) needs sophisticated strategies

## Verification Checklist

- [ ] Negotiation protocol chosen and documented
- [ ] Reservation/walk-away point defined
- [ ] Concession strategy designed (linear, exponential, time-based)
- [ ] Deal acceptance criteria defined
- [ ] Negotiation timeout mechanism
- [ ] Reputation tracking for repeated negotiations
- [ ] Fallback plan for negotiation failure