Where it runs

Fast where messaging is the bottleneck

Pulse Mesh wins wherever many readers share one stream, tasks are short, or signals are frequent: the places where passing the message costs more than the work. These are the five fields where that shows most, with what each is measured against and where it stops helping.

Five fields·Limits stated·Numbers on the Proving Grounds
writerone ringstrategies

01 · Trading

Market data to every strategy on the host

One feed handler, many strategy processes, all on the same machine. Every strategy needs every tick, and none of them may hold up the feed or each other.

Why Pulse fits

The feed handler writes each tick once, into memory every strategy reads. Adding a strategy adds no work for the writer. A strategy that falls behind is told exactly what it missed, and the rest carry on. Each strategy is its own process, so one crash does not take the others with it.

Measured against
The LMAX Disruptor and Aeron, the tools trading desks already use for this path.
The limit
On median latency the best in-process tools remain level with it or slightly ahead; the gain is in the tail and in keeping strategies in separate processes. So far it has been measured on one Intel machine type.
A pilot would
Run a fan-out stage beside an existing feed handler, measured with the ring's own counters and sealed as a record.
buslidarcameraimuplanningperceptionsafetylogging

02 · Robotics

One sensor, every subsystem, at once

A robot or edge computer where lidar, camera and IMU frames feed planning, perception, safety and logging simultaneously. The more nodes that listen, the harder the usual buses work.

Why Pulse fits

Delivery to many readers costs the writer one write, however many are listening, so the advantage grows with the number of subscribers: exactly the shape of a robot with many nodes reading one sensor. Every message has a size known before it is read, which suits control loops that must bound their work.

Measured against
iceoryx2, the zero-copy middleware built for this job.
The limit
Measured on server processors, not yet on embedded boards. Robotics frameworks such as ROS 2 would need an integration layer before a team could drop it in.
A pilot would
Put the bus under one real sensor stream on the target hardware, with the loss and lag counters as the record.
schedulerworkers

03 · Agent dispatch

Thousands of small tasks, no idle workers

Agent swarms making many short tool calls, reinforcement-learning rollouts, simulation sweeps, and the event traffic inside AI serving engines: routers, cache events and worker coordination.

Why Pulse fits

When tasks are short, the time spent handing them out decides how busy the workers stay. Pulse hands out work at memory speed, so workers spend their time on tasks rather than waiting for the next one. The same one-write fan-out carries events to every worker in a serving engine without dropping any under burst.

Measured against
Ray for task dispatch; ZeroMQ and NATS for event fan-out, as used in today's serving engines.
The limit
Once each task takes tens of milliseconds, dispatch is no longer the bottleneck and the gain disappears. Inside a single serving engine's loop, messaging is not what limits it.
A pilot would
Swap the dispatch layer of one rollout or agent workload and compare worker utilisation on the same hardware.
every rank hears at once

04 · Training clusters

Know a rank has died before the GPUs sit idle

A large training job where one dead or hung node stalls thousands of GPUs until something notices. Default setups wait on long timeouts, and fast heartbeats strain the central store that tracks them.

Why Pulse fits

Each process broadcasts a small heartbeat that every other process reads directly, with no central store in the path. A missing rank is noticed almost at once, at a cost of a fraction of one core per process, without false alarms.

Measured against
The failure detection PyTorch distributed training uses by default.
The limit
Detection is the first step; restarting or re-sharding the job is the training framework's work. Across machines the heartbeat rides the Pulse wire, which needs encryption before it crosses a network you do not control.
A pilot would
Run the heartbeat alongside an existing training job and record how long each failure took to surface, against the framework's own detection.
desktopregion aregion bregion c

05 · Mesh compute

One message model from a desktop to every region

Compute that starts on a desktop or an edge box and spills into whichever cloud region is cheapest, or a hybrid of on-premises machines and cloud.

Why Pulse fits

The same Pulse travels over the local ring or over UDP, and reaches out through a home router on a single socket. A job written for one machine runs across several without changing its message format, and the work is split and gathered with nothing lost on the way.

Measured against
gRPC, the usual choice for dispatching work between machines.
The limit
The gains across machines are modest so far, and only the work, not the data each shard needs, has moved with the job. The UDP leg needs encryption and authentication before it carries anything outside a trusted network.
A pilot would
Split one batch workload across a local machine and two cloud regions, and record completion time against a single region.

Also

Two more places it fits

Services on the same machine

Co-located services that talk over localhost sockets or gRPC can share memory instead and stop paying for a network stack they never leave. The comparison flatters any shared-memory transport, so the real question is adoption: the daemon and clients exist for Rust, Python, Node, C and WebAssembly.

Audit trails and provenance

Every payload is named by the BLAKE3 hash of its content, so integrity checks, deduplication and caching come with the format, and an optional hash chain defends against replay. It suits regulated pipelines and anywhere the record of what ran matters. Its speed is measured; the product case is still to be built.

Where it doesn’t help

The honest edges

The pattern is consistent: Pulse wins where messaging is the bottleneck, and nowhere else. These are the cases where it is not.

Language model serving

An engine such as vLLM spends its time in the model, not in passing messages, so a faster transport shows no gain inside it.

Coarse tasks

When each task runs for tens of milliseconds or more, dispatch is a rounding error and any reasonable queue will do.

One sender, one receiver

For a single pair on one machine, sockets are close enough that few teams would switch for latency alone.

Every comparison named on this page is run on the same hardware, through the same harness, against the tool that field already uses. The figures, and the challenge to refute them, live on the Proving Grounds.

Next

Run it on your stack, on the record.

A pilot puts an identified release inside a real deployment and ends in a sealed record the working group can build on.

Apply to pilot →How the programmes connect