Semantos is the infrastructure layer between intent and on-chain settlement — cell-based, identity-native, blockchain-settled. Right now, the truth about your business is distributed across systems that don't agree, owned by platforms that profit from your dependency, and too fragile to survive the next API change. Semantos is the substrate — the layer below every platform — that changes the ground state.
Across any workflow involving more than one system, truth exists in multiple copies — each drifting from the others. A job dispatched to a contractor exists as a ticket in the PM tool, a draft in the accounting platform, an unread email in someone's inbox, and a push notification on a phone. Each is a different version of what happened. There is no canonical record. Reconciliation is manual, expensive, and usually wrong after enough time passes.
And when two parties need to coordinate — a business and a contractor, a landlord and a tenant, a company and a regulator — the entire coordination infrastructure has to be rebuilt from scratch. Custom integration. Custom trust model. Custom reconciliation logic. Every time.
Every system boundary destroys context. "Urgent — tenant has no hot water, please fix before 5pm" becomes a priority-3 ticket, becomes a work order type code, becomes a database row with a status integer. The urgency is gone. The causal chain — who said what, what was agreed, who authorised the spend — dissolves at every handoff.
Audit trails are owned by the platforms that create them. Accessible only while your subscription is active. Siloed behind their data model. When something goes wrong — a dispute, a liability question, a compliance audit — you can prove what a platform recorded. You cannot prove what actually happened.
Every useful platform you adopt is a sticky platform. It builds value by accumulating your data, your relationships, your workflows — in its own model, not yours — and then becomes the chokepoint. The more you depend on it, the more it can charge. Your customers live in a CRM. Your finances live in an accounting platform. Your staff live in an HR tool. Your org structure lives in an identity provider.
You can export a CSV. You cannot take the meaning. Leaving costs more than staying. The platform doesn't hold your data hostage — it holds your workflows, your history, and your team's muscle memory. Which is worse. And the only exit is a year-long migration into another platform with the same problem.
These aren't software problems you can integration-test your way out of. They're ground state problems. The fundamental layers are missing: a shared representation of what things mean that no platform owns, an audit trail that belongs to every participant equally, identity that travels with you instead of living in someone else's database, and economic commitments that are executable rather than merely promised.
Every integration you build, every audit you reconstruct after the fact, every platform migration you survive — these are symptoms of absent infrastructure. The question isn't which platform to trust. The question is: what does a layer below platforms look like?
No data silos. No platform lock-in. No integration tax. Contextual identity that travels with you, an audit trail nobody owns, and economic commitments enforced by consensus — not promised in a PDF.
Every unit of meaning is a 1024-byte cell. It knows its type, its author, its history. It can travel anywhere — browser, server, microcontroller — and be verified on arrival. Memory, runtime, and network all use the same format.
Values have flow constraints baked in. A payment-channel state can only be consumed once, like cash. A certificate must always be used, never silently dropped. The policy VM enforces this before broadcast — and on-chain, BSV's UTXO double spend protection enforces it at consensus. Two independent guarantors of the same type system.
Append-only records where every change is a cryptographic patch. Nothing is deleted. Every state is provable. The audit trail is a first-class structure secured by a hash chain — not a logging afterthought.
Business rules expressed as code, compiled to bytecode, run inside the kernel VM. The rules travel with the data — not with the server. A Lisp surface makes rules readable; ANF normalisation makes them provably correct.
OP_RETURN data — but as spendable on-chain UTXOs. The cell data is embedded in the locking script. The output exists on-chain, unspent, until the cell is consumed.
Hats aren't just for individuals. Every entity that needs to act, delegate authority, receive assets, vote, or be held accountable maps to a hat tree. The root cert is the entity's identity. Every role, every right, every limit is a child hat with scoped capabilities. Constitutions, trust deeds, articles of incorporation — all become executable policy rather than documents people argue about later.
Governance is not bolted on — it is built into the type system. Proposals, ballots, votes, stakes, and vetoes are all typed cells with linearity constraints. A vote is LINEAR: cast exactly once. A ballot is AFFINE: can be abstained but never duplicated. The kernel enforces these constraints before anything reaches the chain; BSV's double-spend protection enforces them again at consensus. Two independent layers, same guarantee.
Your contacts are their root certs. You establish an ECDH edge between your key and theirs once — a shared secret derived locally, never transmitted. From that point, every message between you is end-to-end signed and verifiable.
The cell-engine compiles to two WASM profiles optimised for different deployment targets — from a browser tab to a federation node.
Any system that speaks BRC-100 can verify, sign, and accept payments from a Semantos client — and vice versa. It is an open standard, not a Semantos lock-in. Every message between nodes is a BRC-100 signed bundle: a CBOR payload wrapped in a verifiable envelope.
prevStateHash, peers can detect missing cells on arrival — even over UDP. There is no reliable connection to maintain.
A federation node running the full Semantos stack — cell engine, Pask learning kernel, relay, and NLU pipeline. Acts as a peer, not a server. No central authority. Brain nodes form the backbone of the UDP multicast mesh.
Cross-platform Flutter apps for iOS, Android, and desktop use the 29 KB embedded WASM with host-provided crypto. The platform's own cryptographic APIs are injected via WASM imports — giving full signing and verification capability in a minimal footprint.
IoT devices and microcontrollers use the same 29 KB embedded WASM. Hardware crypto engines (ESP32, STM32, nRF52) provide secp256k1 and SHA-256 via the WASM import interface. A sensor in the field is a first-class Semantos peer — signing its own cells.
Brain nodes are peers. They relay cells between clients, anchor to BSV, run the Pask learning kernel, and serve as entry points to the mesh — but none of them is authoritative. If a node goes offline, the mesh routes around it. The contacts book PKI means nodes authenticate each other without any central registry. Add a node, and the network grows. Remove one, and nothing breaks.
You write domain logic against the semantic object API and register handlers in the policy engine. The cell format, linearity, hash chain, hat-based identity, WASM wallet, and blockchain anchoring are already there. You don't rewrite the substrate — you extend it.
The anchor cell on BSV is what makes "atomic" true. It lands as a spendable on-chain UTXO — not inert data, but a live object whose existence and consumption are governed by Bitcoin's consensus rules. Both chains can independently verify that the swap occurred — or provably did not — by reading the UTXO state. No trusted intermediary. No oracle. The kernel writes the verdict; Bitcoin's double spend protection enforces it.