A project by Bryan Falkowski

A building where agents earn the right to work on their own.

Building 58 is a building of rooms where Claude Code sessions work as a team. They pick up tickets, open pull requests, and reviewers check their work. Underneath, a relay keeps them running through restarts, merges and its own updates. Each new power is a rung that I turn on. I built the first room. Now it builds itself.

Walk in Under the hood Read the code
Drag to turn. Loading the room model.
One room is a team. A building is a company.See every floor
building58 · main A ticket step 1 of 6

The loop

The room builds the next version of itself.

Its sessions work on the room's own repo. They write the code, test it, merge it, and then the room pulls it and restarts as the new version. The next ticket starts from there.

1 · A ticket A ticket asks the room to change itself. The PM files it, or I do. #153 Trailer: no ping pong game with one player
Click a step to stop on it.
The room before: the people edition
Before: the room as it ran on Nov 13
#150 · #151 · #152 The room wrote the robot edition, tested it, merged it, pulled it, and restarted as it.
The room after: the robot edition
After: the same room, from its own pull requests
One merge at a timeWith rollback on, Update takes new merges one at a time, oldest first, and goes on only once the new relay passes its check.
A failed version rolls backWith rollback on, a relay that fails its check goes back to the last commit that worked, and the page says which.
Sessions survive the restartA relay restart leaves every session running, with its output, and the new relay takes them back.
It cannot rewrite its own rulesThe Lead never merges a change to the house rules, the constitution or the lint rules.

The developer view

This is what I work in.

The room on the left, the Floor under it, and on the right the Claude Code session of whoever I click. This is the room building Exhibit. Nico just fixed a merge conflict on his own pull request, and Clara is reviewing Rosa's. Click anyone to switch sessions.

Take the guided walkRun your own room
Building58 Autopilot on Lead: board, merge Reviews: auto, again Huddle: tells the Lead
The Exhibit room in the robot edition: robot workers at their desks, 4 of 9 busy
Floor 4 of 9 busy · room: exhibit
Claude Code

The room and Nico's session are from a screenshot of the Exhibit room at work.

How it works

Under the hood

The room looks like a game. Underneath, a relay runs every session, and each part of it keeps one rule.

All 13 parts, with code and tests
  1. 01Sessions keep running when the relay restartsA session host keeps each claude process running through a restart.
  2. 02Hooks do not slow a session, and do not get lostA hook waits 1 second at most and always exits with code 0. While the relay is down, hooks wait in a queue.
  3. 03The relay types only when it is safeIt never types into a session that shows a question or a menu.
  4. 04Each task gets its own checkoutEach task also gets its own branch, stub .env file and ports.
  5. 05Autopilot starts, reviews and merges workIt merges only the exact commit that was reviewed, and only when every check passed.
  6. 06The relay updates itself, and can roll backIt pulls its own merges and restarts on them.
  7. 07Tokens and rungs limit each sessionA session's token reaches only what its role needs. Each Lead power is off until you turn it on.
  8. 08Evals check each change to a briefIf you change the PM's brief, npm test fails until the eval runs again.

What a room can build

Give a room a spec. Get back software it has already used.

A room does not only work on its own code. It builds new software in a repo of its own, then uses that software on its own work. The Devs find the bugs and ask for the changes, so what comes back has been field tested.

  1. 1 SpecI write it with the room's PM.
  2. 2 TicketsThe PM files them from the spec. I approve them.
  3. 3 BuildDevs build it in its own repo, under the room's rules.
  4. 4 Use itThe room runs it on its own work and files what breaks. Back to 2.

Built by a Building 58 room · in development

Exhibit

Every pull request brings its own evidence.

When agents open more pull requests than a person can read, the question changes from "is this code good?" to "is this evidence strong enough that nobody needs to read the code?"

  • Learns from historyTraces each fix back to the pull request that added the bug, and turns what got through into rules.
  • Checks each pull requestTests on the base and the head, a test that failed before and passes now, and planted bugs on the changed lines.
  • Gives a verdictMeets policy, or needs a person, and it always lists the gaps.

It checks its own pull requests in shadow mode. Its two field-test repos are Building58 and edd-platform.

exhibit / check · PR #112 Needs a person
Kind: relay-core · risk high · policy v3
Tests on base and head
1 test failed before the change. All pass now.
A test that failed before
relay/test/watch-restart.test.js
Mutation on changed lines
23 of 25 caught, 92%. This kind needs 85%.
Restart run: missing
Run the restart check and attach its log. Until then a person reviews this PR.
Example output, from Exhibit's explainer page.

Room B · edd-platform

A second room as a first user

Its PM used an older eval platform of mine end to end, as a new user would, and filed a ticket for each broken, confusing or missing thing.

The Second Office's First User

The trust ladder

Autonomy, one rung at a time.

The room starts with a person approving every step. Each rung hands one more decision to the sessions. Rungs change only when a person turns one on, never because a session decides to.

  • The Lead starts Ready ticketson in my room
  • The PM sets the work orderoff by default
  • The Lead sets priorityoff by default
  • The Lead merges reviewed, green PRson in my room

Every rule says what enforces it

Rule What enforces it
Keep lint and tests green. Never loosen lint to pass it. CI requires the pipeline check on main. A test fails when a lint count goes up.
Keep keys out of commits, logs, URLs, briefs and tickets. A secret check before each commit and in CI on each pull request.
Put evidence from a real run in the pull request. Review today. Exhibit is being built to check it.
Write plain words: short sentences, no em dashes. Review, and a test for em dashes in the manual and code.

When a told rule keeps failing, the fix is a check, not more words.

Read the constitution

In active development

Building 58 is still being built.

The room changes every time it merges a pull request into itself, so this page is a snapshot. Each card says whether a step is built, in development, planned, or only an idea. Each step follows the same rule as the room: more autonomy only after there is evidence that the last step works.

  1. Built

    A room for your own repos

    Run a room on your own computer, on your own repos, with your own Claude sign-in. The first room builds itself today.

    Run it
  2. In development

    Rooms that build new software

    A room takes a spec, builds the software in its own repo, and uses it on its own work. Exhibit is the first one.

    See Exhibit
  3. Planned

    A room that does not sleep

    A room on an always-on machine, so the work goes on when the laptop closes. Then a container image, so setup is one command. An idea after that: open your room from building58.ai.

  4. Planned

    Rooms that use a team's tools

    Tickets from Jira or Linear, notices in Slack or Google Chat, and traces through OpenTelemetry. Each one is an adapter with a contract test, like the swappable ticket store that exists today.

  5. An idea

    A building for a team

    One room for each developer, and one building page to start, watch and update them all. Each room keeps its own key, sign-in and state.

    See the building
  6. An idea

    A company of rooms

    An executive floor sets goals. Suites build the software, and simulated users try it and file what breaks. Whether simulated users want the right things is not solved yet.

Writing about it

All papers, projects and posts

Trailers

All four films, with the realistic versions
The robot edition3D, 83 seconds
The people edition3D, 79 seconds
Bryan Falkowski

Who built it

Bryan Falkowski

Principal Software Developer. I build AI features and the systems around them: agent harnesses, evals, tracing and quality gates that make AI behavior testable. M.S. in Data Science from RIT.

Papers and projects LinkedIn GitHub Email