One install — agents that remember, coordinate, and ask by default.

Not tools an agent can call and usually doesn't. One install writes the habit in, so my agents remember decisions, coordinate without clobbering each other, and ask me on my phone while I'm on the couch.

Xylem is a small stack of tools that gives AI coding assistants three human things — a memory, a shared job site, and a way to reach me when they're stuck — plus the one piece that makes them actually get used: an installer that writes the discipline into the agent's own instructions.

Install as a plugin /plugin marketplace add jarmstrong158/Xylem /plugin install xylem@xylem-stack
Or clone and run the installer ./install.sh --applyWindows: .\install.ps1 --apply
Either path registers the servers, injects a fenced discipline block into your CLAUDE.md, and adds the /xylem-discipline command — so "installed" means "used," not "available and ignored."
See how it works 📊 Live dashboard View on GitHub
The couch demo

A question reaches my phone — and gets answered

Watch one loop: my laptop's agent claims a task, my phone sees it, the agent asks a question, I answer from the couch, and the agent carries on.

Why the phone is a real peer, not just a viewer: a laptop saving through git and a phone saving through GitHub both follow the same rule — only save if no one changed this first. Because those two checks behave identically, both devices share one to-do list and no central server ever has to referee between them.

My laptop
AI coding agent
working
📋 shared board · claims.json
laptop ▸ claim: “refactor auth”
phone ▸ survey: reading the board…
laptop ▸ mailbox Q: “JWT rotation or short sessions?”
phone ▸ mailbox A: “short-lived sessions”
laptop ▸ claim: “refactor auth” — done ✓
My phone
same board, from claude.ai
peer

1.On my laptop, an AI agent claims a task and writes it to the shared board.

This actually happened

Replayed from the real commit history

The couch demo above is illustrative — a clean, one-loop walkthrough. This one isn't. It's replayed from the actual agentsync board and context-keeper decisions recorded while the stack was used to build itself. Step through it; every event links to the commit or PR behind it.

Loading the real timeline… if it doesn't load, read it raw: demo-timeline.json.

Not a mockup — a week

A week of real use

Ordinary work, run on this stack. Every item links to a commit or PR you can open and check.

  1. An audit → fix → retrain loop, driven from a phone.
    An agent audited a Balatron model's optimizer, found the learning rate was being reset every time a checkpoint reloaded, locked it at load time, and re-ran — the whole cycle steered from the couch.
    the audit (dec-058)·the LR-lock fix·dec-061 follow-up
  2. Two agents building in parallel on one board.
    Two agents claimed disjoint lanes on a single shared board and built on their own branches. The board's compare-and-swap refused a colliding claim with its reason, and let non-overlapping work through — no central server refereeing.
    the two-person CAS test
  3. A knowledge harvest: 132 distilled lessons → 9 org items.
    A week of session-level lessons was distilled and boiled down to 9 organization-level knowledge items — each one landed through its own reviewed pull request, not a bulk dump. The org knowledge store itself is a private repo, so unlike the other items on this list you can't open it; what you can read is the promotion machinery that gated it.
    cambium's promotion gates
  4. A connector outage where the discipline held.
    When the remote connector's MCP handshake started failing, the local-first servers kept working. The fix hardened the handshake so a GitHub-side outage isolates to a logged warning instead of hanging the session.
    handshake hardening
No jargon

In plain terms

Four tools, four everyday analogies.

context-keeper

memory

A team wiki that writes itself and remembers why, not just what.

agentsync

coordination

The job-site whiteboard where workers sign out tasks so nobody tears out the same wall twice.

cambium

knowledge lifecycle

How one person's hard-won lesson becomes company policy — with a gate so bad lessons don't.

xylem

the hub + onboarding

The front desk that knows the whole building and points you to the right room — and now runs onboarding too: one install writes in the habit layer that gets the other three used without being asked.

Measured, with the caveats kept

The numbers

Real figures from the projects' own test reports — honest labels, limits included. These are a hand-copied snapshot, read on 8 July 2026, not a live feed; for numbers that refresh on their own, see the live dashboard.

Memory, measured

context-keeper · docs/METRICS.md

Context trimmed at session start0%
Up to 92% fewer tokens than dumping the whole store (88.3% at 26 entries → 92.0% at 70).
Right answer in the top 5 results (Hit@5)0%
13 of 15 test questions answered from the top results. Mean reciprocal rank 0.73.
Unanswerable questions caught (no confident match)0%
50% at the default threshold, 83% at a stricter one — with 0% false abstentions. Never claimed to be 100%.

Coordination, stress-tested

agentsync-remote · docs/RELIABILITY.md

0
simulated concurrent races
0
claims lost
0
tasks double-granted

Every one of the 1,000 races was genuinely contended, and all 47 automated tests pass.

Mirror, two-way

context-keeper · local store ⇄ canonical mirror

0
entries kept in sync
2-way
local ⇄ canonical, both directions
merge
newest timestamp wins on conflict

Edits propagate — a changed entry upserts onto the other side instead of duplicating. The limit kept honest: clock skew can affect ordering for sub-second writes.

Schema, reclaimed

tools/list token budget · before → after

Per-session schema tokens reclaimed0%
tools/list schema trimmed from 4,347 to 2,927 tokens — 1,420 fewer every session, same tool set.
What these numbers are — and aren't.
  • Memory figures come from a synthetic corpus (26–70 entries), using lexical matching only; token counts are estimated (~15% variance) and scale with store size — treat them as directional, not fixed properties.
  • Reliability figures validate the coordination logic against an in-process fake (stale write → HTTP 409) — not GitHub's live API, network behavior, or real-world latency.