Secrets that
Open Themselves

Everything you send arrives readable, so the order you send in decides what happens to you. Bid early and your number is public while the auction is still running.

The usual answer is commit now, reveal later. It fails the same way every time: revealing is a move, and whoever is losing declines to make it.

A round is a moment. Everything sealed to it is encrypted in your own process, so what crosses the network is already a ciphertext. Nobody reads it early: not the other participants, not you, not the operators.

At the deadline, three of the five operators combine their shares and every submission opens at once. None of them is trusted: two together learn nothing, and every share is checked by a public pairing equation. The reveal is not a participant’s move, so there is nothing to withhold.

Every commit and reveal scheme has the same hole. Revealing can be declined, and the person most likely to decline is the one who has just worked out they lost.

A Peal round opens because the deadline arrived, not because anyone chose to. No reveal step to skip, no bond to slash for skipping it, no timeout branch to write.

No single operator holds a key that opens anything, and no operator is trusted. The key is distributed among five operators and takes three of them to use. Two can be offline, compromised or simply refusing, and the round still opens on time.

The threshold is arithmetic, so it is not a diagram. Turn operators off and watch: two never opens it, any three do.

The key shares are distributed among five operators: Meridian Assay, Halcyon Registry, Northwind Trust, Ardent Notary and Vantage Archive, the five operators holding the committee's key shares. Peal runs them during testnet, and in v1 the shares come from a distributed key generation. The auction committee's signing keys are derivable from a published string, so nothing here is custody and nothing here should hold value.

A round is not opened one submission at a time. Sixty-four slots share a single threshold decryption, so a round holding sixty submissions costs what a round holding one costs.

The slots that carried nothing are padding, indistinguishable from the ones that did. From outside, a full slot and an empty one are the same ciphertext.

A searcher reads a pending swap, buys in front of it and sells behind it. The swap fills worse and the difference is the searcher’s. It is the ordinary cost of a queue that is legible before it settles.

Peal seals the order to the block it belongs in. While it is pending it is a ciphertext, so there is no number to trade in front of. The searcher is not blocked from acting. There is nothing to act on.

Get sandwiched, then don'tHow the sealed lane works

The demo is not a drawing. Both pools are real contracts on a public testnet, the searcher is a real bot, and the sealed order settles through PealMempool.executeBatch. The committee’s key shares are distributed among five operators, run by Peal during testnet, and v1 generates them with a distributed key generation. The cryptography and the settlement are real.

An open book turns an auction into a waiting game. The winning bid is often not the one that valued the thing most, just the one that arrived last with everybody else’s number in front of it.

A Peal auction has a close rather than a race. Bids go in sealed and rank on the deadline, from numbers nobody could read while bidding was open, the seller included.

Run a sealed auctionHow sealed bidding works

Bids in the live auction are sealed in the browser to the same committee, with the same batched threshold encryption, as everything else on this site. The committee itself is still a testnet prop with derivable keys, and the auction pages say so.

An agent cannot accept terms, hold a key it did not earn, or wait for somebody to approve an invoice. It can do exactly one commercial thing well, which is pay for a single request.

x402 is HTTP 402 used as specified: the server states a price, the caller pays on chain, then asks again carrying the proof. Every route is mounted twice, free at /v1and metered at /v1/x402.

No account was created, no key was issued and no invoice exists. That is what makes it usable by software that did not exist when your signup form was written.

Wire up a paid callThe agent skill

• Procurement and tenders

  Suppliers price the work instead of pricing each other. Nobody sees another number before the deadline, the buyer included.

  tag: 'rfq:<tender>' · one condition per tender

• Sealed bid auctions

  Spectrum, carbon, freight, secondary equity, domain names, liquidations. Every bid opens at the close and ranks at once, so arriving last buys nothing.

  tag: 'auction:<id>' · one seal per bid

• Encrypted order flow

  Orders seal to the block they belong in, so the queue is fixed before it is readable. There is no number to trade in front of.

  kind: 'at_block' · one condition per block height

• Agent commitments, paid per call

  Two agents commit to a price or an action, sealed until a stated moment, neither able to read the other first. x402 settles the call, so neither needs an account.

  POST /v1/x402/rounds · 0.001 USD per call

• Compensation and offers

  Offers, counter-offers and salary bands open together on a stated date. Nobody negotiates against a number they were shown early.

  tag: 'offer:<req>' · one condition per requisition

• Governance and voting

  Ballots stay sealed until the poll closes, so no running tally can start a bandwagon. The count is computable by anyone afterwards.

  tag: 'vote:<proposal>' · one condition per poll

• Forecasts and research calls

  Analysts, desks and prediction tournaments submit into a sealed window. Nobody copies a better forecaster and nobody edits after the outcome.

  tag: 'round:<n>' · one condition per window

• Grants, bounties and admissions

  Applications and reviewer scores open together, so reviewers do not anchor on each other and nobody is ranked by who submitted first.

  tag: 'panel:<cycle>' · scores as payloads

• Embargoed disclosure

  Earnings, a security advisory, an index rebalance, a press release. The embargo holds itself, and lifts for everybody at the same instant.

  kind: 'at_time' · one condition per embargo

• Token launches and allocations

  Allocation requests are sealed until the window shuts, so the size of the book cannot be traded on while it is filling.

  tag: 'sale:<round>' · slots padded to the batch

The shape is the same every time: people commit to something they cannot take back, and nobody sees anybody else’s until they all open together. Twelve of these are worked through in the documentation.

No API key, no account, no signup, no payment. Open a round, seal a payload to it, read it back after the deadline. That is the whole integration.

The client is one file with the encryption compiled in, served from this site. Skip it and every call above is plain JSON over HTTP.

Peal is not a way to keep something secret for ever, and that is the product rather than a gap in it. A round is unreadable until the moment it names, and public from then on.

• That a round existspublic
• Who created it and when it openspublic
• What is sealed inside itnobody, until the deadline
• How many submissions it holdsnobody, until the deadline
• Everything, after the deadlinepublic

If you need data nobody ever sees, this is the wrong tool. If you need data nobody can act on early and everybody can verify afterwards, this is the whole of it.

• What is Peal, in one sentence?

  Programmable privacy infrastructure. Agents submit encrypted bids, offers, votes and intents, and they open only when the conditions you define are met, with proof for every reveal.

• Do the people submitting need a wallet or any crypto?

  No. Sealing happens in their browser or in your own code and goes over ordinary HTTPS. No wallet, no account, no gas, and they never touch a chain. That is usually the difference between a mechanism you can ship to your users and one you can only ship to crypto users.

• Who can read a submission before the deadline?

  No single party: the decryption key is distributed among five operators, no three of them combine their shares until the condition fires, and two of them together learn nothing. Peal runs the operators during testnet, and in v1 the shares come from a distributed key generation.

• What stops somebody refusing to reveal when they see they have lost?

  There is nothing for them to refuse. Opening a round is not a participant’s move, so a losing bidder walking away costs everyone else nothing. That single difference is what separates this from every commit and reveal scheme, all of which break in exactly that spot.

• What if an operator goes offline?

  Three of the five are enough, so two can be down, unreachable or actively refusing and the round still opens on time. The committee above is interactive, so you can see the threshold rule for yourself; live share arrivals are on the activity dashboard.

• How can someone start building using Peal?

  Fastest is the quickstart, which runs the three calls against the live network from the page itself, so you can watch a round open before you have written anything. If you build with Claude Code, curl -fsSL https://peal.network/skill/install.sh | sh installs a skill carrying a reference for the API, the errors, timing, payments, verification and building the interface, and the assistant then knows the endpoints without you pasting documentation at it; any other coding agent can read the same skill from https://peal.network/skill/SKILL.md. There is an llms.txt at the root for any model that reads one, and peal.js if you would rather seal in the visitor’s own browser with no build step. If none of that appeals, it is three HTTP calls with no key and no account, so curl is a perfectly good client.

• What does it cost?

  Nothing. No key, no account, no signup and no card. Every route is also mounted at /v1/x402 for callers who want to pay per request, currently 0.001 USD, and that twin is opt in. The free API is not degraded to make the paid one look better.

• Is this actually running, or is it a paper?

  Running. The quickstart executes against the live network from the documentation page itself, the encrypted mempool demo settles real transactions against real contracts on a public testnet, and the parameters and endpoints are published. It is a devnet, and none of it is carrying real money yet.

• How is this different from encrypting something and handing over the key later?

  Somebody has to be holding that key, and holding it is the same thing as being able to use it early, lose it, or be compelled to produce it. Here no single party holds the key, and the release is triggered by the condition rather than by a person deciding the moment has come.

• How much can one round hold?

  As many as it needs. Seals open in batches of sixty-four, each by a single threshold decryption, so a round holding sixty submissions costs what a round holding one costs, and a busier round is split into several batches that open together. Slots that carried nothing are padding and are indistinguishable from the ones that did, which is why an open round will not tell you how many submissions it is holding.