A carrier for value.
Settlement-agnostic. Energy-attributed. No off switch.
The smart byte is not money. It is a vesicle — a content-addressed, signed envelope that carries any cargo, with provenance and energy cost intrinsic, replicated by deterministic lockstep, owned by no one. TCP/IP for value.
Anatomy
One object. Five fields.
The smart byte has exactly one schema. Everything an application can do with it — issue it, transfer it, redeem it, audit it — is expressed by reading and appending to these five fields. No accounts. No balances. No special cases.
The whole byte is content-addressed: change any field and the identity changes with it. Holding the byte is sufficient to verify everything in it.
Identity
Content-addressed: the byte's identifier is the hash of its origin attestation. It never changes. Anyone holding the byte can recompute the hash and verify it — no registry call, no trust relationship.
Provenance
The issuer's signed origin attestation: who issued it, against what reserve or authority, with what authorization. The byte's birth certificate — carried with it for the rest of its life.
Ownership chain
Git-style history: each transition includes the hash of the prior history, so the chain is content-addressed end to end. Every transition is signature-bound. No double-spend at the protocol level — the chain forks visibly or not at all.
Cargo
The application-layer payload — opaque to the substrate. It must be deterministically serializable so every node hashes it identically. There is no privileged cargo type: money is one, not the primitive.
Joule cost
Two parts: measured_microjoules read from hardware counters, plus estimated_microjoules from a deterministic model. Cumulative over the byte's life. Divergence between the two is itself a signal.
What the schema deliberately does not carry.
- No wall-clock time — only a frame number. Lockstep simulation has no clock to disagree about.
- No protocol-level fees — the substrate charges nothing. Services charge; the protocol doesn't.
- No account balances — state is per-byte, not per-account. There is no account.
- No mutability — you append to the history; you never edit it.
- No binding of cryptographic identity to legal identity — that's a layer-2 attestation service, not a field of the byte.
The Vesicle
The carrier is not the cargo.
A vesicle, in biology, is defined by transport behavior — it forms, traverses, fuses, releases — not by what it holds. The same machinery moves neurotransmitters, hormones, immune signals, cellular waste. The smart byte is the same: content addressing, signature-bound transitions, deterministic lockstep replication, a two-part joule cost — and total agnosticism about cargo. Money is one cargo type, not the primitive.
- Forms — an issuer signs an origin attestation; the hash is the byte's identity.
- Traverses — signature-bound transitions append to a content-addressed history.
- Replicates — a cluster of nodes runs the same lockstep simulation, frame by frame.
- Carries its cost — measured and estimated joules accumulate over the byte's life.
- Fuses / releases — a redeeming party verifies the chain and settles against the cargo.
- Whether the cargo is a dollar, a kilowatt-hour, a vote, or a credential.
- Which regulatory class the cargo belongs to — that's a descriptor the issuer attaches, not a privileged kind.
- Who the holder is in legal terms — only that the transition was signed by the prior holder.
- What application reads the cargo on the other side.
- Everything matching, clearing, and trust-signaling layers do with it — those build on the carrier; they aren't part of it.
USD bytes
Regulated stablecoin issuers, with reserve attestations carried in provenance.
Joule bytes
Community solar, utility cooperatives, rooftop systems — energy as a transferable claim.
Compute-hour bytes
A bounded entitlement to run work, attributable and redeemable.
Storage / bandwidth bytes
Capacity commitments that move between parties without re-papering.
Kcal / water / fabrication-time bytes
Physical resource units, issued by whoever holds the resource.
Governance-vote bytes
A voting weight that can be delegated, with the delegation chain visible.
Attestation bytes
KYC / age / credential / sanctions-status, signed by the attesting authority.
Reputation bytes
A standing earned and carried, redeemable where it's recognized.
Sensor-reading bytes
A signed measurement at a frame, with provenance to the device.
Output-claim bytes
A fractional claim on production — a slice of what something makes.
Conditional-claim bytes
Futures, options, escrow analogues — payoff bound to an attested condition.
TCP/IP is a vesicle.
The internet's transport layer carries HTTP, SMTP, FTP, DNS — none of them privileged at the IP level. The same packet machinery moves a web page, an email, a file, a name lookup. The smart byte makes the carrier/cargo separation total: an open, application-agnostic carrier replaces a bundled, vertically-integrated one, and the layers that do something useful with value — matching, clearing, signaling trust — build on top of it instead of inside it.
Consensus
Lockstep. Federated. No miners.
Every byte's cluster of nodes runs an identical state machine, one frame at a time. A frame commits when a Byzantine supermajority agree on the post-frame state hash — that's the whole mechanism. There is no Sybil problem, because cluster membership is signed, which is why it costs orders of magnitude less energy than chain consensus. The substrate scales by federating bounded clusters, not by growing one.
Lockstep deterministic simulation
Every node in a byte's cluster runs the same state machine one frame at a time — the pattern that has run real-time multiplayer games for decades. There is no clock to disagree about: a frame is a number, not a timestamp.
Byzantine supermajority commit
A frame is committed when more than two-thirds of the cluster agree on the post-frame state hash. The cluster tolerates up to a third of its nodes being faulty or malicious. No proof-of-work, no proof-of-stake, no leader, no mempool, no fee market.
Scales by federation, not by growth
The substrate is many bounded clusters — each roughly 8 to 32 nodes — connected by a gossip overlay, the way the internet federates roughly a hundred thousand autonomous systems. You add capacity by adding clusters, not by enlarging one.
Per-byte content-addressed history
A byte's history is owned by the byte itself. A cluster need only be trusted for a byte's current state; the deep history is independently verifiable by anyone holding the byte — auditable with the cooperation of no one.
There is no race to waste energy, because there is nothing to win by spending it: cluster membership is signed, so identity isn't bought. The cost figures are below the energy cost of proof-of-work or proof-of-stake consensus by the orders of magnitude shown.
A cluster is trusted for now. The byte is trusted forever.
Because each byte carries its own content-addressed history, a cluster's only job is to agree on a byte's current state. The chain of transitions that got it there is verifiable by anyone who holds the byte — without asking the cluster, without asking the issuer, without asking us. That is why the substrate can be many small, bounded clusters rather than one large one: trust is scoped to the present, and the past is self-evident.
The Spec
A treatise, not a manifesto.
The smart byte is documented as an argument you can check, not a slogan you have to take. It has three layers: a treatise that establishes why; a conformance specification that fixes the wire formats; and a strategic context that places it in the world as it is. The spec text is permissively licensed. The conformance vectors are published. It is unforkable in the way TCP/IP is unforkable.
The Treatise
Parts I–III in full, IV–VII previewed. Part I: why money exists and what the institutional middle actually does. Part II: the substrate, end to end — schema, lockstep consensus, content-addressed history, cluster topology, BFT commit, the dissent log, live issuance, persistence, transports. Part III: the security engineering — the standard concerns every digital system has, addressed the standard way. Permissively licensed.
The conformance specification
Byte-level wire formats — the document that ships alongside the reference implementation. The protocol's identity lives here, in the conformance vectors and the content-addressing, not in any brand. Test vectors are published so any implementer can verify canonicity without a trust relationship with the authors.
The strategic context
Why the substrate makes sense in the world that exists in 2026: fragmented payment clusters with a real cross-cluster gap; energy as the binding constraint on compute-heavy rails; and the host-technology pattern that has recurred through payment-rail history.
The protocol's identity is its conformance vectors.
Anyone can implement the smart byte — that's the point of publishing the conformance suite. But an implementation either produces the canonical bytes or it doesn't, and the test vectors say which. There is no brand to capture, because the brand was never where the protocol lived. It lives in the content-addressing: the same byte, hashed the same way, by every conformant implementation. That is what "unforkable in the way TCP/IP is unforkable" means — you can run a different stack, but you can't run a different byte.
Services
The substrate is open. The services are how we sustain it.
Transaction Science doesn't own the smart byte — the protocol is everyone's. What we run is the commercial layer around it: managed clusters, issuer tooling, cross-cluster gateways, the conformance suite, the registries. The moat is at the edges, not in the protocol. Customers are fintechs, stablecoin issuers, cooperatives, exchanges — anyone who wants to emit or consume smart bytes.
Managed cluster operation
Run a cluster — operate the nodes, handle admission, keep the lockstep healthy — for parties who want to participate in the substrate without operating infrastructure themselves.
Issuer tooling
Mint cargo-bytes with proper provenance and regulatory-class descriptors; manage redemption and reserve attestations. The issuer SDK and the operational scaffolding around it.
Cross-cluster gateway
Move bytes between clusters; bridge to external rails at the boundary. The hop between bounded clusters, run as a service so issuers and holders don't have to.
Conformance suite
The test vectors and a hosted runner, so any implementation can certify itself against the canonical wire formats — without a trust relationship with the authors.
The registry
Operate the cargo-type and issuer registries; publish and version them. The shared lookup that lets a holder know what a descriptor means and who an issuer is.
Settlement — the first institution running on the substrate
Settlement (settlement.science) is the first regulated financial institution running on the substrate — as an issuer and consumer of smart bytes. It is the reference deployment: a real institution emitting and redeeming cargo-bytes, with provenance and energy cost carried on every one.
Anyone can implement the smart byte. No one can capture it.
We don't own the substrate. We steward it — publishing the spec, shipping the reference implementation, running the services that keep it healthy. The protocol's identity is its conformance vectors and its content-addressing, and neither of those is ours to take back. If we stopped tomorrow, the bytes would still hash the same. That's the design.
