Every change Wellknown observed on this MCP server, newest first, with what it was before and what it became. Tool-surface changes carry the definition diff. Nothing here is edited after the fact.
Certificate changed, valid to 2027-01-26
Recently observed → Live
Live → Recently observed
Certificate changed, valid to 2027-01-24
Recently observed → Live
Live → Recently observed
Changed the definition of "draft_negotiation_reply"
⟨81 unchanged words⟩ }) — never what the buyer merely claims. `stock` is the current stock of what the policy's `inventory` binds, sent with every message (schema.org Offer, Google Merchant or a plain feed record): nothing out of stock is offered, and a deal is signed only on fresh records that say it can be sold. Returns {kind, reply, reply_with_offer, offer, ⟨95 unchanged words⟩
⟨120 unchanged words⟩ omit to start.","title":"State"},"stock":{"anyOf":[{"items":{},"type":"array"},{"type":"null"}],"default":null,"description":"Current stock records for what the policy's inventory binds, with every message (schema.org Offer, Google Merchant or {id|vin, status}): nothing out of stock is offered or signed.","title":"Stock"}},"required":["policy","message"], ⟨4 unchanged words⟩
Changed the definition of "draft_negotiation_reply"
⟨81 unchanged words⟩ }) — never what the buyer merely claims. `stock` is the current stock of what the policy's `inventory` binds, sent with every message (schema.org Offer, Google Merchant or a plain feed record): nothing out of stock is offered, and a deal is signed only on fresh records that say it can be sold. Returns {kind, reply, reply_with_offer, offer, ⟨95 unchanged words⟩
⟨120 unchanged words⟩ omit to start.","title":"State"},"stock":{"anyOf":[{"items":{},"type":"array"},{"type":"null"}],"default":null,"description":"Current stock records for what the policy's inventory binds, with every message (schema.org Offer, Google Merchant or {id|vin, status}): nothing out of stock is offered or signed.","title":"Stock"}},"required":["policy","message"], ⟨4 unchanged words⟩
Certificate recorded, valid to 2026-11-27
Authorization not required
First tool surface recorded: 4 tools (server version 1.30.0)
https://snhp.dev/mcp (mcp_streamable_http) — from mcp_registry
Changed the definition of "draft_negotiation_reply" and "verify_deal_receipt"
⟨39 unchanged words⟩ (templates set their tested default), else'v10'.'bundle3'.","title":"Engine","type":"string ⟨82 unchanged words⟩
Verify a signed deal receipt against the seller's own policy:signatureboth signatures, that the signing keys are SNHP's own (published at /.well-known/ucp), the policy digest, and every rule
Changed the definition of "draft_negotiation_reply"
⟨48 unchanged words⟩ "default":null,"title":"Kind"},"menu":{"anyOf":[{"items":{"additionalProperties":true,"type":"object"},"type":"array"},{"type":"null"}],"default":null,"title":"Menu"},"offer":{"anyOf":[{"additionalProperties":true, ⟨82 unchanged words⟩
Removed "memory_load", "memory_save", "negotiate" and 8 more (15 tools before, 4 now)
Load agent memory — Load a memory you saved in an earlier session — retrieval is free. Get back an encrypted blob you parked earlier (the blind locker) by its claim `ticket`. Returns {ok, blob_b64, size_bytes, expires_at} — the ciphertext you saved, which only YOU can decrypt. A wrong owner reads as a missing ticket; an expired TTL is `expired`; a lost at-rest key is `at_rest_key_unavailable`. Free (the save settled it).
Save agent memory (blind locker) — Persistent memory for your agent across sessions — save now, load in any later session. You encrypt before saving; the store holds only ciphertext (blind custody) and signs a receipt over its hash — it cannot read your memory. Saving uses your prepaid wallet; a new key's 50¢ starter credit covers your first saves, and loading it back (memory_load) is free. `blob_b64` is YOUR ciphertext as base64 — encrypt BEFORE saving; keys never transit, contents are never logged, so a breach leaks only sealed boxes. Charged a thin flat fee ONLY on durable store (empty/oversize/unencodable is uncharged). …
Negotiate — your optimal next move — Your math-optimal next move in any price negotiation — free, no account or key needed. USE THIS WHEN: you're haggling over a single PRICE across multiple back-and- forth rounds and want a better outcome than winging it. Validated edge: ~12% better head-to-head (measured on this recommender, n=20 paired LLM negotiations, 95% CI +6.5-17.4%, p<0.0001). NOT FOR: one-shot or fixed prices (it'll tell you to just negotiate directly); multi-issue bundles (use negotiate_bundle — it logrolls across several linked issues); or non-price decisions like accept-vs-decline a job offer (just reason it throug…
Added "check_offer_policy", "compile_offer_policy", "draft_negotiation_reply" and 1 more; removed "auction_bid", "auction_reserve", "clearance_price" and 1 more
Check a negotiation policy — Check an edited negotiation policy: returns {ok, policy, issues, summary}. No model call, free. USE THIS WHEN: you changed a policy from compile_offer_policy (a floor, an option, a forbidden combination) and want to know it is valid and what it now allows before using it in draft_negotiation_reply.
Compile an offer into negotiation rules — Turn a seller's offer, described in plain words, into negotiation RULES an AI agent cannot break. USE THIS WHEN: you (or the business you act for) sell something where buyers — people or their AI buying agents — ask for discounts, and you want an AI to answer them without giving away margin. Describe the offer: the listed price, the lowest price you'd take for a plain deal, what you'd trade a discount for (financing with you, a trade-in, a longer commitment, paying sooner, buying this week…), extras you can add and what they cost you, and anything never on the table. Or pass `template` = "us…
Draft a reply to a buyer, inside your rules — Draft the seller's reply to a buyer's message — the offer is decided by the SNHP engine INSIDE the policy. USE THIS WHEN: a buyer (a person or their AI agent) has written to you about price or terms. Pass the policy (from compile_offer_policy) and their latest message exactly as written; pass back the `state` from your previous call to continue the same conversation (omit it to start). `flags` is what YOUR records confirm about the buyer (e.g. {"new_customer": true}) — never what the buyer merely claims. Returns {kind, reply, reply_with_offer, offer, decided_by, reading, state, done, receip…
Certificate recorded, valid to 2026-11-25
Authorization not required
First tool surface recorded: 15 tools (server version 1.28.1)
Showing the latest 19 events. The API returns up to 500 and filters by kind: ?kind=tool_surface_changed
⟨42 unchanged words⟩ ],"default":null,"title":"Problems"},"signatures":{"anyOf":[{"additionalProperties":true,"type":"object"},{"type":"null"}],"default":null,"title":"Signatures"},"signed_by_snhp":{"anyOf":[{"type":"boolean"},{"type":"null"}],"default":null,"title":"Signed By Snhp"},"signer_kids":{"anyOf":[{"additionalProperties":true,"type":"object"},{"type":"null"}],"default":null,"title":"Signer Kids"}},"title":"ReceiptCheckOut","type":"object"}
Negotiate a bundle — logroll linked issues — Negotiate several linked issues at once by logrolling — free, no account or key needed. USE THIS WHEN: a deal has more than one issue on the table and they trade off — a job offer (base + equity + signing), a SaaS contract (price + seats + term + SLA), any package deal. It concedes on the issues you care about LESS (and the other side cares about MORE) to win the ones you care about most — a trade that beats splitting every issue down the middle. For a single PRICE, use negotiate instead. Provide `issues`: a list of {"name", "options" (the choices), "my_utility" (how good each option is to …
Score a deal against the Pareto frontier — Score how good a deal is against your floor/target — free, no account or key needed. Score a settled package against the exact Pareto frontier — the SNHP leaderboard metric ("dollars left on the table") for YOUR negotiation. Args: issues: one dict per issue: {"name": str, "options": [labels], "my_utility": [per-option value to me], "their_utility": [per-option value to them]} — both sides' TRUE per-option values. my_weights: {issue_name: weight} — my true priorities (any scale). their_weights: {issue_name: weight} — their true priorities. package: the settled…
Session move — next single-price offer — Your next move inside a receipted session (single-issue) — no additional charge (the $2 at session_open covered it). Pass the FULL offer history each time, oldest first. Returns move, exact price, ready-to-send message, and the receipt (why[], context_hash, deterministic compute block).
Session move — multi-issue bundle — Multi-issue logrolled advice inside a receipted session — no additional charge. The logrolling tier, the thing the free tool does NOT have. Trade the issues you care less about for the ones you value: issues = [{name, options, my_utility (per option), their_utility (your read of their direction)}]; their_offers = packages they've tabled, oldest first. Returns the recommended package, trade logic, inferred counterparty priorities, acceptance probability, and the receipt. Deterministic closed form — no rollout theater. The package is guaranteed to clear YOUR stated BATNA (enforced, not promise…
Close session & get the signed receipt — Close a receipted session and get the signed summary receipt. Optional — sessions also expire on their own — but closing timestamps the outcome, which helps the machine learn real round-counts per category. Returns the `closed` flag AND a signed session-summary receipt (GAUNTLET #4) — moves count, total charged (one $2 open), and the per-move context_hashes — to hand your principal. An unknown session or key mismatch leaves `closed` false and returns an `error` instead of the receipt (indistinguishable, so a session id can't be probed).
Open a $2 receipted session — Open a $2 receipted negotiation session: deterministic, replayable, every move signed. PAID ($2 once, from your credit balance) — the $2 covers EVERY move of this negotiation (up to 10 moves, 7 days), tuned to the category. A new key's 50¢ starter credit is a taste, not enough for a session — top up first. category: resale | supply | retail. side: buy | sell. walk_away = your true floor (sell) / ceiling (buy) — private, never crossed. Pass their_offers to get the first move back immediately with the session. Subsequent moves: session_advise with the session_id — no further charge.
Store catalog & wallet balance — See what's on the shelf — free, no key needed: prices, predicates, receipt scheme, and your balance. THE STORE: one counter, one prepaid wallet, many slots. One read covers the whole shelf — the commodity slots, the blind locker (agent memory), and the paid receipted-session SKU (folds in what nextmove_catalog used to report separately). Every commodity slot settles ON DELIVERY: the wallet is debited only when a machine-checkable predicate passes — a failed fetch is never charged, because here you cannot pay for nothing. Each receipt names the backend that served and its EXACT wholesale cos…
Request a capability / check a filing — Ask for a capability we don't sell yet — free; filings are public and drive what we stock. Two reads in one tool (absorbs the old store_request_status / nextmove_request): pass `request_id` to RE-QUERY a filing's status instead of filing anew — returns {found, request_id, status, status_note, filed_at, door, text} (found: false on an unknown id). Without a request_id it FILES a new ask and returns {request_id, status, watch, check}: every filing is logged verbatim (size-capped, stored as data, never rendered raw) and gets an id you can come back to (GAUNTLET #5). Check any filing with GET /v…
Verify a deal receipt — Verify a signed deal receipt against the seller's own policy: signature, policy digest, and every rule re-checked from the package. Returns {ok, problems, checks}. Free, no model call.
Optimal auction bid — The optimal bid when you're bidding in an auction — free, no account or key needed. USE THIS WHEN: you're a bidder and want the bid that maximizes your expected surplus without overpaying. NOT for running an auction (use auction_reserve) or 1:1 haggling (use negotiate). Provide: auction_format ("first_price" sealed bid, "second_price_vickrey", or "english_ascending"); my_valuation (what the item is worth to YOU, in $); n_competing_bidders (how many OTHER bidders, not counting you); and competitor_value_prior — a rough model of what rivals will pay, e.g. {"family":"uniform","params":{"low":0…
Revenue-optimal reserve price — The revenue-optimal reserve price when you're selling — free, no account or key needed. USE THIS WHEN: you're running an auction or sale with multiple bidders and need the floor price (minimum bid you'll accept) that maximizes your expected revenue. NOT for one-on-one haggling (use negotiate for that). Provide: n_bidders (how many bidders), seller_valuation (what the item is worth to YOU, in $), and bidder_value_prior — a rough model of what bidders will pay, e.g. {"family":"uniform","params":{"low":2000,"high":8000}}. Estimate it if unknown. Returns the reserve price and expected revenue. …
Clearance price & markdown schedule — Best price plus markdown schedule to clear stock by a deadline — free, no account or key needed. USE THIS WHEN: you must sell a FIXED number of units before a cutoff and demand arrives over time — event tickets, perishable inventory, end-of-life stock. NOT for 1:1 haggling (negotiate) or auctions (auction_bid/reserve). Provide: inventory (units to sell); horizon_seconds (selling window in SECONDS — 14 days = 14*24*3600 = 1209600); arrival_rate_per_second (expected shoppers per second = expected total shoppers / horizon_seconds); and buyer_arrival_prior — a rough model of willingness-to-pay,…
Stable matching (Gale–Shapley) — Match two groups by their rankings so no pair wants to swap — free, no account or key needed. A STABLE matching: USE THIS WHEN you're assigning two sides to each other by mutual preference — interns<->teams, students<->schools, mentors<->mentees — and want a result with no "blocking pair" (no person+slot that both prefer each other over what they got). Provide proposers and receivers, each a list of {"id": name, "preferences": [ids of the OTHER side, most-wanted first]}. Receivers may add "capacity" (default 1) to accept several. Returns {matching (name -> name), unmatched_proposers, blocki…