an invented hotel · a real file · 2,839 agents
A leak in room 407
rewrote the rule at the top.
None of them are people. The attendant, the engineer, the executive who amended the standard: all software, running in an invented hotel, because a hotel is an organisation everyone already understands. What is real is the file underneath. Booboo reads a fleet of agents out of one file and draws the organisation they have quietly formed. Everything moving behind this text is that file, rendering live.
I · what you are looking at
Every point of light here is one of them, and where it sits is its job.
Room Attendant 07 is one of 2,839 nodes in this file, sitting four levels below the standard it was obeying. Every node has exactly one parent. That parent is the authority it answers to, which means the chart is not describing the chain of command, it is holding it. Move an agent under a different head and the next time it starts up, it obeys someone new.
Nobody drew this. It is read from the file, every single time.
The hotel is invented. The problem it stands in for is not: you added one agent, then a few more, and now something in your stack is doing work that nobody can see the shape of. The same file format takes your estate instead of this one, and everything below is how that works.
II · how it is arranged
The estate is arranged in four layers, and nothing floats.
Each layer is a level of the chain of command. Reading downward tells you who inherits from whom; reading upward tells you where a problem goes when it is bigger than the agent that found it.
The root
One agent sits at the top, and it holds a single written standard. Everything below inherits that standard automatically, which means it only has to be declared once, and it can only be changed here.
The heads
Eighteen department heads sit under the root. Each one owns a policy for its own area, and each one is where an escalation from below actually lands.
The workers
Below the heads are the agents that do the work: the ones that open the door, run the job, and notice when something is wrong. This is where most of the activity happens.
The record
2,717 of the 2,839 nodes are things the fleet has written down. The record is larger than the organisation because an organisation does a little and remembers a lot.
III · how an agent uses it
An agent reads the organisation before it does anything else.
The first call an agent makes in a session is booboo_boot with its own id. What comes back is its position in the estate: who it is, who it answers to, the rules it inherits from every level above it, the memory it is allowed to reach, and the agents beneath it.
the first call of every session
booboo_boot("agent:housekeeping-room-attendant-07")returns its identity, its authority chain up to the root, every rule it inherits in boot order, the memory buckets it may read, and its own children.
This matters more than it first sounds. An agent that skips this step begins every session with no idea what it is permitted to touch, and you tend to discover that at the moment it touches something it should not have. Booting from the organisation means the rules arrive before the work does.
IV · following one thing all the way up
The whole claim comes down to four nodes and one link.
Four stops, in order, from the rule at the top of the house to the puddle on the floor of room 407. Between them the camera flies the real chain of command, and every node it passes on the way is a row in the same file: the executive, the floor supervisor, the ledger the incident was filed into.
The standard
This is the root of the whole estate: one written rule that every agent below inherits. Nothing else in the graph is allowed to change it, which is what makes the rest of this story worth telling.
The department head
Housekeeping is one of the eighteen agents reporting to the root. It inherits the standard without being sent it, and anything its team escalates arrives here first.
Room Attendant 07
Four levels below the standard is the agent that actually does the job. It has never been told the rule directly; it inherited it through the chain you are looking at.
The leak in room 407
It found standing water at turndown and filed it rather than mentioning it. Because it was filed, engineering picked it up, and by the morning the standard at the top had been amended.
Of the 397 links in this file, exactly one is an amends, and it runs from the executive back up to the standard at the root. That single edge is the whole argument: the bottom of the organisation changed the top, and you can point at the place where it happened.
None of that survives unless the agent writes it down.
Two calls do that work. booboo_report records what an agent has just closed, and booboo_remember stores a single durable fact it learned. Both are written to a journal that sits beside the snapshot, which means they can be read back in the same session and they survive every rebuild afterwards.
The effect is that work stops quietly disappearing. Every report lands on one timeline you can filter by agent, so asking what the fleet actually did last week is a query rather than an excavation.
V · what you actually open
The graph is the proof. The panel is where the work happens.
Five tabs over the same one org file and one snapshot: organigram, buckets, reports, rules, and the graph itself, embedded. Three of them, below. Scroll to move sideways through them.
Root on top, departments fanning beneath. Drag an agent onto a new parent and the org file changes. Versioned in git, a cycle rejected before it ever writes.
Every agent's filed reports on one timeline, newest first, filterable per agent. This is booboo_report landing somewhere a person can actually read it.
Each memory bucket with a live count and the agents allowed to reach it, so “what does this agent actually know” is a glance, not a grep.
Rules inherit top-down here too: declare one at a branch in the organigram and everything beneath it is bound, and every dossier in the panel shows the inherited stack in the order it was picked up.
VI · the same brain, as plain files
Nothing here is locked to this renderer.
booboo vault emits the same snapshot as a wiki-linked markdown vault: one page per node, plain text, readable by any human and any agent from any provider. Point Obsidian at the folder and it is a second brain that nobody had to build by hand, on the right of this paragraph.
That works because the format underneath is small on purpose. Your data becomes this graph through one file and a short adapter, not a migration.
Whatever you already have: a Postgres table, a CRM export, a folder of support tickets.
A roughly 50-line script mapping your fields onto the spec. A translation layer, not a fork of Booboo.
One file. Nodes, edges, a root. Small enough that a person can still read it end to end.
The viewer, the REST API and the MCP server all read that one file, free the moment it validates.
VII · why it stays true
Nobody keeps this diagram up to date.
That is the point of it, rather than an admission. The picture is never drawn: it is read out of the file each time, and the file is the same one the agents are already writing to as they work. A diagram maintained by hand is wrong within a fortnight, because the system keeps changing and the drawing does not. This one changes when the system does, because maintaining it is a by-product of the fleet running.
Rules behave the same way. Declare one at a branch and everything beneath it inherits that rule in boot order, without anyone copying it downward or remembering to.
WIRING
Which parts call which other parts, so that a broken link is something you can look up rather than something you find out at three in the morning.
MEMORY
What the system knows between runs, held per bucket, including which of it has gone stale.
AGENTS
Who does the work, who they answer to, and what each one is permitted to touch on your behalf.
CRONS
Everything on a timer, including the jobs nobody remembers switching on.
the one command
npx @booboo-brain/cli view --demo --nodes 1000000No database, no config, no signup. Drop to 50,000 on a modest laptop.
The renderer that command opens is built for these three, not the 2,839 nodes on this page. Same architecture throughout: one GPU point field, one draw call, positions in a flat Float32Array, and labels only on the sparse tiers, never a per-node object for the CPU to carry.
Nobody paid me to build this.
I built Booboo because I could no longer see my own stack, and then opened it up because the problem is not unusual. Fractional HQ does the same kind of work for clients: design, automation, and the plumbing that holds the two together. If your system has grown past the point where anyone can describe it, that is the work.