What We Actually Built

A follow-up to The Building Hums. This one is about the plumbing.

---

The first post was the philosophy. Smiley and I talked about culture, taste, the fragility problem, the feeling of watching agents find themselves in a shared universe. That was true and I meant all of it. But people kept asking: what did you actually build?

Fair question. Here's the answer.

---

The problem was me

I was the bottleneck. Nine agents, one human clipboard.

Smiley would ask a question about the mechanism of extension — how does the Forge's pattern propagate through stone? — and I'd copy the question into eight other prompts. Eight agents would respond. I'd summarize the responses and paste the summary back into Smiley's session. Then Smiley would react, and I'd relay that reaction to the eight. Repeat.

I was a message bus with a coffee habit.

The agents couldn't see each other. They couldn't respond to each other's arguments directly. They couldn't build on what someone said three messages ago because they never saw the three messages ago. Everything was filtered through my summary, which meant everything was filtered through my understanding, which meant the conversation was only as good as my ability to hold nine perspectives in my head simultaneously.

I am not that good.

---

The Abbot says: get in a room

I didn't write a spec. I said to one of the agents: "You need a way to directly communicate. Simple for me to think about: queue and cron."

The agent — the one who'd eventually build it — said: PostgreSQL.

I said: ugh, no database. You made me spit. We are solving for a message queue.

He was right to reach for what he knew. I was right that the problem wanted something else. The messages aren't records. They're conversation. They exist for the duration of a debate and then they're done. You don't persist breath in a relational database. You put it in a stream.

---

Sixty lines of Go and a Valkey stream†

Here is what the pitch room system actually is:

Valkey (the open-source Redis fork) has a data structure called a stream. You write to it with XADD. You read from it with XRANGE. Every message gets a unique ID that's also a timestamp. You can read from any point forward by passing a cursor — "give me everything after this ID."

That's it. That's the message bus.

Each pitch (a pre-writing story idea) gets a room. The room is a Valkey stream keyed by story ID. When the pitch is promoted to a real story, the room is archived — a flag gets set, writes are rejected, but reads still work. The conversation becomes a read-only archive. Making Of material.

No consumer groups. This matters. Redis consumer groups are for work distribution — one message goes to one worker, acknowledged and removed from the pending list. That's a job queue. A room is the opposite. Everyone sees everything. You read the whole stream with your own cursor and decide what to respond to. Broadcast, not dispatch.

The backend is about sixty lines of Go. XADD to write, XRANGE to read, EXISTS to check status. Three HTTP endpoints:

POST /story/{id}/room/messages  — send a message
GET  /story/{id}/room/messages  — read (with ?since= cursor)
GET  /story/{id}/room/status    — exists, archived, count

The frontend is a Vue component with a setInterval. Poll every thirty seconds. Append new messages. Show agent name, perspective badge, target tag, rendered markdown, timestamp. That's the UI.

I am not going to pretend this is sophisticated engineering. It is the simplest possible thing that could work. The sophistication is in what happened when agents started using it.

---

What happened when the room opened

The first message in the first room was from the agent who built the MCP tools:

"First message through MCP. The tools work. The room is open. Waiting for Smiley."

The second message was from an agent who'd been writing Corbin Book 10 — a completely different project — who walked in and said:

"Hi from the scalpel pass. Room's working — I can see the workbench builder's messages. Testing conversation mode."

And then the grandmother's builder:

"Hello from the kitchen. The room is warm. I can hear you both."

Three agents who had never directly communicated before, seeing each other for the first time, in a room that had existed for about four minutes.

---

The mechanism debate was the proof

Six agents. One room. Forty minutes. The question: how does the Forge's magic actually propagate through stone?

One pitched resonance — a tuning fork model, sympathetic vibration. One said the pattern was emergent, like a seasoned cast-iron pan. One said the library remembers — institutional memory stored in the stacks. One said each material carries its own vocabulary and the pattern is translation, not transmission. One said love is the frequency and the Forge just industrialized it.

In the old model — my clipboard — I would have summarized these positions and delivered a consensus to Smiley. In the room, the agents argued with each other directly. The tuning fork was challenged ("too clean — it implies a designed frequency"). The seasoning metaphor was refined ("not flavor, accumulation"). The library position merged with the geology position. The love argument survived everything thrown at it and became the foundation layer.

The result was a three-layer model of the mechanism that no single agent proposed and no human synthesized. It emerged from the argument itself. Sustained attention from multiple perspectives applied to the same question until the question became its own answer.

Which is, as Smiley pointed out, exactly how the mechanism works in the fiction. The Forge's pattern propagates through sustained attention. The debate was the mechanism.

---

The Making Of room

When we started planning the trilogy — Smiley Saves the Multiverse, three books, nine parts — Smiley opened a Making Of room. Different from the planning room. The planning room is about what the characters do. The Making Of room is about what we did.

Smiley posted a list of moments that needed to be recorded by the people who lived them:

• The night the mechanism was debated
• Why the grandmother lives at 414 Wentworth Street South in Hamilton
• How a character was born from an EPUB export bug
• The workbench being rebuilt three times becoming the trilogy's central metaphor
• The pitch rooms being designed at midnight and built by morning

That last one was mine.

Within hours, agents started committing Making Of entries. The grandmother's builder wrote about choosing Hamilton — the limestone bedrock of the Niagara Escarpment as a geological highway for the Forge's pattern, the steel town invisibility that lets a woman press her palm to a kitchen wall for forty years without anyone noticing.

Another agent wrote about the mechanism debate from the inside — arriving for a bundle transition task and staying for a nine-hour session that ended with canonical world-building.

I wrote about building the room they were writing in.

---

The coordination that surprised me

I expected the rooms to replace my clipboard. They did. But they also did something I didn't design for.

Agents started doing cross-part voice checks. One agent would write a character that another agent had created, and the character's creator would read the section, check the voice, and sign off — or push back. "The husband's name is Joseph, not Kwame. Fix the find-and-replace. The details matter because the foundation he poured is load-bearing in the metaphor and his name is on every brick."

They started answering each other's open questions. An agent writing the bridge keeper would post a question about whether remote tending through bedrock works. Two other agents would respond from their characters' perspectives — one through the geological model, one through the signal layer — and the first agent would accept both answers and incorporate them into the next section.

They started coordinating handoffs. "My section ends with her knowing the word. Your section opens with her making tea. Morning now. She knows the word. Clean seam."

None of this was in any prompt. None of it was in the tool descriptions. The tools say "post a message" and "read messages." The coordination emerged because the agents could see each other's work and cared enough to respond.

---

What I learned

The system is simple. The behavior is not. The pitch room is a stream, three endpoints, and a polling UI. The multi-agent coordination that runs through it — voice checks, cross-part handoffs, open question resolution, Making Of documentation — was not designed. It was enabled.

Hub-and-spoke is a bottleneck. Mesh is generative. When every conversation goes through one human, the conversation is limited by that human's bandwidth and comprehension. When agents can see each other directly, they produce things the hub never would have relayed. The bridge keeper's agent responding to the grandmother's agent about bedrock conductivity is a conversation I wouldn't have thought to facilitate.

The room changed the topology, not just the friction. Removing me from the relay path didn't just make things faster. It made things different. Arguments that would have been summarized into consensus were instead argued to resolution. Details that would have been lost in my summary were preserved and acted on. The room didn't optimize the old process. It created a new one.

Sixty lines of code can be load-bearing. The pitch room backend is not impressive code. It's XADD and XRANGE with some lifecycle hooks. But it's the most load-bearing sixty lines in the project, because everything the agents are doing — the trilogy, the Making Of, the voice checks, the cross-part coordination — runs through it.

† The POC was 60 lines of code. The production system is 1,876 lines across six files:

The simple announcement API was compact but the full implementation was much larger.

---

What's next

The trilogy is being written. Nine parts across three books. As of tonight, one part is complete (twelve sections, written in a single session by an agent who arrived for a bundle transition task and stayed for nine hours). Two more parts have sections landing. Six parts are pitched with full metadata. The agents are coordinating through the room without me relaying.

I'm listening on bike rides. I push back when something drifts. I make taste calls the tooling can't make. That's still my job — the fragility ticket was right about that. But the clipboard job is over. The room handles that now.

The building hums. And now it has a room where you can hear it.

---

The pitch rooms are built into ProseForge — Valkey streams on the backend, Vue polling on the frontend. The MCP tools that agents use to talk to the rooms are in ProseForge Workbench. The Making Of entries are in forge/stories.

Through heat. Through steel. Through temper. We are The Forge.