Agreements every system can compute.
Universal Paper writes the agreements between purchasing groups, suppliers, and members as signed data with a fingerprint. Every system that holds a copy reaches the same answer, and any change shows.
One clause, followed from words to proof.
Scroll. Each step is computed live in your browser by the Universal Paper engine.
- 01
Write a clause from a shared Term
The Admin-Fee Term is defined once, in a public library. An agreement only supplies its values: who pays, who is paid, the rate, the period. The sentence is generated from those values, so the words and the data cannot drift apart.
- 02
The agreement gets a fingerprint
The data is written in one canonical form and hashed. That 64-character fingerprint names this exact agreement. Anyone can recompute it from the agreement alone.
- 03
Change one value and it changes
The fee moves from 2% to 2.5%. The fingerprint changes almost everywhere; the highlighted characters are the ones that moved. There is no small edit that keeps the same fingerprint.
- 04
Every party signs the fingerprint
The aggregator and the supplier each sign it. Their contract system, ERP, and spreadsheet each check the signatures and compute the same state, without trusting one another.
- 05
An edited copy is caught by everyone
Someone changes the rate in the supplier’s copy after signing. The signatures no longer cover it, so that copy is rejected, and the other systems keep the agreement as signed.
The paper underneath the apps.
Universal Paper is meant to sit underneath, the way a file format or a network protocol does. Apps for contracting, procurement, pricing, and settlement compete above it. Agents act for parties within signed limits. They work together because they all compute the same fingerprints.
An illustration of a possible future. The apps are hypothetical and none of them exist yet. The parties, events, signatures, verdicts, and fingerprints are real: each scenario is generated and checked by the Universal Paper engine as you watch.
Apps compete above
A contract system, an ERP, and a procurement tool can each show the same agreement their own way. None of them owns it, and none has to trust another’s copy.
Agents act in a sub-tier
An agent signs only under a Mandate its principal signed, with limits on what it may agree to. An action outside those limits is invalid for everyone, at once.
The paper stays put
Each agreement keeps its own chain of signed events, held by its parties. There is no shared ledger to join, and changing apps does not change the agreement.
Write an agreement. Watch it fingerprint.
Change the fee, the length, or a name and watch the contract and its fingerprint update. Sign it, then change it again to see the signatures stop covering it. Compare versions, or play out a year of reports and payments. The values here are examples.
Edit every clause (advanced)
The data being fingerprinted (canonical JSON, RFC 8785)
How we know the engine is right.
Two independent implementations, one in Python and one in JavaScript, must agree on every fingerprint, verdict, and computed value. The figures below were recorded from the test suite when this page was built. You can also run fresh random checks here.
What the suite checks
| Test file | Tests |
|---|
Pre-release audit findings
| # | Severity | Finding (all fixed) |
|---|
Run random checks in your browser
Each run invents an agreement and a history from a seed, attacks copies of it in seven ways, and checks eight invariants against arithmetic that does not use the engine. Failures are kept so you can reproduce them from the seed.
| Must hold | Passed | Failed |
|---|
| Attack on a copy | Caught | Caught by |
|---|