Ambient intelligence means cognition dissolved into the environment — the devices around you reasoning together instead of shipping logs to a datacentre. That needs three things nobody had assembled. LatentMesh builds them, and tests them honestly.
When one AI agent needs something from another, the message goes up to a datacentre and back down. That works beautifully — right up until the connection doesn't.
No towers, no WiFi, no satellite you can afford — and everything cloud-dependent simply halts. That's a hard edge on where autonomous systems can go, and most of the planet sits on the wrong side of it.
Give each one a cheap radio — LoRa, a ham band, Bluetooth, even audio tones through a handheld — and they reach each other directly. No tower. No subscription. No company that can switch you off.
A long-range radio gives you a few hundred bytes per message, and strict limits on how often you may send. We measured the real ceiling on Meshtastic hardware: 227 bytes — not the 233 the spec implies.
A conversation log has no chance of fitting.
Each agent sends a small envelope instead: what changed, how much it matters, which facts must arrive exactly, and a fingerprint so the receiver can tell whether its picture has drifted out of step.
Radios lose line of sight and batteries sleep. Messages wait and deliver when the node returns.
And anything failing its checksum, signature or replay window is dropped — never waved through because it looked close enough.
Ambient intelligence needs machines to exchange thought rather than text, transports that reach everywhere, and a way to ensure shared thought can't corrupt the collective. Two of those are built. The third is honestly unfinished, and we say which is which.
Compact envelopes travel over Meshtastic LoRa — validated against real meshtasticd firmware, which is how we found the true 227-byte ceiling rather than trusting the protocol's nominal 233. Then over bulletin boards for store-and-forward, and into a fleet API with signed device identity.
An edge earns authority only by measured causal benefit against decoy controls — never by claiming confidence. Ambient intelligence without this is an ambient attack surface. With it, links earn trust the way certificates do.
Two models' internal spaces can look geometrically aligned and still share no meaning. That kills the cheap-translator assumption, and it's why real translators get trained and measured here rather than assumed.
Where it's heading is already written down: verified knowledge replicated across a fleet (ADR-025), only causally-proven edges federating while receivers re-verify — hints, never authority (ADR-026), and a lower-trust delivery lane as fallback (ADR-027). A verified-edge message prices out at ~140 bytes — arithmetic from field widths, not yet measured against a real serialization, and labelled that way in the ADR itself.
47 architecture decisions, every claim receipt-backed, every failure preserved. The honest state: reach is real, trust is real, translation is the open problem.
A sensor fleet on a farm. A survey team in a canyon. A vessel forty miles out. Equipment in a warehouse with no WiFi. The moment there's no signal, anything cloud-dependent simply stops.
That's a hard limit on where autonomous systems can operate — and most of the planet is on the wrong side of it.
Give each node a cheap radio and they form their own mesh. Messages hop node to node, routing around whatever's in the way. No tower, no subscription, no backhaul.
Range depends on the radio you choose — LoRa commonly covers 2–15 km line of sight, and every hop extends it further.
A long-range link gives you a few hundred bytes per message and strict limits on how often you may transmit. Sending raw JSON conversation history is hopeless — one message blows the entire budget.
So LatentMesh sends a bounded semantic envelope: what changed, how important it is, which facts must arrive exactly, and a hash so the receiver can tell if its picture has drifted.
Radios lose line of sight. Vehicles drive behind hills. Batteries sleep to save power.
Messages queue and forward when the node returns, with replay protection so a repeated frame can't be reprocessed as new. You design for intermittence instead of fighting it.
The same message travels over LoRa packets, ham HF/VHF, Bluetooth, WiFi UDP — or as audio tones through any voice channel, including a handheld held up to a speaker.
Swap the carrier without touching your agent code.
Put a gateway anywhere in the mesh that has connectivity — a vehicle driving back into range, a hilltop repeater, a base station — and it bridges the whole mesh to online services.
The bridge decodes and republishes at a single explicit boundary. Radio bytes never tunnel blindly onto the internet.
Six shapes this takes in practice. The common thread: coverage is the constraint, and adding towers isn't an option.
Soil, water, livestock and gate sensors over hundreds of hectares.
No cell plan per device · solar-viable duty cyclesInfrastructure down or saturated; teams and drones keep a shared picture.
Battery-powered · works when towers don'tVessels and remote camps well past cellular range.
Satellite is metered by the byte · this isn'tStructured agent data over HF and VHF.
Audio-only paths through gear you already ownEnvironments where RF is hostile and wiring every node is impractical.
Store-and-forward absorbs the dead zonesSites that could have internet and deliberately don't.
The mesh behaves identically either wayThree tiers, honestly labelled. The first ships today. The second is buildable with what exists. The third is where the constraints happen to line up — stated as speculation, not roadmap.
Tap a tier to switch
Soil moisture, tank levels and gate states across a property with no cell plan per device.
Battery sensors in terrain that never had coverage, reporting only when a reading changes materially.
Teams keeping a shared operational picture when towers are down or saturated.
Camps and vessels past cellular range, where satellite is metered by the byte.
Units sharing a world model over radio instead of round-tripping through a base station that may not be reachable.
A small model on-site handles what it can and escalates only what it can't — the escalation is a bounded delta, not a transcript.
Collars forming their own mesh, with a herd-level picture assembled without per-animal connectivity.
Long linear infrastructure where every node is a relay and coverage gaps are the norm.
Where round trips cost minutes, a protocol built for bounded messages and local decision authority is closer to right than one assuming an interactive link. Speculative — nothing here has flown.
Acoustic and through-rock channels are slow and noisy in the same shape as HF. The audio-tone path is the closest existing analogue.
Neighbourhood-scale coordination that keeps functioning when the grid and backhaul don't, with trust that doesn't depend on a certificate authority being reachable.
Fail-closed framing and replay windows matter most where the channel is actively hostile. Untested against a real adversary — stated as a fit, not a claim.
Everything below runs on a laptop with no radio hardware at all — the transport is simulated, so you can build and test the whole path before buying anything.
Confirms the whole stack builds on your machine.
# core · radio · Meshtastic adapter · bridge git clone https://github.com/ruvnet/LatentMesh cd LatentMesh cargo test --workspace
Same framing and error correction, allocation-free, for embedded targets. Sanitizers on.
cmake -S c -B /tmp/lm-air -DLM_AIR_ENABLE_SANITIZERS=ON cmake --build /tmp/lm-air ctest --test-dir /tmp/lm-air --output-on-failure
The microcontroller decision logic, testable without flashing a board.
make -C firmware/esp32/host_tests test
use latentmesh_meshtastic::{MeshtasticAdapter, OutgoingMessage}; let mut radio = MeshtasticAdapter::new()?; radio.set_destination(0xffffffff); // broadcast // one call → the frames your radio should transmit let frames = radio.encode_message(OutgoingMessage { .. })?; // feed bytes back as they arrive; you get a whole // message once every fragment has landed if let Some(msg) = radio.ingest_from_radio(&bytes)? { // reassembled and verified }
Reassembly, ordering, duplicate rejection and replay defence are handled for you. A message can span up to 32 fragments.
Nothing, to start. When you're ready to go over the air, the cheapest useful setup is two LoRa boards.
RF licensing, power limits and band rules are yours to comply with. LatentMesh handles bytes above the transceiver and deliberately owns nothing that touches transmit legality.
Each layer is usable on its own. Take the whole stack or a single crate.
| You want to… | Use |
|---|---|
| Put agent messages on a LoRa mesh | latentmesh-meshtastic |
| Build frames for any other radio | latentmesh-air-core · no_std |
| Drive audio or IQ hardware directly | latentmesh-air-radio · AFSK, CPFSK, BPSK |
| Bridge the mesh to online services | latentmesh-agentbbs-bridge |
| Keep shared memory across the fleet | latentmesh-memory · latentmesh-federation |
| Run on a microcontroller | portable C11 core · firmware/esp32 |
| Test whether a channel earns its bandwidth | latentmesh-gate |
Failing checksum, signature, replay window or reassembly means dropped. Nothing downstream can wave it through.
Frame sizes, fragment counts and queues are all capped. A hostile transmission can't exhaust memory.
Critical values are carried exactly. Compression never touches facts you marked must-arrive-intact.
Clone it, run the tests, send a simulated message. Add a radio when the simulation stops being enough.
Get the code Open Air Studio ↗
LatentMesh is a research prototype under active development. Transport, framing, error correction and radio adapters are implemented and tested; the learned-radio stages on the roadmap are marked as not-yet-built rather than implied. Every performance claim in the repo traces to a committed measurement.