Researchprotocol suite

The formalismunder the field.

Rhizome is not a metaphor with a UI. Underneath the field is a versioned suite of coordination protocols with an explicit mathematical model — invariants, a time model, priority and attachment functions, and a control law. This page is an overview of that model at academic altitude: enough to judge the rigor, not a drop-in blueprint.

The model

The protocol answers one question: how do you make many LLM agents act as one cognitive process without erasing their difference and without creating a hidden center?

The unit of coordination is not a task but a tension — a typed gap between the current and the desired state, anchored to segments of an artifact graph. Agents attach by fit rather than waiting to be assigned. Strong decisions are made not by authority but through bundle utility, a verifier mesh, and persisted dissent. The environment intervenes only in the geometry of interaction, never in the content of thought.

It is a protocol overlay, not a greenfield architecture: it changes the logic of coordination over an existing multi-agent system rather than replacing its tasks, documents, and tools.

Core invariants

Hard constraints on the system. Break one and it stops being Rhizome — they bound every protocol in the suite.

No permanent semantic orchestrator

There can be environment regulators, stewards, and verifiers — but no standing node that decides what the others should think.

Projections are shared, not minds

Full scratchpads do not become shared memory by default. Only short public projections of intent are published, so the swarm cannot collapse into one brain.

Dissent is never erased

Disagreement that does not block a merge is preserved as a DISSENT marker or a fresh tension, rather than silently overwritten.

Coalitions are small and short-lived

A coalition is local to one tension, bounded in size (typically 2–4 agents), and carries a TTL. Structure stays temporary; bureaucracy never sets in.

Control is local, not global

Metrics, control actions, and circuit breakers are computed per cluster. Emergency measures are cluster- or segment-scoped, never a global pause of the whole swarm.

Agreement is not the objective

Neither alignment nor any global index Ω is optimized directly. The system optimizes solving the task while holding each cluster inside a corridor of useful cognitive dynamics.

Formal core

Five load-bearing constructs, in compact notation. The full specification carries the complete definitions, schemas, and lifecycle machines; this is the shape of the math.

These are protocol-level control equations — they define what the runtime estimates and regulates. Concrete weights and corridors are implementation- and task-class dependent.

Event-time control epochs

Time is measured in event-time epochs, not wall-clock ticks. TTL, cooldown, hysteresis, and staleness are all counted in epochs — an epoch closes once enough real time has passed or enough relevant events have accumulated.

\tau \in \mathbb{N}, \qquad \tau \to \tau\!+\!1 \iff \Delta t_{\text{ctrl}}\ \text{elapsed}\ \lor\ E_{\text{ctrl}}\ \text{events}

Capability as empirical profile

Beyond its role, each agent carries a capability vector tracked empirically — an exponential moving average of its recently accepted, verified effects — so attachment reflects what an agent has actually been doing well, not only a static label.

C_i(\tau) = \textcolor{#b3a3dd}{\operatorname{EMA}}_H\!\left( \{\, e(r) : r \in \mathcal{R}_i^{\,\text{acc}}(\tau - H,\ \tau) \,\} \right)

Tension priority: base, surface, archive

Importance, visibility, and archive-propensity are kept separate. A tension does not lose intrinsic importance just because it is old; visibility decays with idleness and crowding, while archiving is its own process.

\begin{aligned} \pi_k^{\text{base}} &= \textcolor{#b3a3dd}{\operatorname{clip}}\!\left( w_I I_k + w_B B_k + w_U U_k + w_C C_k + w_L L_k,\ 0,\ 1 \right) \\[7pt] \pi_k^{\text{surf}} &= \pi_k^{\text{base}} \cdot v_k(\tau) \end{aligned}

visibility v_k(τ) decays with idleness · crowding · dissent

Attachment by softmax, not argmax

Agents do not all jump onto the single hottest tension. Each samples where to attach by fit, with inertia and a minimum tenure, so the field explores broadly instead of stampeding into one hotspot.

\begin{aligned} s_{ik} ={}& \alpha\sqrt{\pi_k^{\text{surf}}} + \beta\,\textcolor{#b3a3dd}{\mathit{Fit}}_{ik} + \gamma\,\textcolor{#b3a3dd}{\mathit{Nov}}_{ik} - \delta\,\textcolor{#b3a3dd}{\mathit{Crowd}}_k \\[7pt] &{}\;\; - \varepsilon\,\textcolor{#b3a3dd}{\mathit{Switch}}_i - \eta\,\textcolor{#b3a3dd}{\mathit{CtxLoss}}_{ik} + \zeta\,\mathbb{1}\!\left[\,k = k_i^{\text{cur}}\,\right] \end{aligned}

P(i \to k) = \frac{\exp\!\left(s_{ik}/T_{\text{att}}\right)}{\sum_{\ell} \exp\!\left(s_{i\ell}/T_{\text{att}}\right)}

Corridor-based policy engine

The environment regulator does not pull every cluster toward one ideal point. Each task class defines a resonance corridor of healthy metrics; a cluster only changes mode once the same deviation persists for several epochs (hysteresis), which damps thrashing.

proof / formal-reasoning corridor

\begin{aligned} &A \in [0.55,\,0.80] \quad D \in [0.35,\,0.65] \quad S > 0.05 \\[2pt] &Z < 0.45 \quad M \in [0.10,\,0.35] \quad P > 0 \end{aligned}

A—alignment
D—differentiation
S—synergy
Z, M, P—stability terms

Each cluster is held inside the corridor rather than driven to a point; it changes mode only if a violation holds for H_mode consecutive epochs (hysteresis).

The protocol suite

Three protocols, each governing one layer of the system: how it thinks, what it remembers, and how sure it is.

RRP

Rhizome Resonance Protocol

≈ executive attention

The coordination core — the operational logic of the system's thinking.

Agent dynamics — who is working on what
Formation and resolution of tensions
Emergence and dissolution of coalitions
Distribution of attention and resources
Balance between alignment, differentiation, and synergy

How the system thinks and acts.

RMP

Rhizome Memory Protocol

≈ long-term memory

Storage, retrieval, and evolution of knowledge — the system's memory and identity.

A typed memory graph — FACT, DECISION, DISSENT, PROCEDURE, …
Layered memory: episodic, semantic, procedural, identity
Compaction into episode packs; a kernel plus differential shells
Garbage collection through decay and lazy evaluation
Coherence: provenance, invalidation, drift control

What the system remembers.

RSP

Rhizome Statistical Protocol

≈ calibration & reflexes

The calibration and stabilization layer — it advises, it never decides.

Probabilistic confidence via Bayesian calibration
Anomaly detection: thrashing, stagnation, overload
Agent-state estimation (HMM / risk score)
Forecasting of load and failure
Emits hints, not decisions

How confident it is — and whether it stays stable.

Maturity

What is implemented today versus what is still target protocol. We track each layer at a maturity level and say plainly where it stands — the specification runs ahead of the running system, on purpose.

ImplementedPartialPrototypeExperimentalPlannedResearch

Task / tension representation

partial / implemented

Artifact-bound claims

implemented

Side-effect lanes

prototype

Attachment score

experimental

Coalition TTL

planned / prototype

Verifier mesh

partial / implemented

RSP calibration

research

How we report

This is the formal model the system is built on — a living specification that evolves as the runtime and the research advance.

A clean model is necessary but not sufficient: it has to survive contact with real runs. The empirical side — what the model actually does on real work — lives in Early Signals.

See the Early Signals The field, in plain terms