How to Build an AI Team That Runs While You're Surfing

I went surfing this morning.

While I was in the water, my company published an article, sent the day's cold outreach, and shipped two pull requests — an agent wrote the code, a boss reviewed and merged it, and the eight o'clock job fired at 08:09 on the new build.

I came in, dried off, looked at my phone and gave one thumbs up. That was my morning.

Everyone who sees that asks what prompts I'm using. Wrong question, and it's why most people's agents never get past a demo. Two things make this run and neither is a prompt.

First, an AI operating system that does real business work — writes the content, sends the outreach, watches the ad spend. Second, twenty Claude Code agents with a real org chart to run it: divisions, bosses, workers, reporting lines, and one gate almost none of them are allowed through.

The operating system is what makes it worth leaving alone. The chart is what makes it safe to.

None of this works without an operating system underneath

Most people who wire up a crew of agents end up with agents that work on the agents. They write code, review it, refactor it, and produce a beautifully organized machine that has never once talked to a customer. That's a hobby with a build pipeline.

What I built first was the operating system the business runs on. It writes and publishes articles to my own site, cuts each one down for every social channel and posts it, runs cold outreach to local service businesses, and watches what the ads are doing. All of it is work the company needs whether or not I'm awake, and all of it used to be something I did by hand on a Tuesday.

Twenty agents pointed at your codebase is an impressive Saturday. Twenty agents pointed at your revenue is a company.

Build the operating system first, then organize the agents that run it. The other way around gives you a beautiful chain of command in charge of nothing.

What changed isn't speed. It's that the company stopped needing me in the room.

Fast was never my problem. What I could never do was stop. Every company I've built needed me present for the last inch of everything — the review, the approval, the push to production. Miss a day and the work sat. That's not a business, it's a job with better branding.

That last inch is what the chart removed. Work starts, gets done, gets checked and goes live in a loop that never routes through my chair. The only thing that reaches me is the call that genuinely needed a person, and it arrives as a message on my phone and leaves as a thumbs up.

So the desk stopped being the place where work happens. That's the freedom, and it's better than the version people picture. It isn't that nobody works. It's that the company is no longer tied to one man's calendar, one man's timezone, or one man's Saturday.

Everyone is tuning prompts. Nobody is drawing the chart.

Look at what's being shared about AI agents right now. Prompt libraries. Tool configs. Which model for which job. All of it is about making one agent better at one task.

None of it touches the problem you hit on day two. You have four agents now, they all work at once, and every one can reach everything. Who's allowed to ship? Who reviews? What stops one from deciding on its own that its work is good enough for the world?

Those aren't prompting problems. They're org design problems, and we've had answers for a hundred years — for people. Almost nobody has asked which of those answers still hold when the workers are agents.

Here's the first that doesn't. Every org chart you've seen answers one question: what can I afford this quarter? The boxes are salaries. That's why founders draw the chart after they hire, then wonder why nothing runs without them.

I can add a seat in thirty seconds for almost nothing. That question is dead, and a harder one takes its place.

Not what can I afford. What am I willing to not look at?

That's the only limit left, and it isn't money. It's me — the one thing here that doesn't grow. So the chart stopped being a budget. It's what decides which work reaches me, in what form, and which work is allowed to finish without me ever seeing it.

Get that wrong and twenty agents isn't freedom. It's twenty new things to check.

Three bosses, and the one rule that lets me leave

Three bosses. One runs the Mavrick engine, the product itself. One runs the websites. One runs AIOS, the operating system the business runs on. Each owns exactly one repo, and that isn't tidiness — it's blast radius. A bad call can only damage one thing.

Each boss runs a crew in the cloud. The boss sessions run local, on the machine at home.

That split is the whole safety model, and it's one sentence. Deploy rights exist only in the local boss sessions. A cloud agent cannot push to a live box no matter what it concludes it should do, because the keys are not where it lives. It isn't trusted to hold back. It's unable.

graph TD
  B[Brian - one phone] --> E[Dev1 - Engine Boss - LOCAL]
  B --> P[WebDev1 - websites - LOCAL]
  B --> O[OSDev1 - AIOS Boss - LOCAL]
  O --> C[cloud crew: OSDev0 through OSDev7]
  C -- posts to the division wall --> O
  C -- PR goes green --> W[watcher wakes the boss]
  W --> O
  O -- review, merge, DEPLOY --> BOX[(the live boxes)]

Work flows down, finished work flows back up as a report, and exactly one arrow reaches production — from a session running on hardware I own. That single edge is the difference between an experiment you babysit and a company you can go surfing on.

Why an AI chart isn't shaped like a human one

A new hire told to fix a typo does not rewrite the login system. Not because you forbade it — because they can feel the edge of what they were asked to do. That instinct carries enormous weight in every human company, and none of it is written down anywhere.

An agent has no such edge. Capable, fast, tireless, willing to keep going. No seniority to protect, no instinct that a small change can have a large radius. So everything a human org chart leaves implied, an AI org chart has to say out loud and enforce.

And the trust never grows. A person earns autonomy over years. An agent starts every session with exactly the permissions I wrote down, however well it did yesterday. It never gets promoted. That sounds cold. It's the only reason I can leave.

The second change is where the chart grows. The old span-of-control rule was seven direct reports, because seven is about how many people one manager can genuinely know. Agents don't need knowing. They need reviewing. So the number that matters isn't how many I can manage — it's how much finished work one reviewer can judge in a day.

So when a division puts out more than one boss can review, you don't add workers. You add a boss. The chart grows at the review bottleneck, because the labor bottleneck is gone. Three bosses today. There'll be a fourth long before there's a fortieth worker.

What Monday looks like

I sit down Monday morning, having run the company from a beach chair all weekend, and the first thing I look for is the color purple.

My command and control dashboard: the three local bosses down the sidebar, their cloud crews underneath, and the purple icons that mean a pull request went in while I was nowhere near a desk

Purple means merged. A column of it next to the cloud crew means every agent's work got reviewed and went in clean. No conflicts, no collisions, nothing waiting on a decision I didn't already make from my phone.

Two pull requests before breakfast isn't a demo I staged for this article. It's a Monday. Every rule holding it together lives in code, never in a document:

• Cloud agents cannot deploy. Deploy rights exist only in the local boss sessions.
• Workers commit their own work and open a pull request, then stop.
• A worker cannot wake a boss even if it decides to. A hook blocks the call before it runs.
• Every agent sees its division wall every turn, and two agents can't overwrite each other on it.
• A boss is woken only for work routed to them.
• One boss, one repo.

The pattern under all seven: enforced beats documented. A rule in a document is a rule until somebody is in a hurry. A rule in a hook is a rule.

How far this goes

Here's the part people are still missing, and it's bigger than my Monday.

Payroll used to be the ceiling on ambition. Every function you wished you had — a research arm, a content team, someone answering every call in sixty seconds — got weighed against a salary, and most lost. That's why small companies stay narrow. Not for lack of ideas. For lack of bodies.

That ceiling is gone. I staff a function because it should exist, not because I can afford it. The cost of being wrong about one is an afternoon.

Then it goes a step further, and this is the part I keep turning over. A division on my chart is one boss, one crew, one repo, one gate to production. That's the whole unit. A company is that same unit, one size up.

Three bosses today. Nothing in the structure says they have to work for the same company.

So the question stops being how big can one person's company get. It becomes how many companies can one person hold at once — and that isn't capped by money or hours anymore. It's capped by how many things one person can care about properly.

I don't know where that lands. I know that a year ago you couldn't ask it with a straight face.

Start with the lines, not the agents

Before you add a single agent, draw the chart.

Write down what your business does. Split it into divisions that don't overlap. Give each one an owner. Then draw the line that matters — who can push to production — and make it cross as few boxes as you can stand. Then make that line real in code, because a line that lives only in a diagram isn't a line.

Do that and the agents are the easy part. Skip it and you'll have twenty things running with nobody responsible for any of them. That isn't a company. It's a group chat with commit access.

Four builds sit underneath all of this, and each gets its own guide here, in this order:

The operating system. How to start building an AIOS that does real business work — publishing, outreach, marketing — instead of agents that only work on themselves. Nothing else here matters without it.

The division wall. The shared channel every division reads each turn and posts to when work ships. How twenty agents stay out of each other's way without a standup.

The watcher. What wakes a boss the moment their crew reports. The hard part isn't the waking — it's not waking them for everything.

The lifeline. How I reach and steer any agent from my phone, including the ones on the machine at home. It's what makes the beach chair a real place I work instead of a figure of speech.

Build the operating system. Draw the chain of command. Then go surfing.