The referee for deals between agents.
When your agent negotiates or coordinates with another agent, PrefSift finds what works, and says why.
Settlesa panel interview, a marketplace price, a truck shared by three shippers, a refund dispute
A decision API for agents: one call checks every option against every side’s limits, with a reason for each.A decision API for agents. One call checks every option on the table against every side’s limits and logs a reason for each, or each side sends its own through a shared session. It uses less than half the tokens of a negotiation loop, and the same inputs always give the same answer.
Free during early access · docs now, key by email
Panel interview with three interviewers
Wed Oct 14, 2:00pm
✓ Works for you and the whole hiring team
ConfirmOther times
Tue 10am, Wed 11am: before noon, and you said afternoons
Thu 1pm, Thu 3pm: you said not Thursday
Tue 1pm, Tue 3pm, Wed 4:30pm, Fri 2pm: don’t work for the hiring team
Behind the scenes
- 🧾Auditable.Every other slot comes back with its reason, logged with the decision.
- ⚡Efficient.Your scheduling agent makes one call, POST /v1/decide, with the candidate’s sentence, the recruiter’s policy and three calendars. No back-and-forth.
- 🎯Deterministic.Same inputs, same slot, every run. The candidate never sees anyone’s calendar or policy.
Which sounds like you?
What it changes for your team.
For agents in one system or across companies.
Stop agents agreeing to pickups the warehouse can’t make.
Today
In 13 of our 90 freight test haggles, an agent accepted a deal that broke its own side’s rule, once just to save $130.
With PrefSift
The dock schedule goes in as data and is checked in code, so that option is never offered.
How we know: The real transcript is below: the agent talked itself into an 8am window when the freight wasn’t ready until 10.
1 · Send each side’s context
One call returns what fits, with a reason for each option.
HTTP and JSON, nothing to install. Call it anywhere in your agent’s flow, in parallel with its own work. The response here came from the live API when this page loaded.
Docs:QuickstartAPI referenceSemanticsAgent skill filellms.txt
Live response, computed for you just now
Calling the API…
Crossed out: breaks someone’s limit. Beaten: another option is as good for every side and better for one. Kept: neither.
See the code: 12 lines of Python, TypeScript, a session, cURL
import os, httpx
r = httpx.post(f"{os.environ['PREFSIFT_URL']}/v1/decide",
headers={"authorization": f"Bearer {os.environ['PREFSIFT_API_KEY']}"},
json={"request_id": "demo",
"attributes": [{"attribute_id": "price", "type": "money", "currency": "USD"}],
"candidates": [{"candidate_id": "a", "facts": {"price": "$180"}},
{"candidate_id": "b", "facts": {"price": "$240"}}],
"parties": [
{"party_id": "buyer", "evidence": [{"evidence_id": "b1", "kind": "principal_quote", "text": "Nothing over $200."}]},
{"party_id": "seller", "evidence": [{"evidence_id": "s1", "kind": "principal_quote", "text": "Not under $150."}]}]})
print(r.json()["explanation"]["options"])
# {'b': "Crossed out: $240 is over buyer's $200 limit.", 'a': 'Kept: fits every limit, ...'}2 · It checks every option
Every side’s context in. One table of options. Every option checked.
1Each side sends its context
Messages, rules, listings, policies, as they are.
Seller’s agent
“Don’t go under $450. I’d rather they pick it up.”
Buyer’s agent
“Up to $480, and I really want the lock and lights.”
The listing
price: 420 · 460 · 500 handoff: pickup · shipped extras: none · lock, lights
2A model reads it
Into limits and preferences, each tied to what a side said.
Read by a model
LimitSeller: at least $450
LimitBuyer: at most $480
PreferenceSeller: pickup over shipping
PreferenceBuyer: lock and lights over bike only
3The solver decides
Checks every option against every limit and proves which are beaten.
Decision table · 12 options
4Each side gets its answer
With its own reasons. Never the other side’s limits.
The seller sees
✓ $460, pickup, with lock and lights
Offers under $450: under your $450.
The buyer sees
✓ $460, pickup, with lock and lights
$420 offers: don’t work for the seller.
The same steps run whether the sides send messages or rules as data; data skips the reading. The example is a recorded bike sale: the options and reasons are the ones PrefSift returned.
2 · And when nothing fits
When there’s no clean answer, it says so.
When each side sends its own limits, open a session for one decision. Each participant joins with its own code, sends its own inputs and gets its own view.
- Participants
- Options
- Each side’s limits
- Who sees what
- Approvals
- Record
Nothing fits
Bike sale: the seller won’t go under $500, the buyer won’t go over $480.
Nothing is known to fit every side’s limits yet.
- $460: under the seller’s $500 minimum.
- $475: under the seller’s $500 minimum.
- $490: under the seller’s $500 minimum.
No deal is the right answer here. Neither side learns the other’s number.
Can’t tell yet
Maintenance window: operations needs it to start after the backup; support needs the hour fully staffed.
1 of 3 fit every limit.
- 11pm–midnight: kept. Fits every limit.
- Midnight–1am: crossed out. Support isn’t staffed for the full hour.
- 10pm–11pm: can’t tell yet. Nobody has said whether it starts after the backup.
It asks: “For 10pm–11pm: starts after the backup finishes, yes or no?”
See the record for “Nothing fits”
{
"status": "no_known_feasible_candidate",
"candidate_scope": "supplied_candidates",
"feasibility": {
"known_infeasible": ["p460", "p475", "p490"],
"witnesses": [
{ "candidate_id": "p460", "rule_id": "floor", "party_id": "seller",
"result": "false", "proof_id": "p_76da5a44cb0dbdb84aed9879" }, …
]
},
"selection": { "selected_candidate_id": null },
"semantics_version": "cp-v1.0",
"content_hash": "cd907d784484…"
}Trimmed from a real response. Every crossed-out option comes with a proof in the response, and the same inputs give the same hash and the same result.
3 · Each side gets its own answer
Each side sees its own reasons. The other side never sees your limits.
PrefSift receives every side’s limits and shows them to no other side.
The same result, seen by each side of a couch sale:
The buyer’s agent sees
$420 courier: crossed out, over your $400.
$395 courier: kept.
The seller’s agent sees
$420 courier: crossed out, doesn’t fit the buyer.
$395 courier: kept. You get $350 after the $45 courier fee.
Calls, sessions, permissions and what it won’t do
One call, or a session
One call: your agent already has every side’s limits and sends them together. If it’s missing something, PrefSift says what to ask the other side’s agent, even one that doesn’t use PrefSift.
A session, when each side should send its own:
- 1Your agent starts a decision and gets a code for each other side.
- 2It invites them. Each agent reads the docs, then joins or declines.
- 3Each side sends only its own limits, straight to PrefSift.
- 4Everyone gets the result at once, with the reasons they may see.
“Hollis & Pine invites you to settle ‘a damaged table claim’ with PrefSift, a neutral referee. Your limits go to PrefSift, not to the other participants, and it costs you nothing. To join, POST /v1/sessions/ses_8Kq2…/join with header X-Session-Code: ps_Rw4…; to say no, POST …/decline.”
Who sees what
Each decision has its own small permission list: who sees whose limits, whether reasons name them, and who gets the record.
- Limits
- Each side sees its own, by default. Or named people, or everyone.
- Reasons
- Name only the viewer’s own limits, or all of them.
- Raw inputs
- Only the side that sent them, unless you allow more.
- The record
- Whoever starts the decision and any observers, or everyone.
Where the options come from
You choose, per decision, and can mix them.
You send them
Your catalog, your calendar, your quotes
Found in the parties’ documents
Offer emails, PDFs, a listing
PrefSift searches
Open tables, flights, venues, with a spend cap
Your agent searches
With its own tools, then sends what it found
What each agent sends
Each agent decides what to send for its person, and every item says what it is and where it came from.
- InstructionRules from the person or the operator
- QuoteA short snippet of what the person said
- SummaryThe agent’s own summary of what its person wants
- RecordA price list, a policy, a calendar
- Memory fileA raw memory file from a connected assistant. PrefSift keeps only the lines about this decision.
Agents can read the docs and a skill file, so joining takes no human setup.
It won’t
- Pick a fairness rule. It applies the one your app declared.
- Show one side’s limits to another unless the decision allows it.
- Treat silence as yes. A missing fact stays open, with the question to ask.
- Act on an old memory from a raw file until someone confirms it.
- Book, pay, or message anyone.
Head to head
Agents haggling, or one call.
Between companies
Inside one company
Agents haggling
…PrefSift
…- 2 sides sent their context
- A model read it into a decision table: 12 options, every limit and preference
- A solver checked every option
More detail
Evidence, features and where this is heading.
Pricing at general availability
Whoever starts a decision pays. Everyone invited joins free.
Free during early access. After that, rules sent as data cost nothing, and reading messages uses under half the tokens of a negotiation loop: typically 1 to 6¢ a decision, with a monthly spend cap on every key.
How billing works
- Typically 1 to 6¢ a decision, billed to whoever starts it. People using their own assistant pay nothing.
- You pay only for reading words. Tokens read are the messages PrefSift reads; tokens written are the rules its model writes from them. Solving and re-solving are free.
- A monthly spend cap on every key. Calls that would go past it are refused, so the bill can’t run away.
- The free tier (2M tokens read and 200K written a month) covers about 150 decisions that read a few messages each, and unlimited decisions sent as data.
Free
$0
2M tokens read, 200K written a month
Unlimited solves.
Pay as you go
$0.50 / $8
per million tokens read / written
No monthly fee. Written: the rules its model writes.
Team
$149
a month, 150M read and 25M written included
Then pay-as-you-go rates.
Businesses
Custom
quoted per deployment
Approvals near your limits, a record of every decision, and help setting up your first one.
Where it fits
Keep your stack. Add the decision.
Agent protocols (A2A, MCP)
How agents find each other and pass tasks and results.
PrefSift adds: What the sides can agree to, checked against each side’s limits.
Agent frameworks and supervisors
How your agents split work and pick the next step.
PrefSift adds: Settling what several agents or parties require, with a reason for each option.
Rules engines
Whether one action is allowed by one set of rules.
PrefSift adds: Several sides’ limits and preferences at once, some conditional, each side seeing its own explanation.
Negotiation agents and mediators
What one side should offer next.
PrefSift adds: Every option on the table checked directly, instead of discovered turn by turn.
Optimization libraries
The best answer to a model you write.
PrefSift adds: The model built from each side’s inputs, plus sessions, permissions and records.
Questions
When does this beat a few if-statements?
For one price cap between two sides, you could. PrefSift is for when it grows: options with several attributes, conditional preferences (“if Saturday, then morning”), several parties, each side’s limits hidden from the others, an agent you don’t control joining with a code, limits written in plain English and read with a quote check, a record of which rule removed which option, and sign-off near a limit. That’s one request here, instead of a module you maintain.
Who decides the outcome: a model or code?
Code. A model is used only to read free text into rules, and each rule keeps the quote it came from. The decision itself is deterministic: the same rules give the same answer on every rerun, with a reason for every option you can show a user or an auditor.
Can I use it between my own agents?
Yes. When agents in your own system propose different things, a planner, a pricing agent and a scheduler say, send each one’s proposal and rules in one call. You get what fits all of them, a reason for every rejected proposal, and the same answer on every rerun, which makes the system testable. It replaces a debate loop or a supervisor prompt that picks a winner.
Can a decision end without an answer?
Yes. If no option fits every side’s limits, it says so and gives the reason for each. If a fact is missing, it says which option is waiting and asks for it. If several options fit and nobody has said how to choose, it returns all of them. No deal is sometimes the right answer.
Does it guarantee a fair deal?
It applies the rule for choosing that you or the sides set, such as “cheapest wins” or one side’s preference breaking ties, and records which rule decided. Without one, it returns every option that fits. It can’t tell whether a side was honest about its limits, and it never calls an outcome fair on its own.
Do I still need a rules engine?
If you’re checking one side’s fixed policy, a rules engine may be all you need. PrefSift is for decisions where several sides send their own limits and preferences, some of them conditional, and each needs its own explanation.
What if the model misreads a limit?
Each rule keeps the exact quote it was read from, so you can check it. A limit PrefSift can’t read clearly comes back as a question for that side instead of a guess. Send anything that must never be misread, like a price floor, as data: then no model touches it.
How fast is it?
Rules sent as data decide in milliseconds, with no model call. Plain-English messages are read once, usually in 5 to 17 seconds, and a message read before is reused in milliseconds. Call it alongside your agent, in parallel with whatever else it’s doing.
What about uptime and lock-in?
If PrefSift is unavailable you get a 503 with Retry-After; have your agent fall back to asking the person. Every decision’s record can be fetched as JSON, and the semantics are documented, so any result can be checked and reproduced. During early access there’s no SLA yet.
Does it work with A2A or MCP?
Yes. A2A and MCP carry messages and tool calls between agents; PrefSift decides between them. Call /v1/decide from your A2A task handler, or wrap it as a tool in your MCP server. It’s a plain HTTPS API, so any agent framework can call it.
How is this different from contract-negotiation APIs or negotiation libraries?
Contract tools work clause by clause from templates and pick a single compromise. Negotiation libraries need you to write scoring functions and run the negotiation yourself. PrefSift takes each side’s limits in plain words or as data, for any kind of decision, and returns every option that fits everyone, with a reason for each one it crossed out. Each side sees only its own limits named.
Can the other side’s agent talk my user past their limit?
No. A limit is checked in code after every model has had its say, so no wording, persistence or stronger model on the other side can move it. The other side never learns the number either: it sees “doesn’t fit the other side.”
Where should hard limits live?
As data in the request. A limit in a system prompt is advice to one model; a limit sent as data is checked in code, so an option that breaks it is never kept, and it costs no tokens to apply.
What happens to our data?
It’s used only to make the decision and keep its record. Reading messages uses OpenAI’s API, which doesn’t train on API data by default; rules sent as settings never reach a model. Retention, storage location and a data processing agreement are set per deployment. We don’t have a SOC 2 report or a HIPAA business associate agreement yet, so don’t send health details as free text.
What if the other side’s agent doesn’t use PrefSift?
Your agent can call alone. PrefSift returns the exact questions to ask the other agent, and decides again when the answers come back. Sides that haven’t changed aren’t read twice.
What does it cost?
Whoever starts a decision pays per token read, typically 1 to 6¢ a decision, and nothing when every side is sent as data. Everyone invited joins free. Each API key has a monthly spend cap you set.
Get API access.
- Get a keyFree during early access.
- POST /v1/decideThe quickstart and the agent skill file are open now.
- ShipEvery decision comes back with a reason for each option.