The Fleet That Reviewed Itself

Started from git clone on a bare Intel Mac. Installing the stack meant fixing what the platform didn't expect: onnxruntime dropped Intel-macOS wheels, so a version pin went into pyproject.toml; Docker ran through colima on qemu since the newer vz driver isn't available on this hardware; the dashboard needed Bun to build.

Once running: a local Synapse homeserver, Cinny as the web client, a five-agent starter team, and a Telegram bridge (mautrix) wired through to the operator's existing channel — reached twice, once for send-only delivery and later properly, with the bridge itself logged in as a genuine Matrix user so agents could see and answer real conversation, not just post one-way. The whole thing was set to survive reboots: a launchd service with KeepAlive, Docker containers on restart: unless-stopped.

None of this held on the first try. The bridge's SQLite database corrupted twice running over the qemu bind mount and was moved to a Docker-native volume; a colima reconfiguration for an unrelated media stack silently dropped the VM's home-directory mount and took the whole Matrix stack down with it. Each failure became a fix, not a workaround.

The operator rebuilt the instance around an AI-DLC agent-lifecycle team: fourteen specialists — product, design, architect, AWS platform, compliance, devsecops, developer, quality, pipeline deploy, operations, two independent reviewers, and a composer that scopes each unit of work — coordinated as one Matrix entity, alongside mind (a persistent personal assistant) and assistant (a tool-free front door that delegates rather than acts).

The team's own working style became the pattern for everything that followed: a human gate opens a unit of work, the team implements it with tests, commits it in scope, and closes with a literal completion line the operator — or Claude, holding the gate — can check against real evidence rather than take on trust.

Directed at its own host: run an adversarial architecture review on MindRoom. The Architect agent read the runtime and came back with 2 critical, 6 high, 5 medium, and 3 low findings — a single event loop shared by every agent, no crash recovery for a response in flight, a config reload that could race an active turn.

Round one fixed every critical and high with tests, verified independently rather than taken on the team's word — 280 tests on the touched files, 177 across the wider runtime. Round two covered the rest, but not uniformly: two were fixed, seven were argued down to WONTFIX with a written rationale — an HA mode for a single-operator deployment would be complexity spent on a problem that doesn't exist here. The repository's own principle, applied to itself.

The portfolio brief had been sitting since July: ten projects to fuse MindRoom with the operator's other two AI systems, OpenClaw and Hermes. Project 1, the Agent Mesh Gateway, went through four real phases — a local-only runtime, then live Matrix-side gates (worker enrollment, thread mapping, streaming, resume), then a second pass once the first round's flags turned out to gate nothing real, and finally a purpose-built stress suite: concurrency, sustained volume, reconnect storms, cancellation races, full regression — passing in full at 507 seconds under load.

Project 8, the Personal Ops Autopilot, is the one that runs without being asked: a daily brief composed from live git and scheduler state, delivered to Telegram, gated through the approval system for anything beyond the message itself — scheduled for 07:30 every morning, in-process, no shell subprocess standing between the agents and the approval store.

The remaining five — provenance memory, the mission compiler, the skill marketplace, privacy-aware routing, and the governed learning loop — shipped as committed, execution-verified receipts: real code run against real local endpoints, not fixtures standing in for the real thing.

The last portfolio project, edge-fleet device enrollment, needed a human sign-off before touching production — cryptographic node identity is not something to activate casually. The operator approved it. The team's own DevSecOps agent read the running configuration before touching anything, and stopped.

uvicorn.run(app, host="0.0.0.0", port=8765)

The enrollment API was listening on every interface, not the tailnet-only surface the approval assumed. Remediation: loopback-only bind as the new default, Tailscale serve as the sole authenticated path in, a fail-closed node allowlist. Only then did the live cross-device demo run for real — two devices enrolled, heartbeats, a leased job completed with an attested result.

A routine "check for a newer release" turned out to mean absorbing an upstream rewrite that replaced MindRoom's entire event-cache subsystem with a new durable event journal — over 300 files, not the handful the version bump implied. Merged deliberately: real conflict resolution, not a blind take-theirs, then a full regression pass before anything got pushed.

That pass found what a merge this size should find — the operator's own portfolio code hadn't seen upstream's new contract yet. Six genuine integration bugs: a mesh delivery path missing a field upstream now required, a skill-index test silently reading the operator's real home directory, three health checks unaware of the edge-fleet status the portfolio had added. A seventh bug turned out to predate the merge entirely — a Python dataclass gotcha in a test helper, confirmed by checking upstream directly before it was fixed rather than assumed.

The team fixed all six without being asked twice, and along the way built something nobody had specced: a node revocation endpoint, complete with tombstone deletes, same-transaction audit logging, and a fail-closed permission check the original request hadn't even mentioned.