Messages between programs at the speed of memory. One fixed 128-byte message, read straight from shared memory: nothing copied, nothing to unpack, no waiting on a slow reader.
Built for the systems where a microsecond is the margin.
The explainer
Two and a half minutes on what a transport protocol is, why the old ones hold AI back, and what Pulse Mesh does differently.
In plain terms
Almost everything now runs as many programs that must pass messages to each other: the parts of one application, the services of one company, the agents of an AI system. The usual ways of passing messages copy the data several times, turn it into text and back, accept messages of any size, and keep no reliable account of who sent what or whether they were allowed to. That costs time on every message, and leaves nothing to audit when something goes wrong.
Every message has one fixed size and one layout, the same everywhere, so a reader knows exactly what it will get before it reads. Messages sit in memory that every reader sees at once, so nothing is copied and a writer never waits for a slow reader. Anything larger travels as a sealed envelope addressed by a fingerprint of its own content, so the same content has the same address in every language. And every message carries who sent it, where it sits in the chain, and the time, as part of the format rather than as an add-on.
Speed you can predict, because the cost of a message does not depend on its size or on how many programs are listening. A record you can check, because the sender, the order and the permission travel with the message itself. And a written standard that others can implement and be tested against, so the pieces of a system, and the companies that build them, agree on the bytes. That is the ground a governed system of many programs can stand on.
The primitives
The whole surface fits on one page. Everything else in Pulse Mesh is built from these two message shapes and the shared memory that carries them.
The small message: always 128 bytes, always laid out the same way, sized to the two cache lines a processor reads at once. Because the size never changes, a reader knows exactly what it will get before it reads, and the layout is checked when the software is built rather than trusted while it runs.
The large message: any length, in one canonical byte layout, addressed by a fingerprint of its own content. The same content gives the same bytes and the same address in every language, so two programs can agree they hold the same thing without comparing it. Not merely compatible: the same bytes.
Messages are written into a ring in memory that every reader can see at once. A writer never waits for its readers, and a reader that catches a message mid-write notices and reads it again. Delivering to a thousand readers costs the writer the same as delivering to one.
Architecture
Every message is a Pulse: a fixed record shaped to the way processors move memory, so that two programs on different sockets never fight over the same cache line. The ring wraps each slot in a sequence lock, a counter that lets a reader tell whether it saw a whole message or a half-written one, without ever stopping the writer.
Delivery to many readers is one write into the slot and one tick of its counter, however many are listening. The broadcast registry keeps each reader’s place padded apart, so readers do not slow each other down.
The standard
The Pulse Mesh Standard is published as a working draft (document SF-PMS-STD-001) in the language standards use, and it separates what any implementation must do from what the reference implementation happens to do. Its fourteen requirements fall in three groups.
Wire format · PMS-1 to PMS-6
The shape of a message and the memory it sits in.
Cryptographic chain · PMS-7 to PMS-10
Who sent it, and in what order, provably.
Governance integration · PMS-11 to PMS-14
Messages that carry the permission they run under, across the boundaries between organisations.
The appendices carry the exact byte layout, the registry of envelope types, and the tests each requirement is checked against.
Conformance
Each level is a distinct tested state, not a marketing tier. A mark belongs to an implementation, never to a company, and an implementation claims only the level it was granted.
Pulse Mesh Compliant™
Wire format
The message format and the shared memory behave exactly as the standard says, and anyone can check it.
Pulse Mesh Certified™
Wire format + cryptographic chain
Adds the chain: who sent each message and in what order, proven by cryptography rather than by the sender’s word.
Pulse Mesh Certified+™
Every requirement, every tier
Adds governance: messages that carry their permission, dispatch that checks it, and transport across the boundaries between organisations.
No certification programme is active yet. The requirements are published for the community to refine, and the marks are administered by Sovereignty Foundation Inc.
Beyond the reference
The standard is written to be built, and the implementation is written to be run. Three doors lead out of this page.
Where it runs
Five fields
Trading, robotics, agent dispatch, training clusters and mesh compute: why each fits, what it is measured against, and where it stops helping. See where it runs →
Pilots
On your stack, on the record
A pinned release inside a real deployment, with the Foundation alongside, ending in a record anyone can check. The pilot programme →
Programmes
Three places, one sequence
Where the proving happens, where the working group forms, and how a result moves between them. The programmes →
The reference implementation is documented in full, from a first encoded envelope to a daemon run as a service: the documentation.
Many builds
The standard exists so that anyone can implement it independently. The reference implementation is one build of it, not the definition.