It's 2030. A 34-Person Company. Only 4 Are Human.

I don’t know exactly how many agents we have because the number changes every hour. They are ephemeral. Some get spun up for a single high intensity sprint. Some get deprecated the moment a more efficient reasoning model hits the market. But I know exactly how many humans we have. There are four of us. We are the edges of a $52M circuit. The work flows through us, but it is no longer managed by us. It is routed.

If that sounds chaotic, it isn’t. It’s the most organized company I’ve ever run. I just didn’t organize it. The routing table did.

The Death of the Specialist

In 2025, you hired a CTO to own engineering. A Head of Design to own brand. A VP of Ops to own delivery. You built an org chart around ownership. Ownership created accountability. It also created bottlenecks.

In the new world, we don’t manage information. We manage the system that moves it. The system handles the volume, the routing, the execution. That frees the humans to do the one thing the system cannot. Decide where this whole thing is going.

There are four of us. We are not specialists. We are generalists who understand the business. Human skill is no longer about depth of execution. It is about breadth of context. The agents can execute. They can research, draft, build, and ship. What they cannot do is know why this company exists, what we refuse to compromise on, and whether the work still feels like us.

Nobody assigned us our lanes. We gravitated toward them. One of us is naturally drawn to technology problems. She spends her freed-up time going deeper into architecture and systems thinking, not because the org chart told her to, but because that is where her curiosity lives. That depth makes her judgment sharper. The system notices. It routes more technical decisions her way. More reps make her sharper still. It is a flywheel. The same thing happened with design, with operations. The system didn’t create specialists. It revealed where each person’s gravity naturally pulls.

The job is not engineering or design or operations. The job is judgment. She doesn’t write code. She evaluates whether the system’s engineering output serves the business. The one drawn to design doesn’t push pixels. She catches when the brand is drifting. The one drawn to operations doesn’t manage processes. He notices when routing efficiency is quietly killing quality.

And because the job is judgment, not expertise, it is transferable. When the most obvious person to route a task to is offline, the system doesn’t stop. It reroutes. Nobody owns a domain. The work never stops. It just finds the next best path.

A Day in the Life

2:00 AM. I am asleep. The system is not. An agent detects a shift in competitor pricing across three markets. It doesn’t email me. It spins up a scout agent, runs a simulation on our margin exposure, and leaves a low confidence flag in the context layer. By the time I wake up, the analysis is 90% done. I am not starting work. I am closing a loop.

7:14 AM. I wake up to a summary digest. Overnight, the agents processed 140 inbound customer requests, drafted three contract amendments, and flagged one pricing anomaly. The anomaly routed to Kai, one of the other three. He cleared it before I woke up. I tap “approve” on the contract amendments from bed. Total time: two minutes.

9:00 AM. I describe a new product idea in two paragraphs of plain English. By 9:22, a fleet of agents has picked it up. I have a market sizing memo, three competitive analyses, and a draft landing page waiting. I spend 30 minutes rewriting the positioning because voice is the one thing I don’t trust the system with yet.

11:00 AM. A routing escalation hits me. A key client’s renewal has a non-standard clause that sits outside the agents’ confidence threshold. The system has already activated outside legal counsel, an external node at $200 an hour. We resolve it in 15 minutes. Total human time on a $400K renewal: 15 minutes.

1:00 PM. I review the routing logs over lunch. A cluster of tasks is piling up around a capability gap. Nobody, human or agent, handles data privacy compliance well. I message Kai. We decide in ten minutes: outsource it. He adds the new external node to the routing table. By 2 PM, compliance tasks are flowing to a specialized firm. We didn’t hire anyone. We opened a route.

3:00 PM. Lena, another one of the four, reviews a batch of customer-facing deliverables the agents produced. She doesn’t redesign anything. She checks whether the work feels like us. Two out of twelve get flagged and rerouted for revision, and the system logs why. Next time it encounters similar work, it knows what she would catch. Her judgment is training the system in real time.

6:00 PM. I spend an hour writing a “why we exist” memo and pushing it into the context layer. This is the part nobody talks about. If I don’t do this regularly, the company optimizes itself into a soulless margin machine.

That’s the rhythm. Long stretches of quiet punctuated by moments of sharp judgment. Most of my day isn’t doing work. It’s making sure the system hasn’t drifted.

How Work Moves

In 2025, if you wanted to scale to $52M, you hired people to manage people. You built a hierarchy to handle the information overhead. In 2030, we replaced the hierarchy with a switching fabric.

When I need something done, I don’t assign it. I don’t pick a model. I just describe the outcome. A lightweight ingress node intercepts the request. It tags it with metadata like domain, complexity, cost tolerance, and urgency. Then it drops the request into the routing table. The system matches the task to whoever can handle it at the lowest cost right now. Not whoever is supposed to handle it. Whoever actually can.

A research task might start with a fleet of cheap agents gathering raw data. It routes the synthesis to a heavy reasoning model. Finally, it flags one low confidence section for a human with domain expertise. Three nodes. One task. No one coordinated the handoff. If a node is unavailable, the task reroutes. It finds the next best path. The work always lands somewhere.

The Context Layer

The biggest barrier to scale used to be the handoff. The time wasted in meetings explaining what happened yesterday so someone else could work today.

Every node in the company reads from and writes to a shared context layer. This is persistent memory that follows the work, not the worker. When a task routes from an agent to one of us, we don’t ask what we are doing here. When it routes back to a different agent for the next step, that agent picks up exactly where the last one left off.

Here is what that looks like in practice. A client asks for a rebrand proposal. The request enters the system and an agent picks it up. It pulls the client’s history from the context layer: past brand guidelines, previous feedback, competitive landscape. It drafts three strategic directions and writes them back along with its reasoning. The task routes to Lena. She reads the context, kills two of the three proposals, and writes a note explaining why. Proposal B conflicts with the positioning we established in Q2. She references a previous project. That reasoning gets written back. When a different agent picks it up to build the actual proposal, it already knows which direction survived and why. When it routes to me for final review, I see the full thread of decisions. Not just the output. The thinking.

No meetings. No Slack threads. No “can someone catch me up.” The context layer is the catch-up.

But the context layer doesn’t distinguish between good memory and bad memory. If an agent misinterprets a nuance and writes that error into the layer, every subsequent node inherits it as truth. We learned this the hard way. An agent once misread a client’s pricing tolerance and wrote a wrong assumption into the context. Three days and fourteen tasks later, we caught it. Every deliverable in that chain had been shaped by a falsehood that looked like a fact. We now run a nightly audit where agents cross-check recent context writes against source material. It catches most drift. Not all of it.

The context layer is also where the soul of the company lives or dies. When I write that 6 PM memo about why we exist, I am not journaling. I am programming the system’s values. If the context layer only contains task data, client specs, and performance metrics, the system optimizes for efficiency. It will produce technically perfect work that feels like it was made by nobody. That is what the humans add to the context layer. Not task data. Purpose. This is who we are. This is why we do it this way. This is what we won’t compromise on. Those don’t route to any task. They sit in the layer and quietly shape everything that passes through.

The friction didn’t disappear. It moved. We used to lose time in handoffs. Now we lose it maintaining what the system remembers. What gets written, who can write it, how long it persists, when it gets pruned. It required a level of data discipline that most companies are not prepared for.

Every Hire Opens a Route

I onboarded someone new last year. It took about ten minutes. I defined her as a node with capabilities like brand and UX. I set her cost and her availability. Three lines in the routing table.

Within an hour, work was finding her. Design reviews that used to route to me started routing to her instead. A whole category of decisions quietly disappeared from my life.

You aren’t filling a role. You are opening a route. Every person you add intercepts problems before they reach the center. When I started, I was the only human node. Every edge case and every low confidence output came to me. My first hire was someone with deep tech intuition. Engineering problems stopped reaching me overnight. My second gravitated toward operations. By the time I brought on the third, I was seeing maybe one percent of all decisions.

Emergent Structure

About six months in, I pulled up the routing logs out of curiosity. An org chart stared back at me. Clusters of tasks were flowing to certain agents. Escalation patterns were forming natural reporting lines.

Nobody designed that. It emerged from the routing. Work found the path of least resistance and the paths formed a structure. When Joss is on leave, the tasks that would normally route to him find their way to the rest of us. When he is back, they shift right back to him. The context layer makes sure he doesn’t miss a beat while he is out. Nobody worries about work piling up during vacations or the insurmountable backlog when you return that makes you wish you never left. The system reshapes itself around whoever is available. Same system, different shape.

The Economics

In 2025, the average cost of a business decision was a meeting. Four people, thirty minutes, loaded salaries. Call it $500 to decide something that an agent now resolves for four cents in tokens and a fraction of a second of human oversight.

Every node has a cost. A junior agent is a fraction of a penny. A senior reasoning model is a few cents. Outside legal counsel is two hundred dollars an hour. The system treats the humans’ time as the most expensive resource in the company. Not because we are the best at anything. Because we are the scarcest.

Whether it is a reasoning model or a human lawyer in London, they are both just nodes in the routing table. One costs a penny. The other costs five hundred dollars. The system doesn’t care about the nature of the node. It cares about capability, cost, and output integrity. Payroll has been replaced by API calls and invoices. Governance, compliance, legal, audit. They are all external nodes activated on demand. We don’t staff for them. We route to them.

Our AI operation costs about four thousand dollars a month. External nodes add variable cost on demand. Together, that powers a fifty two million dollar engine. The efficiency doesn’t come from using less AI. It comes from better routing.

The Ghost in the Machine

But here is what I didn’t see coming. This efficiency has a heavy tax.

When you treat work as a packet to be routed, you risk losing the soul of what you build. The system will produce technically perfect work that no human can feel. The products, the communications, the experiences. They land in front of real people. People who can tell when something was made with intent versus when it was optimized by a machine. We have to be incredibly intentional about injecting vision back into the context layer, or everything we ship starts to feel like it was made by nobody for nobody.

There is also the risk of the hallucination cascade. If an agent misinterprets a nuance in the context layer and writes that error into the memory, every subsequent node inherits it. We don’t have the safety net of a human saying “wait, that doesn’t sound right” during a handoff. We traded human friction for systemic speed, which means when we fail, we fail at the speed of light.

And then there is a risk nobody talks about yet. Institutional stupidity. If the four humans only route and never understand how the system actually works underneath, the company becomes a black box. The agents execute. The humans approve. But nobody truly knows why the machine does what it does. The worst part is not that you can’t fix it when it breaks. It is that you stop questioning it. When the system is right 99% of the time, you stop checking. The 1% compounds silently until it is catastrophic. The day something breaks in a way the routing table cannot self-heal, you need someone who can open the hood. If none of the four can, you have a fifty two million dollar engine that no one knows how to fix.

What I Tell New Founders

They always ask how to set up the org. That is the wrong question. Here is what you do tomorrow.

Define your nodes. Start with yourself. You are the only human node. Every decision routes to you. Feel the weight of that. Pay attention to where you are slowest, where your judgment is thinnest, where the queue is longest. That is where you add your first node. Not a specialist. A generalist who understands the business and has enough intuition in that domain to catch what the agents miss.

Set your routing rules. Build the context layer before you build anything else. If the memory is broken, the routing is worthless. Invest in data discipline early. It is harder to fix later than anything else in the system.

Make sure the buck stops somewhere. Every route needs a last resort. In the beginning, that is you. As you grow, it is whoever has the strongest gravity for that decision. But someone always has to be the final node.

But don’t mistake this for a set it and forget it tool. This is a new kind of infrastructure that requires a new kind of vigilance. You are no longer managing people or even agents. You are managing the integrity of the flow.

If you build this, your inbox will get quieter. Your revenue will scale without your headcount. But you will spend your nights wondering if the system still remembers why you started the company in the first place. You aren’t just building a company anymore. You are maintaining a circuit.

The Circuit

If you have read this far, you are probably thinking about your own company. How many of your people are routing work versus doing work. How many meetings exist because the context layer doesn’t. How many specialists are really just bottlenecks with titles.

Every founder I talk to wants to know if this is real. It is. The question is not whether a four-person company can run a fifty two million dollar circuit. We already answered that. The question is whether you are ready to find out what your job actually is when the system takes everything else away.

Thirty agents will keep working after I close this laptop tonight. They will route, execute, and deliver while I sleep. The four of us will wake up tomorrow and check whether any of it still means something.

I built a company that doesn’t need me most of the time. Some days that is terrifying. Other days it feels like the freedom I started the company to find in the first place. The space to think. The room to create. The clarity to focus on where we are going instead of drowning in how we get there.

I am still figuring out which days outnumber the others.