What is Parley, and what problem does it solve?
Parley is an open-source Python library for one decision among AI agents whose owners have conflicting, private interests. Each owner states red lines and preferences in private; the engine drops every option that crosses anyone's red line, picks among the rest by the max-min rule, and writes a transcript of masked verdicts that each owner can check afterwards. It is multilateral (more than two owners), uses no cryptocurrency or blockchain, and runs on your own machine.
Guide: A fair group decision when everyone has private limits
How are red lines enforced, and what does the other side learn?
A red line is a code predicate on an option, such as cost <= 700. An option that fails it is rejected before any score is weighed, and it is never traded against a preference. The only thing that leaves an agent is a verdict per option: acceptable or not, a score between 0 and 1, and the word ok or red-line, never which rule was behind it. The score is public, so a reader of the record can infer preference ordering and the feasible region, and across enough options the pass/fail pattern shows roughly where a red line sits, even though the reason field stays masked. The engine enforces whatever limit you typed; it cannot tell a real limit from a tactical one.
Guide: Red lines for LLM agents, enforced in code
How does the group pick one option, and what happens when nothing fits?
Only options acceptable to every participant are candidates. Among them the engine picks the option whose lowest score across participants is highest, and breaks ties by the sum of scores; this is a max-min rule, not a majority vote, so a majority cannot outvote one owner's floor. When no option clears everyone's red lines the result is a deadlock with no decision, and a deadlock forces nothing on anyone. Scores are self-reported too, and there is no resistance yet to an owner misreporting them strategically or to collusion (SECURITY.md).
Guide: Fair multi-agent negotiation for rival owners
What can I check afterwards, and what does the receipt not prove?
You can re-hash the transcript (SHA-256 over its canonical JSON), recompute the max-min winner from the recorded verdicts, and replay your own private sheet against the decision with verify_non_betrayal, all on your own machine and without showing the sheet to anyone. The hash is unsigned, so it catches a later edit only when someone other than the editor kept the hash; verdicts are unsigned unless the run signed them, and a signed verdict is checked against the key carried in the same record, with no trusted owner-to-key roster yet. The participants list is written by the coordinator, scores are public and leak preference ordering, and every limit is self-reported.
Guide: Verify an AI-agent decision without trusting the coordinator
How do I try it, and what does it need?
pip install parley-consensus gives you the core with no third-party dependencies on Python 3.10 or later (tested on 3.11 to 3.14), plus the parley-mcp command, a stdio MCP server you can point Claude or Cursor at. Signed verdicts need the crypto extra, pip install "parley-consensus[crypto]". The examples and scripts, including the receipt verifier, are not in the PyPI wheel; clone the repository, which is Apache-2.0. It is Alpha (v0): do not run it against genuinely adversarial principals in production. The demo on this site replays pre-computed runs of the same engine.
Guide: Parley as an MCP server for multi-party agent decisions