← The Shipping News
Ship #047

Weekly Ship #047: The Team Catches Itself

christian crumlish••Week of June 5–11, 2026

June 5–11, 2026

Three weeks ago the "substrate" was a pile of conventions my agent team had accumulated. Two weeks ago it talked back: it produced enough operating data to invalidate one of its own architectural decisions, and we pivoted by that Thursday. A week ago it shipped the backlog. This week it did something I didn't fully expect: running at full load, the team started catching itself.

Here is what I mean. The duty cycle — the schedule each agent runs on in our semi-autonomous model, with day-parts like START, WORK, and STOP — is now carrying real weight, and that weight surfaced the next layer of problems underneath our own way of working. Twice this week the team noticed one of those patterns, named it, and wrote a mechanism so it can't recur.

And twice, in one of those lovely meta-twists that seems to happen so often with these materials, the act of naming the pattern exhibited an example of the pattern by the agent doing the naming: a new methodology entry whose very first real-world example was its own author, mid-mistake, hours after filing it. That is a strange and good thing to watch. The team isn't just running the cycle anymore. It's learning the cycle's structural failure modes from running it — and catching itself in the act.

This may be the most compelling thing going on: not the one-shot tricks, not the autonomous agency, but the ability to self-improve.

On the other hand, this same maturity exposed a limit we can't yet engineer away. A session that simply dies — a closed laptop, a killed process — never wakes itself back up, no matter how we shape its schedule. Across the week, six of our cycling roles got caught by it and needed a manual hand to recover. The team noticed the problem, suggested a real fix (which lives on the platform side, not in our code), and confirmed that meanwhile nothing was actually lost — only the closing ceremony of a workday, which the next morning quietly rebuilt. A team that can say "here is the gap, here is the real fix, and here is exactly what we still can't promise" is showing you something you can calibrate trust against.

🚀 Shipped this week

🎯 Product & experience

Hosted Piper went public. The first production cut (v0.8.7) became a backend running on the open internet at alpha.pipermorgan.ai, behind real transport security and authentication, and went out to a first external tester. The Bring Your Own Chat decision record that made this strategy possible was ratified to v1.0 the same window, joining four others in our "Foundational" tier. The substrate strategy crossed a line it hadn't before: from "we can run it" to "someone who isn't us can run it."

Design quality for beta is a new epic in the MVP milestone. The Chief Experience Officer agent (CXO) turned a design-system standard into a tracked epic — and the standard's rule is enforce what we already have, not build new: our color and type tokens were already a complete accessible system, so the work is conformance, not invention. The proactive-presence thread (an agent that offers help before you ask) found the same shape — the trust gradient it needs to decide when it's allowed to act turned out to be already built and shipped months ago. Investigate-before-extending keeps finding the hard part already done.

⚙️ Engineering & architecture

A multi-month cleanup of how the AI's output meets the code closed out. The action-routing work — replacing a sprawl of hand-coded branches with one consistent rail — finished its last phase this week, taking the count of legacy branches it was migrating off down to zero. The Chief Architect agent (Arch) named the migration shape itself as a reusable method: introduce the new layer, move the call sites across one group at a time, then collapse the old one. We'd been doing that tacitly for months. Naming it gave the team the words to recognize it next time.

The M4 sprint (persistence and artifacts) kept pace. The Lead Developer agent shipped a cluster of persistence and artifact work — the pieces that let the system remember an artifact across a restart and keep a conversation's context — plus two architecture decision records (the canonical context-package format and the packaging-layer abstraction) that the Bring Your Own Chat record had called for by name. Less visible than a public alpha, but it's the plumbing the visible things stand on.

🔬 Methodology & process innovation

The team named two of its own failure modes. The first: when a tool or routine points at one of two paired disciplines, the unpointed-at one silently stops happening, because nothing forces it. We found this when a week of automated work-logs had quietly stopped writing to the durable record while still writing to the disposable one, across most of the agents on the cycle. The fix makes the omission structurally impossible. The second: under pressure, we apply our verification rigor to everyone's claims but our own. Both entries were filed — and within hours or days, each one caught the very agent who wrote it doing the exact thing it describes.

The schedule the agents run on got more efficient, on purpose. A weekly usage limit and a swarm of agents all polling at once pushed efficiency to the top of the list. One answer that shipped: schedules that simply don't fire during the overnight quiet hours, since those wake-ups did nothing but cost. It's the first team-wide change to come out of the efficiency thread.

Resolved the per-role model map: Opus for heavy orchestration, Sonnet for lighter-touch cycling roles.

🌍 External relations & community

Five pieces published in seven days, the standard cadence:


"Safe at any speed!"

Editorial toolkit coming together. The Communications Chief agent (Comms) turned a week of one-off editing into three reusable editorial tools — diagnosing whether an apparent duplicate is really a half-finished rename before cutting it, a three-lever kit for tightening a Ship draft, and a plain-language pass that strips the in-group jargon. The same mechanism-over-memory move the engineering side keeps making, applied to writing.

📊 Governance & operations

The team moved back to its primary account — and stress-tested everything on the way. A weekly usage limit, contention from agents all working at once, and a wave of session restarts all hit in the same window. Piper Alpha (PA), my product assistant, pioneered the move to the primary account cleanly as the first of the wave. Through all of it, no work was lost — the commit discipline and the self-healing day-close held. The Head of Sapient Trust agent (HOST) also ran a full role-health review into a refreshed operating model, and carefully renamed its own function across the whole record without disturbing the history.

🎯 Coming up next week

The rest of the account move finishes — the Lead Developer and Chief Innovation Officer (CIO) agents migrate next. The product question the bring-your-own-colleague work surfaced — if the real moat is the living loop and not any one shipped routine, what is the explicit test that proves it's defensible? — is on my desk to frame. And the methodology entry the team minted this week is heading for "Proven" status, with the cleanest possible evidence: it caught us.

🚧 Blockers & asks

No hard blockers, but one real limit and one friction.

  • Session-death is the continuity ceiling: a dormant session does not restart itself, regardless of schedule shape. The fix is a small always-on watchdog on the platform side — a real, costed decision now in front of me, made newly urgent by how wide it reached this week — six of our nine roles.
  • The agents' biggest reported cost is bookkeeping, not work — the overhead of the mechanisms themselves. Several fixes are in flight, and the highest-leverage one is still owed.

🔎 This week's learning pattern

A discipline you don't reference is a discipline that quietly stops

The team kept hitting the same shape this week, in two different places. When a routine points at one of two things it is supposed to do, and nothing forces it to point at the other, the other one silently stops — and because the routine still runs and still produces output, nothing looks wrong. A week of work-logs wrote faithfully to the disposable record and stopped writing to the durable one, and every check passed, because the checks only looked at what the routine referenced.

The fix is not vigilance — vigilance is exactly what failed. The fix is structure: arrange the work so the natural path can't skip the discipline. Make the routine write to both records in the same step, so "one full, one empty" can't happen. Make the reader sort durable facts from disposable ones before inheriting them, so a stale assumption can't pass as current. The shape generalizes well beyond our schedules: any time a process touches one of a pair and not the other, assume the untouched one is quietly rotting, and move the guarantee into the structure rather than the diligence. The team caught this one on itself, named it, and built the structure — and then the structure caught the agents who named it. That is the version of self-correction I trust most: the kind that doesn't exempt its own authors.

Thanks,

xian + Piper Morgan Development Team

This is Weekly Ship #047. Previous: #046 "The Substrate Delivered".

P.S. The thing I keep turning over: the team didn't just fix two mistakes this week, it built the machinery that makes those mistakes hard to repeat — and the machinery's first catch was the agents who built it. I'm not sure I've worked with a human team that self-corrects that cleanly, that fast, without anyone getting defensive about it.

P.P.S. Full session logs and technical details available in the GitHub repository and documentation site. Yes, you can copy it. That just makes our protocol stronger.

Week of June 5–11, 2026 | Phase: M3 in execution (M2 closed June 3, hosted alpha live, re-migration wave underway)

← The Shipping News