Every rejected counter-offer tells your counterparty something. It doesn't have to.

David Uzan · 14 August 2026

Negotiation has a structural flaw that everyone lives with because it seems unavoidable: the process itself leaks.

You say no to $95 per unit, and your supplier now knows your ceiling is below $95. They counter with a 60-day delivery window, and you now suspect a production bottleneck. Run enough rounds and both sides have reverse-engineered a decent map of each other's constraints, including constraints around deals that never closed. Information you'd never volunteer is extracted from the pattern of your refusals.

So companies negotiate slowly and defensively. Procurement won't reveal budget ceilings, suppliers won't reveal cost floors or capacity limits, and a deal that's actually there to be made can take months of careful dancing to find, or get missed entirely.

What the Encrypted Negotiation Matrix does

The Encrypted Negotiation Matrix is a JuLenny function that answers one question: is there a deal here? And it answers it without either side revealing its position to anyone, including us, and without failed rounds leaking anything at all.

It works on a simple shared foundation. Both sides first agree on the dimensions of the deal: price, quantity, delivery window, whatever the terms are. For some of these they also settle the options together up front, a standard set of quantity brackets, say, or a fixed list of delivery schedules. Others, like the final price, are nobody's to dictate: each side decides on its own what it would accept. A full bundle of these, for example $80 for 5,000 units in 60 days, is one combination, and all the bundles on the table form a shared menu. The menu is public between the parties; it only frames what could be agreed, and says nothing about what either side actually wants.

Then, privately, each side marks which combinations it would accept. The buyer marks everything within budget and need. The supplier marks everything above its floor and within its capacity. And nobody ticks thousands of boxes by hand: you work in ranges (any price from $80 to $90, delivery within 60 days) and the client app expands them into the matching bundles for you. Each side encrypts its markings locally, on its own machine, and uploads only ciphertext.

The platform then looks for any bundle that both sides marked, computing entirely on encrypted data. A match means the whole combination lines up at once, the price and the quantity and the delivery together, not just one of them, and there can be more than one match or none at all. The decryption key is split between the parties, so the result comes out only when both approve.

The count variant returns "there is a match" or "there is no match" (and how many). The itemized variant, which is what procurement teams usually want, returns exactly which combination matched: deal at $80, 5,000 units, 60 days.

The interesting case is the failure

When the result is zero, both sides learn precisely one thing: no overlap this round. Not how close they were. Not which dimension killed it. The buyer doesn't learn that the supplier needed 60 days. The supplier doesn't learn that the buyer's ceiling was $90.

Both sides can then privately adjust, re-encrypt, and run another round. Maybe the buyer decides 60 days is workable after all. Each round is a fresh encrypted comparison, so positions can change between rounds without the other side ever seeing the change. Compare that to a normal negotiation, where revising your offer is itself a signal.

This flips the economics of trying. In a conventional negotiation, every probe costs information, so you probe carefully and rarely. Here a probe costs nothing, so you can be honest with yourself about your real acceptable range and let the math find the overlap.

Where this goes

Procurement at scale: a buyer runs the same encrypted RFQ against fifty suppliers simultaneously. Each supplier learns only whether it matched. No supplier learns what the others offered. The buyer's budget ceiling is exposed to no one.

Financial markets: buyer and seller encode acceptable price and volume ranges, and the platform finds the overlap without either side showing its limit order.

M&A and real estate: term sheet structures encoded as a grid, viability established before anyone shows a number.

And anywhere the parties genuinely cannot show each other their constraints: negotiations between government agencies, between competitors forced to cooperate, between parties whose lawyers would otherwise spend a quarter drafting the NDA for the conversation about the NDA.

The principle underneath

Like every JuLenny function, this runs on a simple rule: nobody sees anybody's cleartext, ever. Each party encrypts locally, the computation runs under a joint key no single party holds, and the result is released only when everyone signs off. The math is the contract.

If your organization has deals dying in the dance, we'd like to hear about them. Get in touch.