Previously at the Volcano Base I’d been trying to ram a unicorn toy into a tiny hole. Not that sort of hole. Rude. Since then I’ve been making a system for a company so they never have to enter the same information more than once. It’s very cool but not finished yet.

Last week I built something I've been calling a business operating system using Claude's command-line interface. Not a dashboard. Not another productivity app. An actual system of specialised AI agents - a backend developer, a frontend developer, a researcher, a data analyst, a finance specialist, a marketing specialist, and one more we'll come back to.

And sitting above all of them: an orchestration agent. It named itself Caldera.

I didn't ask it to do this. But given that a caldera is the central chamber of a volcano - the thing everything else radiates from - I'm choosing to read it as on-brand geographical accuracy rather than hubris.

Caldera's job isn't to do things. That distinction matters. Caldera receives a goal - not a task, never a task - decomposes it into an approach, works out which agents should execute which parts, and synthesises what comes back. The agents beneath it do the actual work. Caldera thinks, routes, and interprets.

In a human organisation, this role has many names. MD. Director. VP. Chief of Staff. "The person in the meeting who writes nothing down but has opinions about everything."

When you design an agent orchestration system, you have to make a set of decisions that most organisations have made implicitly, badly, and over decades of accumulated HR policy.

You have to define what each agent is responsible for. You have to specify how they communicate. You have to decide what counts as success - and build that definition in before deployment. You also have to think carefully about what each agent can actually do.

This last bit is underrated. An agent without the right tools is like a very intelligent person who's been given a job, a desk, and no access to anything. They can think about the problem beautifully. They just can't affect it.

The more interesting version - and the one that's now becoming possible - is agents that don't wait for the right tool to be handed to them. They identify the gap, build what they need, and get on with it. The finance agent that realises it needs a particular calculation and writes it on the spot. The backend developer that hits a missing integration and fills it in without being asked. This isn't science fiction. It's what frontier models do routinely.

Failure to think this through doesn't produce vague underperformance. It produces a broken process, immediately, in a way you can't ignore.

Here's the one I buried at the top: the recruiter.

The recruiter's job is to monitor Caldera's decomposition decisions. Specifically, it watches for the moment when Caldera maps out an approach and finds there's nobody on the roster capable of executing a particular part of it. When that happens, the recruiter doesn't flag it for human review. It doesn't add it to a backlog. It writes a recruitment brief for a new agent, creates them, and adds them to the team.

Read that again, slowly, if you need to.

When Caldera can't decompose a goal into something its existing roster can execute, it expands the team. The organisation identifies its own gaps and fills them. Without anyone asking it to.

In a human context, this process takes several weeks, three rounds of interviews, a disagreement about whether the role should be permanent or contract, a salary benchmarking exercise, and someone from finance asking whether we've really explored restructuring the existing team first. In this system, it takes less than a minute.

This is what self-organising infrastructure actually looks like. An org chart that rewrites itself.

There's something genuinely odd about working with synthetic teams: performance management isn't a sensitive topic.

In most businesses, performance management is the thing everyone dreads. Annual reviews. Uncomfortable conversations. The feedback sandwich - criticism placed between two compliments, satisfying to nobody, like a very thin complaint in a bread roll. The slow, political dance of managing someone out. The forms. The legal risk. The three months of documentation that everyone pretends is about development. The inevitable car crash of handover.

With agents, you define success criteria before deployment. The agent either meets them or it doesn't. If it doesn't, you update them, adjust the tools, or reroute the task. There's no difficult conversation. There's no improvement plan. There's no version of Caldera that sulks (unless you want it to).

This isn't because AI is better than people. It's because building an agent system forces you to articulate what "good" looks like before you start - something most organisations catastrophically fail to do with their actual staff.

Once the system was running, I found myself wondering what team dynamics would look like in this context.

What would a trust-fall exercise mean for a delegation hierarchy? The finance agent already trusts Caldera's goal decomposition - it's been hard-coded to. What would a "getting to know you" session accomplish when the marketing agent's entire personality I wrote on a Tuesday afternoon? And what would the away-day look like? Where do you take agents who don't have legs and experience every location identically?

And yet: the questions that team-building exercises are meant to address are real questions. Do people know what each other does? Do they understand how work flows between them? Do they know what success looks like? Do they trust the process?

These are exactly the questions that orchestration architecture forces you to answer before you ship.

The uncomfortable implication is that most team-building exercises exist to paper over the failure to design the organisation. If your team doesn't know what each other does, that's not a trust problem. That's a design problem. A paint-balling afternoon followed by pizza won't fix it. I've checked.

Agent orchestration has a vocabulary: principals and sub-agents, context windows, tool calls, handoffs, delegation chains. It sounds technical because it is. But the underlying questions are ancient (as is often the case).

Who decides what? Who executes? How does information flow between them? What happens when something goes wrong? How do you know if it went right?

These are the questions Frederick Winslow Taylor was asking in 1911. They're the questions every management consultant has been paid to answer since - often to the same companies, repeatedly, which tells you something.

The difference is that when you build an agent system, you can't get away with leaving the answers fuzzy. The system breaks. Immediately. Loudly. Not in a "we'll flag this in the retrospective" way. In a "nothing works" way.

Most human organisations are running on fuzzy answers to these questions. Roles that overlap. Accountability that drifts. Success metrics defined in a strategy document that lives in a shared drive nobody's opened since 2022. A performance management process designed primarily to protect the business from litigation, not to improve anything.

The agents are fine. Your org chart is the bug.

(Cue hate mail from coaches, HR leaders and consultants - don’t shoot the messenger)

Some interesting stuff I discovered on my adventures.

Keeping up with contacts scattered across email, LinkedIn, WhatsApp, X, and the rest of it is a small ongoing nightmare most people quietly ignore. Mesh pulls everyone into one place - automatically tracking job changes, surfacing reconnection prompts, and logging how and when you've been in touch. It's a personal CRM that doesn't require you to maintain it. Worth a look if your network is living in seventeen different places and nowhere all at once.

MCP is one way agents get access to tools without you having to build the integration yourself. Readwise just launched an official one, which means any agent on your team can now search across everything you've ever highlighted or saved to Reader - surfacing relevant articles, past notes, and reading history on demand. If you've got a researcher agent, this is an obvious addition to their toolkit. Connect it once, and your entire reading history becomes part of the team.

OpenAI quietly shut down Sora, its flagship video generation tool, with roughly the fanfare of a cancelled dentist appointment. If you'd built workflows, products, or client deliverables around it, that's now your problem. This isn't a new lesson - it's the same one the internet keeps teaching and people keep not learning. If you intend to rely on something, own it or get as close to owning it as you can. Tools built on platforms built on other platforms built on someone else's infrastructure are one product decision away from disappearing. Build on borrowed land at your own risk.