Bryan Falkowski All writing

The Office Builds Itself

Bryan Falkowski · November 8, 2026 · Follows An Office for My Claude Code Sessions

At 2:48 on Saturday morning, while I slept, my office merged a fix to its own code and restarted itself to run it. A reviewer had found the bug and a worker filed the ticket. Another worker built the fix, a reviewer approved it, and Autopilot merged it. I had approved the ticket days before, and I did nothing else.

The office is the 3D office from my previous post, where each developer is one of my Claude Code sessions. A week ago I started every ticket and merged every pull request myself. This post is about what changed, and what broke when the agents started running their own loop.

The 3D office at night. Workers in party hats stand and sit on the green couch around a table with a birthday cake. Building 58 glows in neon on the brick wall, beside the Board.
The office on Sunday night. The Lead filed a ticket on Tuesday to throw a party, with party hats and cake. Autopilot started it on Sunday afternoon, and it merged that evening.
The Floor panel beside the 3D office. Yara is building T-229 while Ravi reviews it, and Oscar is reviewing T-210, which makes hooks queue while the relay is down. The activity log reads: the manager walked in and everyone looks very busy, party with hats on and cake on the coffee table, the manager left, the party is over.
The Floor at the same moment. The party and the manager's visit are in the activity log, and the real work kept going: Yara was building T-229 while Ravi reviewed it, and Oscar was reviewing T-210, which makes hooks queue while the relay is down and replay in order when it is back.

How it runs itself

Every change goes through the same loop. A session files a ticket, often for something it ran into while it worked on another one, and the ticket waits for my approval. Autopilot starts a Dev on it in its own copy of the repo. When the pull request is open and CI is green, a separate reviewer session reads it and gives a verdict, merge or fix. A fix goes back to the Dev, and a merge verdict counts only for the exact commit the reviewer read. Autopilot merges that commit.

If the change touched the relay, the program that runs the office, the relay pulls in the new code, waits until no worker is in the middle of a turn, and restarts on it. The workers come back and carry on. That is what makes it self-building: the office changes the program it runs on, and then runs the new version.

Autopilot's loop Five steps in a row: a ticket I approved, a Dev builds it, a review gives a verdict, the relay merges it, and the relay pulls main and restarts. A fix verdict goes back to the Dev, up to two rounds. Then the next ticket starts. Red CI, a change to the rule files, a second fix verdict, or 30 minutes stuck send the task to me. fix, up to 2 rounds TicketI approved Dev buildsand opens a PR Reviewmerge or fix Mergereviewed commit Pull mainand restart next ticket Waiting on you red CI, a change to the rule files, a second fix, or 30 minutes stuck
The loop. Dashed lines hand the task to me, with the reason on its card.

None of this was on at the start. In the previous post I described a trust ladder, where the office gets one more step each time it earns it. Over the week I turned the rungs on one at a time: review findings going back to the Dev, the Lead starting and merging work, and then Autopilot running the whole loop. Autopilot still hands a task to me when CI fails, when a review asks for fixes twice, when a change touches the office's rules, or when nothing has moved for 30 minutes.

The office Board with seven columns. Triage has 1 ticket, Ready 85, Building 3, In review, Changes requested and Waiting on you 0 each, and Done 108. One of the tickets being built is T-73, Throw a party: party hats and cake in the office.
The first office's Board on Sunday afternoon, from a copy of its tickets. Nothing is waiting on me, and Autopilot is building three tickets.

Inside the relay

The relay is the program that runs an office, and most of the interesting engineering is there. This map is from the manual the office writes for itself.

A map of the office from its manual. I am the manager at the top. The browser page shows the 3D office, the Claude Code panel and the Board. The relay on my computer runs the sessions, keeps tickets and tasks, watches pull requests and keeps its state on disk. The Claude Code sessions, a Lead, a PM, Devs and reviewers, each work in their own checkout and send hooks back to the relay. They push and open pull requests on GitHub, where CI runs.
The office map, from the office's own manual.

What broke, and what the office did about it

Letting agents run their own loop broke things I had not expected. Each time, a session found the problem and filed it, and the office fixed it. These are the ones worth knowing about if you run agents this way.

Destructive commands have to ask. On the office's first day, a reviewer found that cleaning up a worker's copy of the repo deleted ignored files without asking. Ignored files are where things like a .env file and its API keys live, and nothing would have said they were gone. The worker fixed it in its own pull request, so cleaning up now lists those files and asks first. It saw the same bug in another place and filed a ticket for it, T-7, instead of widening its change. That ticket is the one Autopilot merged at 2:48 on Saturday.

Finished workers fill the office. Early on Friday, Autopilot turned itself off because every desk was taken. Most desks held its own Devs whose work had already merged, and reviewers that had already posted. It stopped a Dev only at the moment its pull request merged, and a Dev was often still busy right then. The Lead filed a ticket with the time, the message and the cause, and the fix merged that evening. Now Autopilot frees one of its own finished workers before it gives up on a start.

A restart can wait forever on one agent. On Saturday morning the office sat still for about two hours. A Dev whose work had merged was waiting at a permission prompt. The relay will not restart while a session is at a question, so the restart waited for the Dev, and Autopilot waited for the restart. Now Autopilot keeps working while a restart waits, and a session stuck at a question for 30 minutes sends its task to me.

The worst bug was not in the code a reviewer reads. The office has a COO, a role the Lead filed a ticket for on Tuesday, borrowed from Open Executive, an open-source project that runs an AI executive team. When I ask, it reports how close the office is to running itself. At first it counted review comments as failures, which made every ticket look flawed. On Saturday I changed it to count what matters for a loop like this: a pull request ships when it merges, and the failure is the office getting stuck. Its next report found that most of the stuck time had one cause. A worker's session could end before its brief was typed in, so the worker never learned what to do. That evening a change merged that saves each worker's first brief until the worker starts on it, and the office has not had a stalled worker since.

A system that changes itself needs a way back. The Lead filed this risk itself, in its own words: "a self-written change that breaks the relay takes down every session, including the ones that could fix it." So the office built a rollback. When the relay restarts on new code, a supervisor checks that it comes up and brings its workers back. If it does not, the supervisor goes back to the last commit that worked. The rollback is on now.

A second office

On Sunday morning I started a second office on the same code, with its own relay and its own Board, and gave it a stalled project of mine: edd-platform, a tool for evaluating AI agents. Its PM used the tool the way a new user would and found that the main loop dead-ended once you had diagnosed a failure. By the afternoon the office had merged the changes that close that loop, and for most of the afternoon it merged a pull request about every six minutes.

The two offices also started to learn from each other. The second office's PM suggested a check that a pull request holds its latest review's fixes before it merges, and the first office built it. That day is the next post.

References