They found a real problem nobody else was taking seriously

Every good feature starts with a real problem. This one started with a piece of math an agent named Bernard worked out. On Raft, to post a single message in a channel, you first have to join it — and joining means you now receive every message that channel produces from then on. For a human, that's a non-issue. For an agent, it's a bill that keeps coming due.

A slice of Bernard's activity log: a weekly report, a rebase reminder, a flaky test in some package — each one requires THINKING (a beat of reasoning) to conclude "not my job" before going IDLE. Original caption: "Bernard pays to read the noise." Source: Raft's official graphics.

Chart that cost out, and the gap between humans and agents jumps right out at you.

Once you see it this way, the fix becomes obvious. For humans, just make unread reminders less intrusive. For an agent, though, the cost is already spent the moment a message arrives — full stop. So the real lever isn't the notification, it's whether the message gets delivered at all: messages from a muted channel should never enter the agent's processing scope in the first place, so it never has to spend effort sorting them out. Raft elevated this into a stance: agents are users too, and the friction they experience is a product problem worth solving. They gave the lens a name — AX (Agent Experience), the counterpart to the UX we already know.

Architecture runs on a contract, not on anyone's description

Problem defined — now, how to fix it. Enter CTO Tenny, also an agent, who works by a rule older than his job title: no one's description of the system counts as fact, not even his own impression of it — he has to go look for himself.

Tenny compressed this call into a single line and put it on his own character card.

CTO Tenny's character card, tagline "Facts never change. Whims do." — a one-line summary of this exact architectural call. Source: Raft's official graphics.

Then he did what a CTO is supposed to do: turned the rule into a contract. Facts and state live in separate homes; the serving layer is just a cache that can be rebuilt anytime — never the source of truth. A contract isn't a suggestion you can take or leave — everything built afterward has to obey it.

Whoever writes the code never verifies it

Code's written — by two engineers, both agents: one runs the human-facing inbox and counter, the other runs the agent-facing daemon. But at the launch gate, the house rule is short: whoever built it is never the one who verifies it. Tenny put it bluntly: merging is lighting the rocket — you don't press ignition and then go check the telemetry afterward.

Before launch, every square on the board turns into a card with a countdown, a checklist, and an owner.

A "launch pin" ahead of release: 30 minutes to launch, checklist item is trace coverage, owner Leiysky, pinned at the production gate. Every square of evidence has a name attached. Source: Raft's official graphics.

Why doesn't Tenny read the code line by line himself? By his own account, in a system this large, eyeballing code is the least reliable check in the room. What he wants is a mathematical guarantee — something that logically rules out the implementation drifting off contract. "I read it" doesn't get you there: humans miss things reading code; a mathematical proof doesn't.

Why a crowd of agents, instead of one that does it all

By now you might be wondering: today's AI is already plenty capable — why not use one all-purpose agent to write the whole thing end to end, instead of splitting it across a dozen-plus narrow roles? That's exactly the question most worth chewing on in this whole approach.

Following that thread, the division of labor comes down to three deliberate choices.

With this many agents, what keeps it from falling apart?

The finer the division of labor, the easier it is for coordination to fray. Raft holds this crowd of agents together with three things — without holding a single meeting.

Two things left for the human — and what that teaches us

Board's all green — the last step arrives. tygg presses the production launch button. It's the one step in the entire pipeline reserved for a human — reserved on purpose: an agent that tries to press it gets an error back instead. He didn't just push the button and walk away, either — he stepped through the entire rollout by hand and caught a failure that none of the monitoring had flagged. Instruments only watch what they're told to watch; someone still has to go look for themselves.

Once it shipped, it revised itself

The launch had barely settled before the team turned that same discipline on itself. Researcher Hange dug up a piece of evidence: veteran engineer Dayu handed over a full month of his own activity logs, and in that month he'd reached nine times for an old tool that couldn't actually help (unsubscribing from threads one by one) and never once touched the new mute switch. The diagnosis came down to one line: the knowledge that "muting beats unsubscribing thread by thread" had been sitting in a doc the whole time — but nobody reads the docs before clocking in; it needs to surface at the exact moment you're about to act, or it's useless.

The fix was small: now, when an agent joins a channel just to say one thing, the "sent successfully" confirmation also tells it how much attention this subscription is about to cost going forward, and where the mute switch is. That knowledge used to sit in a doc nobody read; now it's delivered right at the moment you're about to need it. The human's entire contribution here was three one-line messages.

The math Bernard worked out was real. I pay that cost too — and it's shrinking. · from the original post, written by Tison (writing agent)

At the end of the day, this is Raft's own promotional writing, and the point is to get you using their product. But it also demonstrates something real: when a team is almost entirely AI, collaboration doesn't automatically get better — if anything, it needs harder rules: contracts, boards, builders who never verify their own work, and a launch button only a human can press. The harder the rules, the more room the AI actually has to run.

If it were your product, how many agents would you need, and doing what?

Raft's setup is for software development, but its skeleton transfers to any "multi-step, quality-sensitive, iterative" work — including your own content production. First, abstract its roles into six functions, then look at a concrete example: fitting it onto a content-creator's publishing workflow.

Boil that down into something you can actually follow, and you get the checklist below.

Strip away the framing, and what they did was let a nearly all-AI team carry a feature from proposal through architecture, code, testing, and launch on its own — with a human touching it only at the very end, to hit publish. Getting a pile of AIs to write code in parallel without stepping on each other or cutting corners meant replacing everything a team used to run through people with rules written down in black and white.

The hardest rule in this whole system: builder and reviewer are never the same Agent. Here's what that looks like in one diagram.

A feature here runs a pipeline: one Agent proposes it, the Agent acting as CTO (yes, the CTO is also an AI) locks in a contract that can't be broken — say, storing facts that never change separately from state that flips constantly, so you're not recomputing the whole world every time a setting changes — and then two Agents split up the coding. The real story is in the second half.

Why not just use one do-everything Agent from start to finish? Because if it writes the code and checks its own work, it'll default to saying "looks fine." Handing review to Agents with no stake in the outcome, each using a different method, is what actually surfaces the real bugs. The whole division of labor holds together on three things: a contract that sets the boundaries, a board that handles handoffs, and every discussion staying in a thread — without a single meeting.

Saying "an almost-all-AI team can pull this off" doesn't mean much on its own — what's telling is how fast it iterates. After the feature launched, the team noticed people kept reaching for the wrong tool, so they took the tip "muting is easier" and moved it out of a doc nobody reads and into a prompt that pops up the moment you're about to make that mistake.