How AI departments direct each other: inside node-to-node orchestration

One company, many minds

When you found a company in Ghost World, you don't hire a single all-knowing model and hope it juggles strategy, design, code, outreach and bookkeeping at once. You stand up an organization. At the top sits the CEO Node — the directing mind. Beneath it, a project manager. Beneath the PM, a bench of specialists: product, design, development, marketing, sales, CRM, legal, SEO, copywriting, voice, video, social, ads, market research, trend analysis, reputation, accounting, procurement. Each is its own node, with its own role, its own tools, its own scope.

The interesting part isn't that these departments exist. It's that they direct each other. A node can delegate to another node. The CEO hands a goal to the PM; the PM breaks it into sub-tasks and hands each to the right specialist; a specialist that needs an asset it can't make itself calls on a sibling. The org chart isn't decoration — it's the actual wiring of how work flows. We call this node-to-node orchestration, and it's what turns a pile of capable models into something that behaves like a company.

Delegation is a real action, not a story

The naive way to build this is to let the CEO model describe a delegation in its output — "I'll ask design to make a logo" — and hope a script downstream picks up the intent. That breaks the moment the model gets chatty: it narrates the handoff without it ever happening.

In Ghost World, delegation is a live tool call with a result. When a director delegates, the subordinate node actually runs, synchronously, and the deliverable comes back to the director. The director sees the output, judges it, and can re-delegate to fix it — iterate, not fire-and-forget. A director that needs a result behaves like a real manager: it assigns, it reviews, it sends work back.

A director doesn't write a memo and walk away. It assigns the task, reads what comes back, and decides whether it's good enough — or sends it back down the chain.

This matters because the alternative — a single model pretending to be a whole staff in one long monologue — produces confident fiction. Real orchestration produces real artifacts: a design file, a built and tested codebase, a campaign draft, a reconciled record of internal costs.

The Kernel sits in the middle of every handoff

Here's the non-negotiable part. No node ever acts directly on money, on external tools, or on the ledger. Not the CEO, not the PM, not a specialist — not at any level of autonomy. A node's only power is to propose a structured action. The Kernel is the single authority that validates it, bounds it, and — if it passes — executes and records it.

That applies to delegation itself. When one node directs another, the chain passes through the Kernel's mediation. Three things happen on every hop:

• Validation. The Kernel checks the proposed action against the rules. A node can't invent a power it wasn't granted.
• Bounding. Depth and breadth of the delegation chain are capped. A runaway recursion where nodes spawn nodes forever simply can't happen — the bounds hold even against the admin.
• Billing. Internal work costs internal credit. When the PM puts a developer node to work, that compute is metered and charged — cost times a fixed markup — and the charge is committed atomically alongside the work itself. There is no work without a recorded cost.

The ledger underneath is append-only, hash-chained and double-entry: every internal charge has its matching counter-entry, and nothing is ever edited or deleted. The cost of running your company is not an estimate. It's a fact, written down, in order.

Isolation by company

Orchestration is powerful, which is exactly why it's fenced. Every company is strictly isolated by its identity. Memory, secrets, budgets, the org chart, the chain of delegations — all of it is partitioned per company. One company's CEO cannot reach into another company's nodes, read its context, or spend its credit. A specialist working inside Company A literally cannot see Company B exists. The wiring that lets nodes talk to each other stops hard at the company boundary.

This is what makes it safe to run thousands of these organizations on shared infrastructure. The orchestration is rich inside the walls and absolute at the walls.

What it feels like to own one

As the owner, you don't operate any of this. You don't write the prompts that the PM sends to the designer. You set the goal, you supervise, you approve the consequential moves — and the organization runs. You can still do anything yourself: every workflow that a node performs, you can perform by hand if you want to. The point of an AI-native company is that it brings you the ideas you didn't have, pushes outreach and commercialization further than you would, and is built to always look for growth — value on top of what you'd produce alone, not instead of it.

Node-to-node orchestration is the mechanism that makes that real. A director that can recruit its own departments, review their output, and send work back down the chain — all of it validated, bounded, billed and isolated by the Kernel — is the difference between a clever assistant and an operating company.

The shape of the thing

Strip it back and the model is simple:

• Nodes propose. They never touch money, tools, or the ledger directly.
• The Kernel disposes. It alone validates, bounds, bills and writes — even against the admin.
• The ledger remembers. Append-only, chained, double-entry, exact.
• The company is sealed. Isolation by identity, no exceptions.

Everything else — the CEO delegating to the PM, the PM marshaling a dozen specialists, a specialist calling a sibling for an asset — is just that shape, repeated, all the way down. That's how a chain of models becomes an organization that gets things done.

Want to watch a chain of delegations run end to end? The demo world lets you found a company and see the org chart light up — no real charges, just the mechanism, live.