Negotiation Assistant Technical Details

When a seller has something that a buyer is interested in, both parties must agree to a price. When supply exceeds demand and prices are low, stores typically take a simple approach to this: you either accept their price or there's no deal. This works fine when there are many sellers competing to sell the same item. But for rarer items, or even just more expensive ones (cars, houses, etc.), there's often an element of negotiation involved.

In a negotiation like this, you never want to truthfully provide your "best price" (BATNA), since the other person will then try to get you to agree to an even better one. Hyperbole, falsehoods, and nitpicking tend to be the way to go. In addition to the downsides of normalizing dishonesty, this can be very stressful for people who aren't used to adversarial negotiation. Just look at the Wikipedia page on negotiation strategies to get an idea of how complicated this can get when one is trying to play optimally.

In theory, the optimal solution is to choose the price that maximizes total utility across both players. But in the real world, we have no good way to determine another human's utility function, and people can simply lie about how much they value the item.

The ideal way to avoid this is to use a mechanism that's strategyproof; designed such that the optimal strategy is for each player to be truthful about their BATNA. For example in a Vickrey auction, there's no incentive to lie or bid less than your maximum; doing so would only put you at a disadvantage.

Unfortunately, in the bargaining game with one seller and one buyer, there is no reasonableThe system of "pick a player at random and let them determine the price" is strategyproof, but obviously terrible as it has unbounded expected disutility for both players. strategyproof solutionI've been told that this is proven by Gibbard's theorem. That applies only to deterministic processes, but in this case introducing randomness would clearly make it unlikely that the result you get happens to be efficient. (If both agents' utility curves are strictly monotonic (which seems like a reasonable assumption), there's only a single price at which the transaction is efficient.), and the Myerson–Satterthwaite theorem proves it impossible to have an efficient result in the absence of that information. In other words, there is no bargaining system that guarantees maximized utility across both participants, and we have to make do with imperfect systems.

People usually handle this via some form of sequential bargaining. This incentivizes dishonesty, emotional manipulation, brinksmanship, artificial self-restrictions, and other undesirable behavior. It rewards people who have high charisma, have more knowledge of psychology and game theory, and/or are good at manipulating other people. It punishes those who are conflict-averse, empathetic, and/or have poor social skills.For example, when Facebook trained an AI to negotiate, it learned to feign interest in an item it didn't actually want, just to "concede" it later on in the negotiation in return for something else it did want.

Can we do better than this? Maybe! There are many things working in our advantage. Computers let us do things like keep information private while still performing calculations on it, perform more complicated calculations than humans can perform themselves, and introducing randomness, which all seem like they could be helpful. Additionally, all the proofs above apply to traditionally rational agents, which humans are not. This could potentially be exploited for a net better outcome.I considered the strategy of "lie to the user and claim that there exists a strategyproof solution, which this webpage implements". This would probably work on most people, but it would hinder adoption among those more economically-minded, and also seems unethical. (For example, traditionally rational agents defect in the prisoner's dilemma, but irrational humans often cooperate, getting them both a better outcome.)

This negotiation assistant is an attempt at such a better system.See Chatterjee & Samuelson, 1983 for an analysis of the core game. It tries to satisfy several criteria:

The way we do this is by letting both people input their information independently, and having the server return a final price based on the input information. This allows both parties to safely enter their true best guess at a fair market value without the first-mover advantage that this usually entails, along with their true BATNA, without the last mover-advantage that that usually entailsWhoever gives their BATNA first, the other party can then claim that their BATNA is the same number in order to force a transaction at that number..

If the seller's lowest price is higher than the buyer's highest price, no deal can be made. If the seller's lowest price equals the buyer's highest price, then a deal is made at that number. If the seller's fair price equals the buyer's fair price, and that price is within the valid interval, a deal is made at that number. If none of those are true, the server creates a probability distribution that's bounded by the "high" and "low" prices, which will be sampled from in order to get the final price. The specific distribution tries to satisfy the following constraints:

(Some people don't want to enter a "fair price" when they feel they don't have a good idea of what would be fair, so it's optional. In this case the server internally sets it equal to the midpoint between that user's best price and the other user's fair price.Setting it equal to any number that depends on the other user's best price could leak information about it if they also entered the same fair price, so it needs to depend only on information will eventually be available to that user. This convention is a rather arbitrary choice that reflects some measure of deference to the other party (since they don't know and don't want to guess), while also taking that user's personal valuation as evidence towards what would be fair.)

There are obviously an infinite number of probability distributions that satisfy these constraints, so the exact choice was rather arbitrary. Let a and b be the fair prices (doesn't matter which is which), l be the seller's lowest price, and h be the buyer's highest price. The distribution is then given by this construction, and you can see the exact code here.

You can explore the exact probability density function for a set of given input prices here:

(For simplicity, inputs are limited to integers in the range 1 - 1,000,000,000.)

This system is not immune to gaming; as mentioned above, that's impossible. The buyer can gain an advantage by guessing what the seller's best price will be and making their own best price only slightly higher than that; the same Keynesian beauty contest as occurs in regular sequential bargaining. But the risk of the deal falling through means that it's rational to include a significant margin of error, and input a "best price" that's somewhere in between their true BATNA and their guess at the other party's best price.This is why it's very important that both parties agree to not try to renegotiate later if the tool says "no deal", and will refuse if the other party tries it. The disincentive for lying via the tool relies on the threat of no deal being made.In low value negotiations, people may choose to fall back on their true value, since trying to figure out the utility-maximizing lie to tell is intellectually demanding and not worth the trouble.

The main difference between this system and sequential bargaining on a purely game-theoretic level is that under this system, agents lose the ability to update their own price upon hearing their opponent's. But since the opponent's stated price has no connection to reality, it's questionable whether hearing it really provides much information.Of course verifiable information is still useful to hear, which is why users of this tool are encouraged to share it in advance. Also note that the bargaining game is zero-sum in money, meaning that any information gained in an earlier round of bargaining can only help one player at the cost of their opponent. Since the game is symmetric, neither player has a reason to prefer sequential bargaining, since the information exchange is just as likely to hurt them as to help them. This logic breaks down when we consider that most agents don't have flat utility curves, and some transaction prices will lead to higher total utility than others. The question then becomes whether there's any way for one player to gain reliable information about the other player's utility function. I can't see how sequential bargaining would allow this to happen.

If the user enters multiple items, the same process is used on each item individually. For example, if Alice is willing to sell item #1 for a minimum of $10 and item #2 for a minimum of $20, and Bob is willing to buy item #1 for a maximum of $20 and item #2 for a maximum of $10, a deal will only be struck for item #1, even though adding them together would have both parties comfortable with a combined sale at $30. Combining the prices is tempting, since both parties would prefer more items to sell than fewer. But combining the prices accomplishes this by using up the extra flexibility from items where the buyer is willing to pay more than the seller's minimum, reducing the gains from trade for both parties. This causes both Alice and Bob to have an incentive to negotiate each item independently, defeating the point of offering such functionality.

This tool is primarily useful for highly illiquid markets, where both actors have significant market power. When that's not the case, both players will have a BATNA very close to the going market rate and will have common knowledge of such, obviating the need for bargaining.

There are some potential meta-exploits:

If you have concerns about this system or think you can improve on it, I'd love to hear about it. Various methods to contact me can be found on the homepage, or simply leave a comment below. I offer a competitive reward of $2.57 for any issues found in this system.

Back to assistant

With thanks to Ryan Sears for helping me with some of the economics concepts, and to Jonathan King for coming up with the exact probability density function.

RSS feed