"0.025" → "0.02"
UP:Renewing-Term · max_renewals
1 → 2
Deal Desk
Compose proposals from the Term library and negotiate only the parameters. The counterparty sees a value diff, never a redline.
Universal Paper is an open language for agreements between GPOs, suppliers and members. Every agreement, signature and change is plain JSON that any system can check for itself, offline.
up validate examples/conventional/bundle.json
The problem
The GPO's contract system, the supplier's ERP and the member's spreadsheet each hold their own version of the same agreement. Teams spend weeks reconciling them. Universal Paper gives all three the same record, with a fingerprint that proves they match.
How it works
Scroll to follow the admin-fee clause from the repo's conventional example. Every hash below is computed live in your browser.
"term": "UP:Admin-Fee", "payer": "supplier", "payee": "aggregator", "rate": "0.02", "due": { "count": 30, "unit": "day" }
The GPO's contract system, the supplier's ERP and the member's spreadsheet each describe the same deal. Universal Paper gives it one shape: plain JSON built from standard Terms, with the parties' own numbers.
Canonical JSON (RFC 8785) plus SHA-256 turns the agreement into 64 characters. Any system, in any language, computes the same ones.
Each party signs the hash with Ed25519. The signature covers these Terms and these numbers, nothing more and nothing less.
When January's sales report arrives, every party's software computes the same fee and due date from the signed clause. Nobody re-keys a number.
Change the rate after signing and the fingerprint no longer matches. Every party's software rejects the copy, offline, without asking anyone.
A Seal hides a value from parties who shouldn't see it (A10). They still check the signatures and reach the same verdicts.
Try it
Change the rate, the due period or the rounding. The fingerprint, the contract text and the fee recompute in your browser, exactly as the Python reference does.
sha256:616dac2fd52f336580dec71a1d1f00ccabed5b3ef0e14b15bb0761a453218623Install the reference interpreter, replay the example chains and derive what's owed.
Get started → Product buildersDeal desks, price sync, renewal calendars and agents that work with every counterparty.
Browse app ideas → Procurement & financeBefore-and-after for business development, procurement, finance, implementation and legal.
Compare by team → Legal & standardsEvery Term's contract text, parameters and machine meaning, hashed in your browser.
Open the Term library →From signature to first invoice
This is the conventional example from the repo: a GPO and supplier sign a tiered agreement, a hospital joins, its tier is confirmed, and the first report and fee settle. Every date and number below comes from the example chains. The parties and values are hypothetical
Business development composes the agreement from standard Terms: renewal, three price tiers, monthly sales reporting, a 2% admin fee, audit and exit. The proposal is signed and becomes the first event of the chain.
The supplier accepts the exact agreement hash it reviewed. Both required signers now agree, so the agreement is executed and goes into force on 2027-01-01.
The participation is its own small agreement linked to the master. The GPO proposes at 09:00, and the hospital and supplier accept by 16:00. It starts on tier C until a tier is confirmed.
The hospital attests tier B and the supplier acknowledges it the same day. Every system derives the same contract prices from the chain. Nobody had to send or load a price file.
The supplier reports January's sales against each participation. The fee owed follows by itself: 2% of USD 3,050.00 reported, which is USD 61.00, due 30 days after the period ends.
The hospital's purchases now qualify for tier A. It attests, the supplier acknowledges, and the derived prices change for everyone at once.
The supplier attests payment of USD 61.00 and the GPO acknowledges it. The obligation is discharged in every copy, with no true-up spreadsheet.
What changes for each team
When every party works from the same verifiable record, most of the work between "signed" and "paid" stops being manual. Here's what that could look like for the people who live in it today.
Value-neutral by design: the library never suggests a price, rate or period.
obligations(S, t), the same way for both sides.The language standardizes process, never prices or economic terms.
These describe possibilities the design allows. They are not measured results from a deployment.
Time to first invoice
Illustrative only. Bar lengths show the shape of the work, not a measurement.
Copies either match the signed hash or are rejected. There's nothing to compare by hand.
Contract price follows from the tier schedule and the member's acknowledged tier.
The fee follows from the reported sales and the signed rate, with rounding defined in the spec.
Corrections are new events. The past can't be edited, only added to.
At a glance
Each count below is fixed in the spec. Every new construct is a permanent commitment, so the language stays small enough for any engineer to implement and any lawyer to read.
propose accept attestspec/06-termsEvery object is named by the SHA-256 of its canonical JSON. Same content, same name, on every machine.
State is computed from the chain, never stored. Two evaluators with the same events always agree.
Terms define meaning, never numbers. The library can't suggest a price, rate or period.
The signed contract text is generated from the data, under the same hash. They can't drift.
Agents act under Mandates. Anything outside the bounds is invalid for every evaluator.
Seals hide private values while hashes, signatures and states still verify.
The language
Seven primitives, two value types and six clause forms. Each primitive does one thing, and the list is short on purpose because every primitive is a permanent commitment.
The cover page: Parties in Roles, plus Clauses that apply standard Terms with values. Its hash is what everyone signs.
{"type": "Agreement", "spec": "UP/0.1-draft", "parties": […], "clauses": […]}Anything that can sign. A Party is its Ed25519 key.
"ed25519:315acb5c…"What a Party does in one Agreement.
aggregator · supplier · memberStandard meaning with a stable id, pinned by hash.
"UP:Admin-Fee"A signed change. Only three kinds exist.
propose · accept · attestWhere an Agreement stands. Never written, always computed from its chain, so every evaluator gets the same answer.
"status": "executed", "height": 9, "last": "sha256:68b6d6b8…"Bounded authority for an agent.
"rate": {"max": "0.03"}Reuses GTIN, GLN, HIN, NDC. Never mints IDs.
{"scheme": "GTIN", "id": "…"}A salted hash in place of a private value.
{"seal": "sha256:41135ba3…"}Every Term is built from these. A new Term never needs new code.
Term library
These are the real definitions from spec/06-terms. A clause pins a Term by its content hash, and this page recomputes each one so you can check it against the agreements that use it. All are drafts that counsel hasn't reviewed yet.
Terms as data
The real UP:Admin-Fee Term. Its prose and its machine meaning share one hash, so they can't drift apart.
The rendering template has a slot for each value the parties choose. There are no numbers in it.
Name, type and description, and nothing else. There's no field for a default value, so the library can't suggest a price or rate (axiom A6).
Who owes whom, how often, by when, how the amount is computed, and what discharges it.
The clause pins the exact Term definition by hash in def and supplies every parameter.
up render fills the template. Everyone gets the same sentence, byte for byte (axiom A8).
| name | type | doc |
|---|---|---|
| payer | Role | Role that pays the fee. |
| payee | Role | Role that receives the fee. |
| rate | Rate | Fee as a fraction of reported net sales. |
| report_clause | string | Name of the Sales-Reporting clause whose reports form the base. |
| period | Period | Fee period. |
| due | Period | Time after each period's end by which the fee is due. |
| rounding | Rounding | Rounding applied to each period's fee. |
{ "form": "Duty", "duty": "pay", "obligor": {"param": "payer"}, "obligee": {"param": "payee"}, "trigger": {"every": {"param": "period"}, "anchor": "window-start"}, "due": {"param": "due"}, "discharge": {"claim": "UP:Admin-Fee/paid", "ack": [{"param": "payee"}]}, "amount": { "rate": {"param": "rate"}, "base": {"claim": "UP:Sales-Reporting/report", "clause": {"param": "report_clause"}, "field": "total_net"}, "rounding": {"param": "rounding"} } }
{ "n": "fee", "term": "UP:Admin-Fee", "def": "sha256:7794f7872d6cef305839b2fdc7b7e9f2916e71f20cde4bdac95321848e21a85e", "params": { "due": {"count": 30, "unit": "day"}, "payee": "aggregator", "payer": "supplier", "period": {"count": 1, "unit": "month"}, "rate": "0.02", "report_clause": "reporting", "rounding": {"mode": "half-even", "scale": 2} } }
### 4. Administrative fee (UP:Admin-Fee, clause "fee")
For each period of 1 calendar month, the Supplier pays the Aggregator an administrative fee equal to 2% of the net sales reported for that period, rounded to 2 decimal places, rounding half to even, within 30 days after the period ends. The fee is fixed at that rate for the term of this Agreement unless the Agreement is amended.Agreement hash: sha256:616dac2fd52f336580dec71a1d1f00ccabed5b3ef0e14b15bb0761a453218623
Proof, not trust
Every Term, Agreement, Event and State is identified by the SHA-256 hash of its canonical JSON (RFC 8785). The same content gives the same hash on any machine, in any language.
Live · computed in your browser
This is the full master agreement from examples/conventional. The page hashes it with the same algorithm the Python interpreter uses.
Use a Decimal like 0.02: digits, an optional point, no exponent.
Agreement hash
Signatures and chains
Each Event is signed over its hash and names the State before it. This is the real master chain, then the repo's fault example.
Its hash becomes the ChainId, the agreement's permanent identity, even through later amendments.
The supplier's accept names the State it saw in prev. Two events can't both follow the same State, so there's never a fork to argue over.
After nine events, every copy reaches sha256:f7ca8ea5…. What's owed comes from up derive, never from a stored balance.
In the supplier ERP's copy, the fee rate was changed from 2% to 1.5% after signing. The genesis event's hash changes, the aggregator's signature fails, and that copy stops at event #0.
Confidential by construction
A Seal is a salted SHA-256 commitment that stands in for a private value. Hashes and signatures cover the sealed form, so a holder who sees nothing reaches the same verdicts and the same State hashes (axiom A10).
Agents under Mandates
A Mandate gives an agent its own key and bounds on every value it may set. Out-of-bounds actions are invalid on arrival (axiom A9). From the generative example, where one GPO is run entirely by an agent:
"scope": { "kinds": ["propose", "accept", "attest"], "roles": ["aggregator"], "terms": { "UP:Admin-Fee": { "payer": {"in": ["supplier"]}, "rate": {"max": "0.03"}, … } } }
What you could build
Concepts, not products. Each one only needs the language and the reference interpreter, and each works with every counterparty that speaks it.
Compose proposals from the Term library and negotiate only the parameters. The counterparty sees a value diff, never a redline.
See which members are live, on which tier and price, right now. Every row is recomputed from the chains, never from a roster file.
Admin fees computed from reported sales and the signed rate, matched against payment attestations. Close without the true-up spreadsheet.
The moment an agreement executes, open the implementation plan with every term already structured: tiers, reporting cadence, fee schedule, notice periods.
An agent with its own key and a Mandate. It can join agreements and attest within bounds, and anything outside them is rejected by every evaluator.
Push derived contract prices into the ERP and flag drift before it becomes a chargeback dispute. Existing EDI keeps running side by side.
Renewal dates, opt-out windows and notice deadlines computed from each agreement's Window and Exit clauses, for every counterparty at once.
Describe the contracts you already have by their document hash, without renegotiating. Start getting computed obligations on day one.
Hand an auditor the bundle and only the disclosures they need. They replay the history offline and reach the same verdicts.
Status, renewals and obligations across every agreement you're party to, with each counterparty's confidential values left sealed.
Build on it
The spec is the language. The Python interpreter is a reference you can use, port or replace. If your code produces the same hashes and verdicts, it speaks Universal Paper. Nobody has to grant you access.
$ up validate examples/conventional/bundle.json chain 0: Master agreement (hypothetical) id sha256:47b4b79c2b8e07588427250c27c170241a171cd1e86dded047828518e31d78be [ok ] #0 propose 2026-12-01T15:00:00Z [ok ] #1 accept 2026-12-05T10:00:00Z … state sha256:f7ca8ea5183a39b1e6a1388dcc33cf0b66e9eb1b91b00df8972bca6548a95144 status at latest event: active Every event is valid. $ up derive examples/conventional/bundle.json --at 2027-04-30T00:00:00Z # status, tiers, prices, obligations $ up simulate examples/conventional/bundle.json my-hypothetical-events.json # what-if; Mandate limits still apply $ up render examples/confidential/bundle.json --chain 0 --hashes-only # the contract text, sealed values hidden $ up trace examples/conventional/bundle.json -o conventional.trace.json # every check, as a trace file
import json
from universal_paper.engine import Bundle, Evaluator
from universal_paper.canon import content_hash
from universal_paper.report import snapshot
bundle = Bundle(json.load(open("examples/conventional/bundle.json")))
ev = Evaluator(bundle)
chain_id = content_hash(bundle.chain_list[0][0]) # ChainId = hash of the genesis event
for step in ev.run(chain_id):
print(step.index, step.event["kind"], "ok" if step.accepted else step.reason)
print(ev.status(chain_id, "2027-04-30T00:00:00Z")) # "active"
report = snapshot(ev, "2027-04-30T00:00:00Z") # statuses, tiers, prices, obligationsThe JS tab is the exact code this page runs for the fingerprint lab. It matches the Python interpreter's hashes for the example agreement.
Conformance
There's no certification program and nobody to ask for permission. The example traces are the test vectors: every evaluator has to reach the same verdict on every event and the same State hash at every step.
The complete reference interpreter and CLI used to generate every trace on this page.
Canonical JSON plus SHA-256. It reproduces the example agreement and all 16 Term hashes, but it doesn't verify signatures.
Port it to Go, Rust, Java or TypeScript, or into a CLM or ERP. If your verdicts and hashes match the traces, every counterparty can rely on them.
| Test vector | Scenario | Every evaluator must conclude |
|---|---|---|
| conventional.trace.json | Tiered master, two members joining, monthly reports, fees and a tier change | All events valid. Master reaches state f7ca8ea5… |
| conventional.tamper-supplier-fee | The supplier's copy had its fee rate changed after signing | Rejected at event #0. The aggregator's signature doesn't verify |
| conventional.tamper-aggregator-missing-signature | The supplier's signature on its acceptance is missing from one copy | The acceptance carries no signatures. The master stays proposed |
| conventional.tamper-member-backdate | A tier attestation was re-signed with an earlier date | Rejected as backdated. Past states can't be altered |
| generative.trace.json | A GPO run entirely by an agent under a Mandate | Two out-of-bounds agent actions rejected (A9). Everything else valid |
| overlay.trace.json | A 2024 contract described by its document hash, without renegotiation | Valid. Duties start only from the overlay's signing |
| confidential.trace.json | Every price, rate and amount sealed. The observer has no disclosures | Same verdicts and same State hash at every step (A10) |
cd universal-paper pip install -e '.[test]' # or: export PYTHONPATH=src
up validate examples/conventional/bundle.json
up derive examples/conventional/bundle.json --at 2027-04-30T00:00:00Z
up render examples/conventional/bundle.json --chain 0 python -m pytest
Specification
Universal Paper is a working draft. Here's exactly where it stands, what the documents cover and what is still undecided. Nothing on this page is final until the steward's review closes these questions.
An illustrative path. No stages or dates have been set.
From DESIGN_NOTES.md §6
Questions
Short answers, with the part of the spec that backs each one.
No. There's no ledger, token, mining or global network. Each agreement has its own short chain of signed events, held by the parties to it. Hashes link the events and Ed25519 signatures authorize them, so any copy can be checked offline.
spec/04-inference.md · axiom A3
With the parties. A bundle is plain JSON that you can store in your CLM, ERP or a file share. Hosted services can store and route bundles for you, but nobody needs one to verify, because every evaluator recomputes the same verdicts from the same events.
spec/08-neutrality-charter.md: products built on the language may not claim to be required to use it.
Never. Terms have typed parameters with no default values, so the library can't suggest a price, rate or period. The parties supply every number. The language standardizes process, not economics.
axiom A6 · spec/08-neutrality-charter.md
No. UP:Overlay describes a contract you already have by its document hash, so you get computed obligations on day one while the signed PDF stays the governing document.
spec/06-terms/UP-Overlay.md · examples/overlay
A private value can be replaced by a Seal, a salted SHA-256 commitment. Hashes and signatures cover the sealed form, so a holder who sees nothing still reaches the same verdicts and State hashes. You disclose values only to the parties who need them.
axiom A10 · examples/confidential
Yes, within limits. A Mandate gives an agent its own key and bounds on the kinds, Roles, Terms and values it may use. An out-of-bounds event is invalid on arrival for everyone.
axiom A9 · examples/generative
Side by side. The mapping guide shows how rosters, eligibility files and the X12 845, 844, 849 and 867 sets correspond to events and projections. The main gap in v0 is the distributor Role, and it's documented.
spec/07-mapping-guide.md
Uppercentile is the current steward provisional. The neutrality charter commits the steward to publish its affiliations, keep the language value-neutral, and transfer stewardship to a neutral body once the language has users across segments. Governance details are still open questions.
spec/08-neutrality-charter.md · DESIGN_NOTES.md §6
Universal Paper was created by Uppercentile, which offers it to everyone for free under open licenses: the specification and Term library are CC BY 4.0, the reference code and schemas are Apache-2.0, and the example agreements are CC0. No account, fee or license key is ever required. Anyone can implement it: if your code produces the same hashes and verdicts, it speaks Universal Paper. Licenses in detail.
Universal Paper
Open language, open reference code, no gatekeeper. Pick an example, run the validator, and build the first app your team wishes it had.