The org chart was a caching strategy for slow humans

Open any company’s org chart and you are looking at a wiring diagram for moving information between human heads. The CFO knows the numbers. The head of sales knows the pipeline. The founder knows the strategy, and a thin line connects each of them so that, when the numbers need to meet the strategy, there’s a path. Nobody drew those boxes because the work naturally came in boxes. They drew them because no single person could hold the numbers, the pipeline, and the strategy in one head at once.

The org chart isn’t a picture of the work. It’s a workaround for the fact that human memory is small.

You drew reporting lines to route information through people who couldn’t hold it all, agents on one brain don’t need the boxes.

What a cache actually is, and why companies are full of them

Strip away the jargon and a cache is a small, fast copy of something big and slow, kept close to whoever needs it.

Your laptop has one. Main memory is large but a little slow, so the processor keeps a tiny copy of the data it’s using right now inches away, on the chip itself. The whole reason the cache exists is a physical limit: the processor can’t reach all of memory fast enough, so we stash the hot part nearby. Caches are not a feature you’d want for its own sake. They’re a concession to distance and size.

Now look at a company through that lens.

The head of sales is a cache. The relevant slice of “everything the company knows”, this quarter’s deals, who’s close, who went quiet, lives in one person’s head because the founder can’t hold all of it and the finances and the product roadmap simultaneously. So the company keeps a fast local copy of the sales reality in a person, and a line on the chart says where to go when you need it. Every department head is the same move: a hot, human-shaped copy of one slice of the company’s knowledge, kept close to the work that needs it.

The org chart is a cache hierarchy made of people. Every box is a copy of one slice of what the company knows, kept near the work because no one head could hold it all.

That’s the org chart, honestly described. Not a map of how work divides, but a map of where each piece of the company’s memory got parked, because no human could be near all of it at once.

The naive fix: hire more people, draw more boxes

Here’s the move every growing company makes, and it feels obviously right.

The company gets bigger. One person can no longer hold the support queue and answer the new-customer questions and track the bugs, so you split the role. You hire. You draw a new box. The slow, big thing, total company knowledge, grew past what one cache could hold, so you added another cache. More heads, more boxes, more lines between them. This is just called scaling, and for two hundred years it was the only way to scale.

Then you live with what it costs.

Every new box is a new copy of part of the truth, and copies drift. The sales cache and the finance cache disagree about whether the deal closed, because the update reached one head on Tuesday and the other on Thursday. A customer detail that support knows never reaches the person writing the renewal, because there was no line on the chart between those two boxes, nobody drew it, because nobody predicted the work would need it. The information existed somewhere in the company the whole time. It just wasn’t in the head that needed it, at the moment it was needed, and the only way to move it was a meeting, a forward, a “quick sync.”

This is the tax nobody itemizes. Picture a company where it takes three days for a thing one person already knows to reach the person who needs it, not because anyone is slow, but because the path between their two boxes runs through two meetings and an inbox. Multiply that by every fact that has to cross the chart, and you have the real cost of running a company on human caches: not that people are dumb, but that the wiring between them is slow, lossy, and drawn before anyone knew which facts would need to meet.

You drew reporting lines to route information through people who couldn’t hold it all, agents on one brain don’t need the boxes.

Why the boxes existed: it was never about the work

It’s worth sitting with the obvious objection, because it’s a good one. Surely the org chart reflects real division of labor, sales really is different work from accounting, and you want specialists, not generalists who do everything badly.

True, and also not the point.

Specialization of skill is real and stays real. A person who is excellent at closing deals is genuinely different from one who is excellent at closing books. But notice that the chart isn’t only drawing skill boundaries, it’s drawing memory boundaries. The reason the deal status lives in the sales head and not the finance head isn’t that finance lacks the skill to understand a deal. It’s that finance can’t hold the deal pipeline in addition to everything finance already holds. The box exists because the head is full.

That’s the part the cache lens makes visible. We’ve spent so long inside the org chart that we read every line as “this is how work is naturally divided.” Most of those lines are something humbler: this is how we routed memory around the limit that no one person can keep more than a few things hot at once. Skill division would survive a world of infinite memory. Most of the boxes would not.

So the real question isn’t “how do we draw a better org chart?” It’s: what happens to the boxes when the reason for them, small, slow, isolated human memory, stops being a constraint?

The other way: one brain, many hands

Here’s the shift, and the key idea is simple.

Stop caching the company’s knowledge in separate human heads. Put it in one place every agent reads from directly. Then the lines on the chart, the slow, lossy wiring between caches, aren’t optimized. They’re deleted, because there’s nothing to route between when everyone is already reading from the same memory.

Think about how a processor would work if there were no distance at all, if every core could touch all of memory at full speed with no copies to keep in sync. You wouldn’t build a cache hierarchy, because the thing the hierarchy worked around wouldn’t exist. That’s the situation a company is in when its knowledge lives in a shared brain and its work is done by agents that all read from it. The sales agent and the finance agent aren’t two caches that might disagree. They’re two hands reaching into one memory that is, by construction, the same for both.

Watch what happens to the three-day tax. An agent handling a support conversation learns that a customer changed their billing contact. It writes that to the shared brain. The instant the renewal agent acts, minutes later, or weeks later, it reads the current fact, not a stale copy that drifted since Tuesday. There was no line on a chart between “support” and “renewals” because there didn’t need to be one. The fact didn’t travel between two boxes. It was simply in the one place both hands were already reaching. The gap where dropped balls used to live, the space between two caches that no line connected, has nothing to live in anymore.

When the knowledge is shared and the limit is gone, the org chart doesn’t get redrawn. It gets deleted, because there’s nothing left to route between.

And the boxes that were really about skill? Those stay, in a sense. You still want an agent specialized in closing well and another specialized in the books. But “specialized” now means which capability runs, not which copy of the truth it’s allowed to see. The skill divides. The memory doesn’t. That’s the line the org chart could never draw, because for a human, skill and memory came bundled in the same skull.

You drew reporting lines to route information through people who couldn’t hold it all, agents on one brain don’t need the boxes.

A field note on the thing that actually breaks

There’s a failure mode every team hits the moment they try this, and it’s worth naming so you don’t mistake it for the idea failing.

The first instinct is to give each agent its own memory. The sales agent remembers sales things, the support agent remembers support things, it feels clean, it feels modular, it mirrors the org chart you already trust. And it reproduces the exact bug you were trying to escape. Now you have two agent-caches that drift, and you’ve rebuilt the three-day tax in software, faster but just as lossy. The agents disagree about the customer for the same reason the humans did: each one is reading its own copy.

The lesson is the one the hardware learned decades ago. The hard part of a cache was never the speed, it was coherence, making sure every copy agrees about the truth. The discipline that kills the bug is to refuse the second copy in the first place: one brain, written once, read by all hands, so coherence is free because there’s nothing to reconcile. Modular memory feels like good engineering and is, in this exact case, the thing reintroducing the problem. The boxes were never the goal. They were the workaround.

The turn: what you do when the boxes are gone

Here’s the part you can’t install, and it’s the only part that was ever yours.

When the company’s knowledge stops living in scattered human heads and the wiring between them disappears, a strange thing happens to the people. The job that was mostly being a cache, holding a slice of the truth, forwarding it, syncing it, sitting in the meeting whose only purpose was to move a fact from one head to another, that job evaporates. And what’s left is the part no shared brain can do for you. Deciding what the company is for. Which customers deserve its attention. What “good” means when nobody’s watching. Whether the deal you can close is the deal you should.

That was always the work. The org chart just buried it under the logistics of moving information between people who couldn’t hold it all. A person who spent their career being a fast, faithful copy of one slice of the truth was a person doing the lowest-leverage thing a mind can do, remembering, and relaying. Move the remembering and relaying onto a system built for it, and what you free isn’t time. It’s judgment. The scarce thing. The thing the boxes were never able to cache, because it was never a copy of anything, it was the deciding itself.

The boxes were a brilliant solution to a real problem: human memory is small and far apart. The problem is the part that just changed.

---

That’s what we’re building at Apollo Space, a company that runs on one shared brain instead of a chart of human caches, so a fact learned anywhere is known everywhere, the instant it matters. If you’ve ever watched something your company already knew arrive three days too late to the person who needed it, you’ve felt the tax the boxes were charging. It’s time to stop paying it, and get back to the only work the boxes could never do for you.