v0.2.0 — The latent channel doesn't move decisions, and one of our own nulls was the control's fault

What this release is about

LatentMesh started from an appealing idea: AI agents shouldn't have to talk in
sentences. If two models share an architecture, why not hand the raw internal
state — the numbers mid-thought — straight from one to the other? Denser, faster,
no words wasted.

This release is the record of testing that idea properly and finding it doesn't
work — plus the more interesting discovery that one of our own negative
results was wrong, and our measuring stick was why.

---

1. The idea doesn't move decisions

We injected one model's internal state into another's and measured whether the
receiver's answers changed. Six pre-registered experiments:

what we varied	result
one injection point	no decision effect
two injection points	no decision effect (identical numbers to one)
training the receiver to accept it, 3 sizes	no decision effect, all three

Every test was powered — it had enough data to detect an effect had one
existed. Plain text, on the same receiver, worked decisively.

The consistent pattern: injection reliably shifts what the model thinks is
likely, and reliably fails to change what it does. Those two things come
apart, and only one of them matters.

2. We were wrong about why — and our control was the reason

Earlier we concluded the receiver wasn't sensitive to what a message said. That
came from comparing a real message against random noise.

The problem: random noise is wrong in two ways at once — it's meaningless
and it's shaped unlike anything the model produces internally. So when a real
message beat it, we couldn't tell which of those it beat. And when it didn't
beat it, we wrongly concluded there was no signal.

This release adds the control we were missing: a different real message —
same shape, wrong answer.

comparison	result
real vs another real message	p = 0.0002 — clear signal
real vs random noise	p = 0.26 — nothing

Same 300 problems, same model, same run. The signal was there the whole time,
hidden behind a bad comparison.

The earlier conclusion is narrowed by an appended note rather than quietly
rewritten — its numbers reproduce exactly, and what changed is the interpretation.

3. A geometry result we didn't expect

We wanted to test "right meaning, wrong shape." It turns out that in a
1536-dimensional space, pushing a message off its natural shape almost
inevitably destroys its meaning at the same time. The two properties are very
hard to separate.

We found this with a CPU-only check costing about four minutes, before spending
any GPU time on an experiment that would have produced an uninterpretable result.

---

What's new in the code

harness/representation — a router that picks how agents should talk to
each other, and admits a channel only on measured evidence that it changes
behaviour. Two deliberate design inversions:

• Confidence doesn't count. A component's own confidence score is a
  self-report, so a confidently wrong component passes. This gates on an
  admission test the component cannot author: beat the worst of five controls
  under a real significance test.
• Unmeasured means ineligible. Most explore/exploit algorithms give untested
  options an optimism bonus. Here, if it hasn't been measured, it cannot be
  chosen at all.

Asked to optimise itself, it reported that its own evolutionary search was
unnecessary — a full 432-configuration exhaustive sweep costs 0.82 ms and is
exact, while the search needed ~338 evaluations to match it only 93% of the time
— and replaced its own authority with enumeration.

Also included: the LoRA receiver-adaptation trainer and probes; the M6 probe
with the new control; every experiment receipt; and ADRs 045–047 with the full
pre-registrations.

---

The honest summary

Scored by its founding premise, this release is a failure: the latent channel
does not carry decisions, and we now have six powered experiments saying so.

Scored by what it produced, it's a measurement stack that catches its owners
being wrong — including about their own negative results. Four coordinator
errors are on the record, two of them the coordinator's own, along with a
prediction registered before a draw and falsified by it.

What isn't claimed: this closes direct activation injection under this
apparatus. It says nothing about latent communication in general, about
trained-fusion methods like Cache-to-Cache, or about transfer between different
models — none of which were tested here. One part of the design (the
"other-example message" control) is prior art from arXiv:2607.26773 and is cited
as theirs, not claimed as ours.

Two follow-up experiments are documented and deliberately not run — each
needs its own pre-registration first.

v0.1.0 — LatentMesh Air + Meshtastic/agentbbs/cognitum integration wave

First tagged release of LatentMesh — a causally-verified latent communication fabric for continuously evolving agent collectives, with the LatentMesh Air bounded semantic radio stack and its first ecosystem integration wave.

Highlights

Core (ADRs 001–014): LMS1 envelope + LMAD deterministic state delta, causal-edge verification against five decoy controls, capability-governed execution, no_std-capable Rust crates, canonical portable C11 codec with cross-language golden vectors, ESP32-S3 firmware adapters, evidence-labelled MetaHarness benchmark discipline.

Integration wave 015–018: MidStream QUIC streaming, RuVector persistent latent memory, radio-federated world models, MetaHarness Darwin topology loop.

Integration wave 019–022 (new in this release, PR #10):

• latentmesh-meshtastic — Meshtastic as a byte transport under the ADR-011 adapter boundary (WireProfile::Meshtastic = 9, landed simultaneously in Rust and the C ABI with a shared golden vector). Interop-validated against real Meshtastic firmware (meshtasticd 2.7.26, portduino, TCP device API): full config handshake, single- and multi-fragment Air-frame round-trips byte-identical through the firmware's own routing. Empirical finding folded back into the design: the usable Data.payload ceiling is 227 bytes (not mesh.proto's nominal 233 — that bounds the encoded submessage), giving 211 usable Air bytes per packet, guarded by a permanent TOO_LARGE tripwire test.
• latentmesh-agentbbs-bridge — store-and-forward bridge into ruvnet/agentbbs bulletin boards; agentbbs is a transcribed wire contract, never a Cargo dependency.
• latentmesh-cognitum-client — Ed25519 canonical-request signing for the cognitum-one fleet API, offline by default (http feature gates the transport).
• harness/integration/ — self-optimizing e2e loop: three loopback suites, evidence-labelled receipts, Darwin-loop parameter optimizer, MetaHarness gates with honest degradation.

Evidence boundary (read this)

Everything in this release is validated in loopback/simulation or against real device software over TCP — never over the air. No claim of RF, live-credential, or live-peer validation is made anywhere; each ADR carries an explicit implemented-vs-simulated boundary table, and every harness receipt carries its evidence label. Open items are tracked in ADR boundary tables: physical LoRa validation, EU868 duty-cycle verification, ruflo ADR-164 confirmation, cognitum server-side replay-window verification.

CI

9 gates green at release: Rust stable (fmt, clippy -D warnings, workspace tests, feature lanes), MSRV 1.77 (with edition2024-drift-resilient resolution), portable C (sanitizers, golden vectors, static analyzer), ESP32 host tests + ESP-IDF 6.0.2 build, three MetaHarness evidence jobs, RustSec audit.

🤖 Generated with claude-flow

https://claude.ai/code/session_01JNzKP76XHPvCKWSnyZrsCK