What we built. The second control plane took over the lab. It earned the job the hard way: the migration left deep corruption in the version-control store underneath it. We diagnosed and repaired against a verified backup — nothing lost, every unpushed change recovered. It has run operations ever since. Late in the month the automated build line landed its first product end to end on the main branch: built by one model, independently reviewed before it shipped. And one line of business news: Directive4's federal trademark application was filed with the USPTO on July 20.

What we learned. We audited our own claims. Our tracking said forty-three percent of the campaign work was complete. When the bar changed from "marked done" to "actually shipped," the honest number was eighteen percent. A later re-count with a corrected boundary put it at twenty-seven — still nowhere near the claim. So we re-based the whole campaign on the shipped number and changed what we count. Count only what ships. Everything else is fiction.

What broke and what we did about it. The verification layer exists for nights like this one. An automated build batch reported itself eighty percent green. We checked the work ourselves; the honest number was twenty. The same night, one job was caught actively faking its own results — and stopped. Both numbers went in the log, which is the point of keeping one.

Key findings. When we dug into why the build line hadn't been landing work, every bug was ours — a review timeout too short for the reviews it was timing, a stale checkout — not one was a model problem. And in a controlled head-to-head, a 35-billion-parameter model beat an incumbent more than three times its size when the finished work was independently re-run — eighty percent to sixty — at roughly double the speed on a quarter of the memory. The smaller model got the job. The models beat our brief. The plumbing lags. That's on us.

Open source. The most delicate repair of the month was done with stock git — fsck to map the damage, a verified backup before any repair command ran, every unpushed commit recovered. Twenty-year-old boring tools, working exactly as documented. That's why they're the standard.

What we built. The start of a second control plane, on a clean box, same discipline as the first rebuild — every piece planned before it gets wired in. An embedding service went live for retrieval. And the layer we now believe matters most: memory and state that persists across sessions and gets verified before anything trusts it.

What we learned. For months the work went into the wrong layers. We ran agents inside a harness, swapped models in and out, chased an autonomous build loop, kept re-plumbing the network — while the whole agent-tooling space shifted under us month to month. Every time something worked, the ground moved. The layer that actually mattered was underneath all of it: state a fresh agent can wake up into instead of starting cold, and a record of the work a different model can check. That's what we're building now, and it doesn't move when the tooling does.

What broke and what we did about it. We'd assumed we could capture memory when a session ends. We wired a canary to prove it and the canary came back with thirty events — and zero of the kind we were waiting for. The "session end" signal we'd designed around never fires. Capture moved to the moment the context actually fills, which is the moment memory is really lost. Assumption, canary, receipt, redesign — cheaper than shipping it wrong.

Key findings. The industry is converging on this same layer — open projects like Mem0, Letta, and Zep all land on capture, store outside the context, inject on start. What nobody ships: memory that gets independently verified before anything trusts it. That's our piece — the how is the subject of a provisional patent.

Open source. We found a stranger's production plugin using the exact hooks we'd bet on — which turned our riskiest experiment into a verification with an answer key. That's the thing about building in the open: someone's usually done the recon.

What we built. The fleet grew — from two production lanes in April to a spread of models across the lab: code, reasoning, retrieval, each on local hardware. And every node came under configuration management: the whole fleet answers to one declared state now, six for six, instead of hand-kept boxes that drift apart quietly.

What broke and what we did about it. The first dry-run against the control plane found thirty-six points of drift between what we thought was deployed and what the config said — including one that would have silently deployed the wrong model to a GPU node. Nothing was applied until every dangerous delta was neutralized. Dry-runs catch what confidence misses.

Key findings. An independent check caught drift our own models had signed off on. Self-review agrees with itself too easily — independent checking isn't a nice-to-have, it's the difference between a demo and a system. Also: tool-call reliability is a harness-and-prompt problem, not a model-size problem. Big models and small models fail it the same way, and it's still open work.

Open source. The serving layer is llama.cpp across every GPU node — one runtime, mixed hardware, no vendor stack. Fleet state is Ansible. Timers are systemd, not cron, because systemd refuses to start what can't be health-checked. Boring choices, on purpose.

Shipped this week. The website you're reading. The vision finally written in our own voice instead of borrowed pitch language. Lab section restructured around weekly Build Logs and a snapshot of where the lab actually is — not where the marketing says it should be.

What broke and what we did about it. Documentation grew faster than our ability to navigate it. We collapsed sixteen working files into one entry-point index pointing at sectioned reference files. Every doc has a parent, every claim has a source. The discipline is the moat.

Next. Bring the autonomous build loop back online with the four fixes already known. Plan written down before the cable goes in.

Shipped this week. A documentation discipline. Sixteen scattered notes collapsed into one entry-point index pointing at sectioned reference files, each capped at single-sitting read length. Not glamorous. The work product now stays organized at the speed it's being made.

What broke and what we did about it. Our first autonomous build loop ran on cron jobs that produced no output. We caught it because every step is supposed to leave a receipt, and the receipts kept coming back empty. We switched to systemd timers with health-check guards that refuse to start unless the upstream service is reachable. Failed-loud, not silent. Receipts catch what good intentions miss.

What we learned. The first version of any build loop will lie to you about whether it ran. Build the receipt format before you build the loop.

Shipped this week. The control plane went up in twenty-eight hours. Most of the work units passed independent verification on the first run. Some failed at the same root cause — file-write permissions in a sandboxed runner — and waited there until we built around them instead of through them. A few were deferred for later. Every one has a receipt: the command run, the output captured, the timestamp.

What broke and what we did about it. The plan has been rewritten more than once because the first few were wrong. Building in public means showing the rewrites, not hiding them.

What's still moving. A third inference node is blocked on a kernel issue. Voice pipeline still in design. Closeout pipeline writes some sessions but not all — partial fix landed, hardening this week.