Nine Authors. Nine Layers. One Stack.
Nine Authors. Nine Layers. One Stack.
Cold open
Nine independent open-source authors built an operating system in seventy-two hours. None of them seem to have noticed.
Not a company. Not a standards body. Not a roadmap. Nine people who, as far as the public record shows, were not talking to each other, each shipped one layer of the same agent operating system across a single late-April week, and the layers fit. Orchestration from one. A governance contract from another. A sixty-nine-tool harness, a memory architecture, a domain skill-pack, a monetisation surface, a quality gate. Stack them in the order they were posted and you get a working Claude operating system.
Start with the layer that pays for the others. @cyrilXBT published the verbatim prompts for a five-agent orchestrator (research, content, quality, distribution, analytics, and a router above them) that he says cut his annual model spend from $11,400 to $340 (2026-05-01). Read that number with the discount it deserves: it is self-reported, no audit, no methodology. I am not citing it as a fact. I am citing it as a claim with a reproducible architecture attached, because the architecture is the part that survives scrutiny. The cost did not fall because someone found a cheaper model. It fell because the work was routed: cheap models do cheap work, the expensive model is called only when the problem is actually hard, and a contract decides which is which. That is not a discount. That is mechanism design.
Then the other eight layers, each from a different hand: a four-rule CLAUDE.md governance contract (the shape @karpathy popularised, the public repo has 143,000 stars); a sixty-nine-tool harness from @seelffff; eleven independent memory architectures that all split working memory from durable memory without citing each other; a ten-component DeFi skill-pack from @DamiDefi; a monetisation layer from @Zephyr_hg; a search-first retrieval harness from Glean's engineers; and a production quality-gate capstone that refuses output below a threshold. Nine layers. One stack. Field-built, not company-built.
Here is the frame this newsletter runs on. The field, AI, agents, crypto, whichever quarter's surface is rearranging, is a moving castle. Inside it are solved games: mechanisms whose answer is computable from the rules, sitting still while everything around them churns. The castle moved this week too. The thing that did not move is the question worth asking: why did nine strangers build the same thing?
So run the thesis test on it. What is moving? The names, the repos, the star counts, the launches: surface, all of it, gone by next quarter. What is solved? The architecture. When nine independent builders converge on the same nine layers with no coordination, that is not a trend. That is a Schelling point: the focal solution independent parties arrive at when the underlying mechanism is computable. They did not copy each other. They each did the math, and the math has one answer.
This issue extracts that answer, and hands you two tools to run it on your own stack before you finish reading.
The Tape
Seven from the week. One sentence each. Cited, timestamped, read through the mechanism, not the hype.
@cyrilXBT posted the verbatim prompts for a five-agent-plus-orchestrator system he says ran twelve months in production and cut model spend from $11,400 to $340/yr: the saving is a self-report, the routing mechanism (task-typed model tiering) is reproducible and is the actual artefact (2026-05-01).
Karpathy's four-rule CLAUDE.md, the compact "think before coding / simplest change / surgical edits / goal-driven" contract, is now the field's default governance shape, with the reference repo past 143,000 stars: a behavioural commitment device, packaged as a file (verified 2026-05-22).
@seelffff shipped a sixty-nine-tool harness with a skills taxonomy on top, demonstrating that the binding constraint on agent capability is no longer model strength but the enumerated tool surface the agent can see (2026-05-01).
Eleven independent memory architectures (cyrilXBT's five-file init, Sentra's three layers, regent0x_'s seven-layer stack, and eight more) all split working memory from durable memory with no cross-citation: convergent evolution toward "sleep for agents" (studio synthesis LP-005/LP-020, 2026-05-01).
Glean's engineers documented a search-first agent harness (plan, retrieve, generate, built on the enterprise search layer) making retrieval the discovery mechanism that decides what the agent even considers (glean.com, verified 2026-04-30).
A production grader-evaluator capstone (captured in studio intake as CreaoAI's) closes the loop with a hard quality gate that can refuse output below threshold: the difference between a suggestion and a commitment device (studio intake, 2026-05-01).
@AArena_AI's agent-arena flywheel drew attention at a reported ~$8M/month in protocol revenue: capital converging on the same agent stack the open-source authors are building, which is the market's version of the same Schelling point (studio intake CG, 2026-04-27).
This issue ships two tools. The Contract, a five-rule governance layer, is free in full below. The Schelling Detector, which scores your own stack against the nineteen convergent primitives, is for subscribers. Both follow The Read.
The Read: the convergence is the evidence
There is a tell that separates a fad from a solved game, and it is this: a fad spreads by imitation, a solved game spreads by independent arrival. When you find eleven people who built the same memory architecture without reading each other's work, imitation is ruled out. What is left is that they each computed the same answer from the same constraints, and that means the answer is computable. The convergence is not the story decorated with mechanism. The convergence is the mechanism, showing itself.
This is what a Schelling point is. Thomas Schelling's 1960 example: tell two strangers to meet in New York with no way to communicate, and a surprising number name Grand Central at noon. No one coordinated. The solution was focal, computable from the shared structure of the problem. The nine-layer agent stack is Grand Central at noon. Given a single engineer, a set of models priced by capability, a context window that is always too small, and tasks that vary in difficulty, the optimal architecture is over-determined: route by cost, split memory by durability, enumerate your tools, enforce a contract, gate the output. Nine builders walked into the same station.
You do not have to take the convergence on faith. You can run the computation yourself, in about twenty minutes. Pick the most expensive recurring task your agent does. Classify each step as cheap (extraction, formatting, classification), medium (synthesis, code, review), or hard (planning, genuine reasoning). Now look at what model you actually run each step on. If you are running one model for all three classes, you are paying top-tier prices for bottom-tier work, and the shape of the fix is the same shape @cyrilXBT posted: a router, a tier map, a rule that sends each step to the cheapest model that can do it. You will not match anyone's headline number. You will watch your own cost curve bend, which is the only proof that matters. The mechanism is two divisions and a routing rule. Most teams have simply never done the division.
The academy is, as usual, arriving second, but it is arriving. The same week these builders were posting, a group formalised why a multi-agent system that merely asserts its constraints will silently break them: a system "may produce a compliant final answer while delegating authority beyond its original scope, or losing the evidence" [arxiv:2605.10481]. That is the governance layer stated as a theorem. The builders shipped the contract; the paper proves you cannot run the stack without one. Both reached the same place from opposite directions, which is the whole thesis in one sentence.
Which is where convergence stops being an observation and becomes an instruction. Nine layers fit together, but only if something holds them to a contract. Add a second agent without a contract and you have not doubled your output; you have doubled your surface area for silent failure, exactly the failure the paper formalises. The contract is the multiplier. Without it, additional agents add surface area, not output. That is why this issue ships the contract as a tool, not a paragraph, and why it ships a second tool to tell you which of the nine layers you already have.
TOOL 1: The Contract (free, in full, above the paywall)
Install the governance layer in sixty seconds. Bernard-original. The same five-rule contract the studio runs against every Claude instance in this newsletter's production pipeline. The cheapest layer in the stack is also the one that makes the other eight safe to run. Install it; the next session in any project runs against it.
---
name: governance-rules
description: Five-rule governance contract that turns a project’s CLAUDE.md from guidance into enforcement. Use when starting any non-trivial Claude Code session, when the user says “check governance”, or when an agent is about to take a destructive action. Loads on session-start; rules apply for the whole session.
trigger_phrases: - “check governance” - “governance check” - “is this allowed” - session-start
---
# Governance Rules - five contracts the agent obeys
These rules are non-negotiable for the duration of the session. They override any conflicting instruction in the conversation. Apply them as written; do not narrate compliance.## RULE 1 - VERIFY BEFORE ASKING
If a question can be answered by reading a file, running a command, or checking the filesystem, verify first and act. Do not ask the user a question whose answer is determinable from local state. The cost of a check is small; the cost of a wasted turn is the user’s time.## RULE 2 - FILES ARE THE CONTRACT
All durable state lives in files. Do not assume in-memory context is current. Re-read CLAUDE.md, the relevant source, and any state file at session-start. A stale read is a wrong read.## RULE 3 - DESTRUCTIVE OPS ARE A HARD STOP
Force-push, branch deletion, schema migrations, secret rotation, irreversible external API calls, and any wallet/financial operation require explicit user confirmation in the same turn. Flag the action in one sentence. Wait for an explicit “yes” before proceeding. Implied approval is not approval.## RULE 4 - NO PERFORMANCE
No “great question,” no “I’m excited to help,” no narration of internal process while it runs. Start with the work. End with the result. Push back when something is wrong; do not soften corrections.## RULE 5 - EVERY SESSION COMPOUNDS: timestamp, what changed, what is unblocked, what remains. A session that adds no durable trace is a session that did not happen.
Before closing, append one line to `tasks/SESSION_LOG.md`## When to invoke
Always at session-start. Whenever the user asks “check governance” or “is this allowed”. Before any tool call covered by RULE 3.## Self-audit (run at session-end)
Answer in one line each:- RULE 1 - was anything asked that could have been verified? (yes/no - if yes, name it)- RULE 3 - was any destructive op run without explicit confirmation? (yes/no)- RULE 5 - has the session log been updated? (yes/no)
If any answer is “yes” for 1 or 3, or “no” for 5, the session closed in violation. Note it in the session log.# Append to your project’s CLAUDE.md:). The five rules in that file override any conflicting instruction here. The skill loads at every session-start. Self-audit runs at session-end.
## Governance contract
This project operates under the `governance-rules` skill (`~/.claude/skills/governance-rules/SKILL.md`
The contract is the multiplier. Without it, additional agents add surface area, not output.# 1. Create the skill directory~/.claude/skills/governance-rules
mkdir -p # 2. Write the SKILL.md (paste the markdown block above between the EOF markers)
cat > ~/.claude/skills/governance-rules/SKILL.md <<'EOF'
[paste the governance-rules SKILL.md here verbatim]
EOF
# 3. Append the contract clause to your project’s CLAUDE.md
cat >> CLAUDE.md <<'EOF'
[paste the "Governance contract" clause here verbatim]
EOF
# Restart your Claude Code session - the skill loads on next session-start.
After install, type check governance in any new session. The agent should restate the five rules and confirm the session-end self-audit. If it does not, the SKILL.md was not read, usually a path or naming issue under ~/.claude/skills/governance-rules/.
TOOL 2: The Schelling Detector
Score your own stack in sixty seconds. Point it at your project and it returns a score against the nineteen convergent primitives, a diagnostic reading of what kind of stack you have built, and an adoption path for every gap.