Envelopes
The envelope is the framework's value primitive — on the same footing as the kernel and the clock. It is how computation becomes value. Credits are the fuel that goes in; the envelope is the one thing of value that comes out. Every charged compute mints exactly one envelope: an atomic, signed, movable record of a real piece of work.
Keep two words apart, and the rest of the economy follows:
Credit — the fuel
What a call costs to run, metered before it executes. You spend credits to compute. See credits & metering.
Envelope — the value
What the work mints: one signed, movable coin per compute, carrying the value of the work it represents. One compute, one envelope.
What sets an envelope's value
An envelope isn't priced by a quote. Its value is set by the work it represents — how much compute the operators actually took, and how precisely the result landed inside the framework's ≤0.1% bound:
cost already grows with operator count and cross-domain coupling; quality rewards how far inside
the bound the answer sits. So a heavier, more precise compute mints a more valuable envelope with no
extra rule — and the 2× cap keeps supply bounded. A result that lands exactly on the bound mints
V = cost; a perfect-precision result mints V = 2 × cost.
Who owns it — the funding decides
The envelope is atomic: it is the whole coin, never split. Where it lands depends only on how the compute was funded.
Paid compute → you
The whole movable envelope mints to you. It's yours to keep, transfer, carry, or redeem.
Free compute → the Foundation
The whole envelope mints to the Foundation — the domain's commons. Your free daily claim buys results, not transferable value.
Either way, the computing machine is stamped as the minter — and that stamp, together with the machine's Ed25519 signature and the seal on its audit chain, is the light proof: soulbound provenance of who did the work. The coin can move; the light proof never does. Hand an envelope to someone else and the record of who computed it still points, permanently, at your machine.
What an envelope carries
Every envelope is one immutable row on the machine's tally:
A deterministic id
An id and hash over the machine, the Zeqond, the result digest, and the operator chain — so identical work always names the same envelope.
Value & funding
Its value V, and the funding behind it — free-funded or paid-funded — so ownership is always reconcilable.
Minter & owner
The soulbound minter (who computed it) and the current owner (who holds it) — the same until the envelope is transferred.
Home origin
The chain that issued it, its sole serializer for life — the only chain permitted to reassign it.
Spend sequence
A strictly monotonic per-envelope counter, bumped under the same row lock as every ownership change, so the serializer's ordering is auditable.
An Ed25519 signature
Signed by the node key, with the compute's ZeqProof as its proof value — verifiable by anyone, offline.
What you can do with one
Prove
A portable, re-verifiable receipt that a specific compute happened, to a specific precision, at a specific Zeqond.
Transfer
Whole-envelope ownership moves with a single call — private by default, idempotent, audited on both chains. Only the home origin may reassign it.
Carry
Export it to a portable, PIN-locked bearer envelope that verifies itself offline and settles single-spend at home.
Redeem back into compute
Convert an envelope back to compute credits at face value. A one-way valve: value can leave the envelope layer into compute, but compute funded that way mints no new envelope — so it never loops.
Read next
- Credits & metering — the fuel that goes in, and what a call costs.
- Bearer envelopes — carry an envelope offline as a self-verifying file.
- The tally — the ledger every envelope is written to.
- Transparency — the whole envelope economy, published live.