I built a production multi-agent MCP stack — from my phone

Jonathan Armstrong — Sun, 12 Jul 2026 20:30:45 +0000

I manage a warehouse. I am not a professional software engineer. But over the
last several months I built and shipped a stack of AI-agent infrastructure —
most of it typed on my phone during breaks and after shifts — and it's now live
on the official Model Context Protocol registry. Here's what it is and the one
idea that made it work.

The problem. When you run more than one AI coding agent against the same
repo, two things break: they forget (every session starts from zero) and they
collide (two agents editing the same files). The usual fixes are heavyweight —
a database, a server, a queue. I wanted something local-first that works
offline and needs no infrastructure I'd have to babysit.

The one idea: git is already a coordination primitive. git push rejects
your write if someone changed the branch first. That's a compare-and-swap — the
exact "only save if nobody beat you to it" rule you'd normally reach for a
database to get. So I put the agents' coordination state in a JSON file on a
dedicated branch and let git push be the lock. No server. A phone and a
desktop become equal peers on one board, because the GitHub Contents API
enforces the same rule the phone's git client does.

The stack (Xylem):

context-keeper — durable project memory. Records the why behind decisions, not just the what, in human-editable JSON. Published evals: up to ~92% context reduction vs. dumping the whole store, with calibrated abstention when it doesn't actually know.
agentsync — the coordination layer above. 1,000 simulated concurrent races in the test suite: zero lost claims, zero double-grants.
cambium — the knowledge lifecycle. It distills finished work into recallable lessons and promotes them by earned trust: local → team → org.

The part I still find a little wild: the stack now runs its own development. It
audited a reinforcement-learning agent I'm training, compared the agent's
recorded design decisions against what actually happened in the training run,
found a learning-rate bug, and I fixed it and relaunched — coordinated from my
phone.

What it's not. It's lexical recall, not semantic (yet). Coordination is
advisory, not enforced. I've tried to be honest about every limit in the
READMEs, because tools that oversell their guarantees are worse than none.

If you're building with agents, it's all open source and on the MCP registry:
https://github.com/jarmstrong158/xylem

I'd genuinely like feedback — especially on where the git-as-CAS model breaks
down at scale.

DEV Community: Jonathan Armstrong

I built a production multi-agent MCP stack — from my phone