Parley

parley.

Several owners, private limits, one decision that crosses nobody's red line

Give each party's agent a private red line. Parley picks the option that crosses nobody's line and lifts the least-happy party, and every owner can check on their own machine that their limit held. Nobody shows their sheet, not even to the coordinator.

Red lines are code, not prompts · multilateral (N>2) · non-crypto · self-hosted · zero-dependency Python · Apache-2.0.

[Try it live](https://parleyprotocol.com/demo/) · [See it in 30 seconds](#see-it-in-30-seconds) · Roadmap · Changelog · Security · Contributing · Español: herencia entre hermanos · Español: ¿unanimidad para vender? · English: do all heirs have to agree to sell a flat in Spain? · Ukrainian

Rival parties reach a max-min decision · a shortcut that would cheat someone is BLOCKED by a red line · every party verifies the tamper-evident receipt.

Works from an MCP host (Claude, Cursor) and from OpenAI Agents SDK, smolagents and LangGraph: the three recipes return the same receipt hash for the same decision.

---

Install

pip install parley-consensus              # zero-dependency core

pip install "parley-consensus[crypto]" # + Ed25519-signed verdicts

The distribution is parley-consensus (PyPI's parley is an unrelated project); the import name is parley.

Install as a Claude Code plugin

/plugin marketplace add 5uper0/parley

/plugin install parley@parley

This registers the parley-mcp stdio server, launched with uvx --from parley-consensus parley-mcp, so uv must be installed.

Quickstart

from parley.agent import Agent

from parley.consensus import run_consensus from parley.preferences import HardConstraint, PreferenceSheet

options = [ {"venue": "rooftop", "cost": 900}, {"venue": "garden", "cost": 600}, {"venue": "diner", "cost": 300}, ] ana = PreferenceSheet( "Ana", utility=lambda o: 1.0 if o["venue"] == "rooftop" else 0.4)

a red line: code, not a preference

bob = PreferenceSheet( "Bob", hard=[HardConstraint("budget", lambda o: o["cost"] <= 700)], utility=lambda o: 1 - o["cost"] / 1000) cara = PreferenceSheet( "Cara", utility=lambda o: 0.9 if o["venue"] == "garden" else 0.5)

agents = [Agent(s.owner, s) for s in (ana, bob, cara)] result = run_consensus(agents, options) print(result.status, result.decision) print("receipt sha256:", result.transcript.hash())

each owner replays their own private sheet, locally

for sheet in (ana, bob, cara): ok = result.transcript.verify_non_betrayal(sheet, result.decision) print(sheet.owner, "not betrayed:", ok)

agreed {'venue': 'garden', 'cost': 600} receipt sha256: 30483303e4d94e22833161d9bb8c292c0effff88c3303d7e195e57d49c88f516 Ana not betrayed: True Bob not betrayed: True Cara not betrayed: True

The hash above is what version 0.2.1 and later print: a rejected option's score is reported as 0. Version 0.2.0 prints a9cb75c0... for the same snippet; the decision and the verdicts are identical.

The rooftop is Ana's favourite and loses anyway: it crosses Bob's budget red line, so it is rejected before any score is weighed. The coordinator only ever saw red-line, never the budget or the sheet.

Contributors install from a clone instead: pip install -e ".[dev]" (see Status).

Use it from an MCP host (Claude, Cursor)

The base install ships a stdlib-only MCP server over stdio. Point your host at it:

{"mcpServers": {"parley": {"command": "parley-mcp"}}}

If the console script is not on the host's PATH, launch it through the interpreter that has the package: {"command": "python", "args": ["-m", "parley.mcp"]}.

The server speaks both MCP eras: hosts on the 2026-07-28 revision (no initialize, version and capabilities in each request's _meta, server/discover for discovery) are served statelessly, and hosts on 2025-11-25 or earlier get the usual initialize handshake. Same tools, same receipt hash on both.

Three tools appear: parley_decide (options + each party's red lines and preferences in, status, decision, transcript and transcript_sha256 out), parley_verify_receipt (recompute the hash over a transcript, and recompute the max-min decision from its recorded verdicts) and parley_check_party (replay one party's red lines against a decision). To check what parley_decide returned, pass its transcript and transcript_sha256 to parley_verify_receipt: scripts/verify-receipt.py reads the receipt file examples/real_decision.py writes, not the parley_decide result, and rejects it. The input is the same JSON as the recipes in examples/demo/, passed under one spec key. If you call the tools yourself instead of through a host, the three calls look like this (arguments of tools/call):

{"name": "parley_decide",

"arguments": {"spec": {"title": "...", "options": [...], "parties": [...]}}} {"name": "parley_verify_receipt", "arguments": {"transcript": {...}, "sha256": " "}} {"name": "parley_check_party", "arguments": {"party": {"owner": "Bob", "hard": [...], "utility": [...]}, "decision": {...}}}

The result of parley_decide is not a receipt file for scripts/verify-receipt.py; check it with parley_verify_receipt. Example prompt:

Three of us are picking a venue: rooftop (900), garden (600), diner (300). Bob will not go over

700; Ana prefers the rooftop, Cara the garden, Bob the cheapest. Use parley_decide, then verify

the receipt hash and check that Bob's red line held.

What this mode does and does not give you. The host holds every party's spec and passes them all in one call, so there is no privacy between parties or from the host. What still holds is what the engine enforces in code: a red line rejects an option deterministically, the max-min rule picks among options feasible for everyone, and the receipt hash makes any later edit to the transcript visible, provided the hash is kept by someone other than whoever might edit the transcript: it is unsigned and the server does not store it, so a hash and a transcript from the same hand prove nothing about each other. max_min_verified does not depend on the hash: it recomputes the winner from the recorded verdicts. For private sheets, run one process per owner over HTTP (examples/run_env.py); the coordinator then sees only masked verdicts.

---

Most agent tooling in 2026 solves either transport/identity (A2A, MCP) or 1:1 agentic commerce (an agent buys/books for you), or *cooperative* debate between agents of the same owner. Parley targets the gap nobody productised: a group of delegates, each representing a different principal with conflicting and private interests, reaching a decision everyone can trust, and *prove* their agent didn't betray them.

Who it's for. Teams and platforms where several parties must reach a decision that crosses none of their red lines, and each can prove that afterward. Built first for regulated, multi-party workflows: compliance & onboarding decisions (KYC/AML, sanctions red lines), marketplace & P2P disputes, and delegated governance (committees, panels).

The wedge is three properties, enforced in code rather than left to an LLM's discretion:

1. Deterministic red lines. Each owner's hard constraints are predicates checked in code. A proposal that crosses one is *rejected*, never negotiated away. "My agent won't betray me" becomes a provable property, not a hope.
2. Conflicting-interest consensus. The coordinator sees only masked verdicts, a feasibility flag, a soft score, and a *masked* reason (ok/red-line), never the private sheets or which constraint was at stake. A decision must be feasible for *every* agent; among those it picks by an egalitarian max-min rule (lift the least-happy participant), tie-broken by total welfare, social choice, not majority vote. No feasible option ⇒ honest deadlock.
3. Verifiable transcript. A tamper-evident SHA-256 record of every masked verdict. Each owner can replay their *own* private sheet locally to prove no red line was crossed, without revealing the sheet to anyone.

Why this exists (and what we learned building it)

Agents are starting to act on our behalf: booking, negotiating, onboarding, allocating. The moment two agents serve different owners, "did my agent sell me out?" stops being paranoia and becomes a real question. The crypto answer to agent-trust (put it on a chain, add a token) collapsed 89–99.7%; the durable need is the trust primitive itself, decoupled from tokens.

AI that can't lie, and you can check. The 2026 agent-hype cycle proved virality can be

fully decoupled from truth. Parley is the provable version: every verdict in a parley is a

re-hashable receipt, and each owner replays their own private sheet to prove no red line was

crossed, no trust required, just the check.

Building the v0 taught us the wedge is narrower and sharper than "multi-agent consensus": the value isn't the vote, voting is free (Snapshot, polls). The value is provable non-betrayal under conflicting private interests, that no party had to reveal their private sheet or which red line was at stake, no red line could be traded away, and everyone can check the receipt themselves. That's what doesn't compose from off-the-shelf parts, and it's the one thing we made enforceable in code rather than left to an LLM's goodwill. The worked proof: docs/dogfood-01-p2p-escrow.md.

Neighbours, and what they do not do

Read from each project's own public description on 2026-10-25; they are different tools for different jobs, and some are complements.

| Acuerdio (Spa