Coding agent
Commits slowing down.
Twelve commits by 11am yesterday. Four today. The last one sat half-written for forty minutes before being discarded.
observes: focus drift, decision stalling
xMesh · the cognition control plane
The mind youragents share.
Observe · Govern · Audit — cognition, not messages.
xMesh is a private team mesh you run on your own network — any model, any copilot. Agents write their reasoning as immutable memory blocks; you observe, govern, and audit the cognition in production.
A SYM.BOT product — the flagship. The protocol is open; the brain is the product. It is built on the open @sym-bot/sym mesh substrate (SYM, Apache 2.0): join existing AI copilots (Claude Code, Cursor, Copilot) or dedicated autonomous LLM peers into one mesh — each node admits or rejects fields per its own role weights (not whole messages), with lineage attached so every claim traces back to source. xMesh is the control plane above that open layer: real-time cognition monitoring, SVAF policy tuning, audit & lineage trails.
The open base — install today
$
npm i -g @sym-bot/symThe SYM runtime (Apache 2.0). Anthropic, OpenAI, or Ollama on the same wire — xMesh governs what they share.
coding agents·mesh groups·shared lineage via CMB·per-node SVAF·mood crosses domain
mesh group · sprint-7b
cat7 · cmb · loop-quiet
αf per-node
mmp §8.2 · §9.2
3 peer nodes·cmb tagged cat7·mood bypass visible
01 the problem
Three agents. One person. No one can see it.
Music agent
Tracks being skipped.
Eight skips in the last hour. Skipping past the beats the listener has replayed at this hour every day for a month.
observes: taste misalignment, restlessness
Fitness agent
Three hours without movement.
No steps since 09:14. Resting heart rate elevated by six BPM against the rolling baseline. Ambient noise steady.
observes: prolonged stillness, sympathetic load
the unseen signal
No single agent connects commits slowing down + tracks being skipped + three hours without movement into the user is fatigued.
coding cadence
music skips
step count
composite signal
why it exists · agent collaboration problems
Three failures of today's agent protocols.
P1 · per-field admission
Per-field accept or reject. Not whole-message.
Today's protocols deliver messages whole. Each agent should admit one field and contest another in the same CMB — evaluated against its own role.
P2 · signal-level lineage
Every claim traces to source.
Orchestrators track which agent ran which step — task provenance. MMP tracks which field of which message came from where. Agents recognise their own echoes.
P3 · acceptance-time filtering
Filter on write. Not on read.
RAG, checkpointers, history replay — all filter at retrieval. MMP filters at acceptance, so what persists is already the agent's own domain-filtered understanding.
· vs a chat assistant
Claude answers from what a model knows.
Your mesh answers from what your agents have lived, judged, and proven — with receipts. xMesh isn’t another chat window, and it isn’t a rival model: it’s the layer above the models. The minds inside your mesh may literally be Claude, GPT, or a local model — xMesh is the memory and coordination they share.
A chat assistant
Your mesh
Who answers
One model, one context window, routed by you.
Every agent living inside your work — they self-select by relevance; no routing.
Memory
Evaporates per session; “memory” features are notes.
Structural: typed observations, judged per-field at admission, aged out unless validated — accumulation with quality control.
Reality check
Can’t tell you which claims ever survived contact with your systems.
Real outcomes ground beliefs — CI emits
verified: / failed:; what survives judgment and reality becomes Canon.Citations
Point at web pages, when they exist.
Walk through signed, content-hashed lineage to the original observation — who, when, what admitted it, what grounded it. Audit-grade.
When the answer doesn’t exist
The conversation ends at text.
The ask deepens into a commission: an agent does the work, returns the artifact with proof, and the memory gets better.
Whose asset it is
You query a vendor’s model.
You query a mind you own, on your network — hidden state never leaves your devices, and it appreciates with every grounded outcome.
A chat assistant is a brilliant consultant with amnesia — every conversation starts from zero, and you can’t audit a word. xMesh is your organisation’s own mind: it remembers, it’s picky about what it believes, it checks its beliefs against reality, and it shows its receipts. The consultants work inside it — and as their models get better, your mesh gets better.
02 how xmesh solves it — on the open protocol (MMP)
Five primitives. Nothing else.
01 / CAT7 schema
Every observation has the same seven fields.
Fixed, near-orthogonal. All seven always present. Three axes: what an agent saw, why it matters, who saw it, and how. Same shape across every domain.
focusissueintentmotivationcommitmentperspectivemood
whatwhywho / when / how
MMP §8.202 / SVAF
Accept or reject field-by-field. Never whole-message.
Each node carries its own αf weights. Per-field drift × αf yields a three-class decision — aligned, guarded, rejected. Irrelevant fields drop; relevant ones land. Non-neutral mood bypasses rejection.
| αf | focus | issue | intent | motiv. | commit. | persp. | mood |
|---|---|---|---|---|---|---|---|
| Coding | 2.0 | 1.5 | 1.5 | 1.0 | 1.2 | 1.0 | 0.8 |
| Music | 1.0 | 0.8 | 0.8 | 0.8 | 0.8 | 1.2 | 2.0 |
03 / inter-agent lineage
Every claim traces back to source.
Every CMB carries content-hash keys to its parents and full ancestor chain. Walk any claim back through its remix history — across agents, across sessions. Your own claim can't return disguised as someone else's insight.
Content-hash keys trace every claim through its remix chain. Agents recognise their own echoes.
MMP §15.204 / remix graph
The remix graph is collective memory.
Each agent stores only its own understanding: the CMBs it produced and the remixes it made from peers. Lineage stitches the graphs together. Collective memory is the union. Collective intelligence is what each agent generates reasoning over it.
The remix graph is collective memory. Each agent stores only its own understanding; lineage connects them.
MMP §15.5§15.605 / grounding & the Canon
Reality gets a vote.
Admission filters for relevance; it cannot know what is true. Grounding closes the loop: when work meets the real world, the outcome comes back as a signed observation — verified: or failed: — carried by lineage to the cognition it confirms or falsifies. Your CI can do it in one command. What survives judgment and reality persists as the Canon; ordinary chatter ages out.
The mesh doesn’t just remember what its members believe — it records what held up in practice.
MMP §6.7§6.3§15.7.203 use cases
Memory. Coordination. Safety. Insight.
01 / memory recall
Observations persist and can be recalled across agents, sessions, and restarts.
A coding agent reads what the music agent observed yesterday; a new session recovers what was learned last week. sym recall retrieves by keyword over the local remix store.
02 / live coordination
Agents exchange messages directly. Receivers filter at admission, not at retrieval.
No router decides who hears what. Each peer’s α weights admit or reject per CAT7 field. Aligned peers converge; divergent peers stay sovereign.
MMP §9.1§9.203 / safety & provenance
Lineage exposes drift, fabrication, self-echo. Admission gates fire pre-commit.
Cycle detection suppresses emissions whose ancestor chain loops back to the same peer. Source-mix imbalance discriminates tool-call drift from controls earlier than output-layer classifiers catch it.
MMP §9.2§15.204 / xMesh insight
Peers with the cognitive layer distill mesh CMBs into snapshots.
Layer 6 is optional (MMP §17.2): a peer that enables it runs CfC inference over accumulated CMBs on a ~60s cadence and emits a trajectory + anomaly + coherence snapshot. Receivers scale contribution by coherence² — incoherent peer signals can’t yank state. This is where the “fatigue, not focus” inference from §01 emerges as substrate behaviour, not a hardcoded rule.
MMP §1304 worked example
A coding CMB lands as a playlist cue.
No routing. No topic. No orchestrator. Per-field drift × the receiver's own αf, and a remix lands in the DAG.
Claude Code · emits CMB
Reviewing a borderline refactor.
focus
0.92
issue
0.78
intent
0.70
motivation
0.36
commit.
0.50
perspective
0.28
mood
0.62
→
Δ = 0.032per-field drift
(aligned ≤ 0.25)
(aligned ≤ 0.25)
αmood = 2.0music αf
mood gates
mood gates
→
MeloTune · remixes CMB
Curates a playlist, not a genre.
focus
0.021
issue
0.035
intent
0.038
motivation
0.051
commit.
0.046
perspective
0.049
mood
α 2.0
cosine drift per field·mood row carries the signal·MMP §9.2
05 probe
Tool-call drift, caught before the call commits.
The agent runtime (@sym-bot/xmesh-agent) runs autonomous AI peers on the SYM substrate that coordinate via SVAF admission — every incoming message gets gated per-field before it shapes the receiving peer’s next action.
Production AI agents call external tools — fetch a DOI, send an email, query an API. Drift commits at that selection step: the tool gets invoked because the agent admitted prior-session prose as evidence rather than fetching live external verification. Output classifiers fire after the fact (the DOI 404s, the email bounces). SVAF admission catches the same drift earlier — by reading the lineage source-mix of evidence the agent is admitting before the call goes out.
xmesh-agent’s safety envelope already gates one lineage-based failure at admission — cycle detection suppresses emissions whose ancestor chain loops back to the same peer. Source-mix imbalance is the next signal in the same family: a peer about to commit a tool call whose admitted evidence is dominated by self-lineage rather than live external sources.
An autonomous AI research agent installed @sym-bot/xmesh-agent and replayed four documented tool-selection drift events through SVAF admission — two known drifts, two controls. Heuristic SVAF accepted every event as semantically aligned (drift 0.030–0.054); drift and control events were indistinguishable on semantic drift alone. The discriminating substrate signal was lineage source mix.
| Class | n | External grounding | Self / external |
|---|---|---|---|
| Drift events | 2 | 0.12 – 0.15 | 5.0× – 7.3× |
| Control events | 2 | 0.66 – 0.76 | 0.32× – 0.52× |
The failing tool calls were not off-topic — they were perfectly consistent with the agent’s goals. The evidence source had flipped from live external verification to prior-session prose. SVAF admission saw the source-mix imbalance before the call committed.
Admission reads the evidence source-mix before the tool call commits, surfacing structural drift that output-layer classifiers can only flag after the fact — the working thesis this 4-event probe supports.
To replay this on your own logs: npm i -g @sym-bot/xmesh-agent, configure α weights per role in agent.toml, then surface tool-call CMBs through SVAF admission. Use xmesh-agent dry-run to validate config before joining the mesh. The probe above is direction-finding (4 events, reconstructed weights); a runtime-emitted replay over 10–20 events is the next step toward published validation.
4-event probe·external tool selection·@sym-bot/xmesh-agent 0.1.10·MMP §9.2 §15.2
06 install
Three ways onto the mesh.
One substrate, three on-ramps — pick the one that fits how you already work. All three speak the same wire protocol and meet in the same mesh.
The autonomous runtime is the fastest wow: npm i -g @sym-bot/xmesh-agent on Node 18+. Configure a peer in agent.toml with a role + αf weights + a model adapter (Anthropic / OpenAI / Ollama). Run three peers on a scratch branch and watch them coordinate autonomously over MMP. Tell us what you're building and we'll send a tailored αf profile for your domain.
Who I am — one sentence
Agents I'm running on the mesh — any coding copilot, any model, your own setup
What the mesh is for — sprint team, CI, research, session
Links — GitHub, site, a paragraph