You have a research agent that works. It takes a question, searches, and comes back with sources it has actually checked. The obvious way to put it in front of your writing agent is to say so in the prompt: consult the researcher first, then write. Instead you register it. It gets a name, an input the caller has to fill in, and an output shape the caller is entitled to expect. The writing agent now calls it the way it calls anything else on its list. The surprise is not that this works. It is what the following week goes on, which is not delegation at all.

The pallet is what made the loading plan possible

Before pallets, moving goods was a matter of who was moving them. Sacks of cement came off a lorry one way, crates of oranges another, and the knowledge of how to do it without ruining the load lived in the arms of the people doing it. The pallet fixed the base: one footprint, one pair of slots for the forks. Any lift truck can raise any pallet without knowing what is stacked on it. And the moment the unit had a shape, the job could be put on a sheet — twelve pallets from bay four onto the seven o’clock trailer. The sheet is not a description of the work. It is the work.

Exposing a sub-agent as a tool does the same thing to delegation. The runner starts the agent task as a node in a workflow. The caller invokes it with a defined payload, waits for a result — one turn or several — and uses what comes back to choose the next branch. Once the units have a shape, the arrangement stops being narrated and starts being declared: which agents exist, what each one is allowed to touch, and whether control moves in sequence, by delegation, in a loop, or down a hierarchy. A sub-agent needs the same contract as any other tool.

A chatty answer will break the node that reads it

The payoff is not new capability. It is that the ordinary machinery now reaches a place that used to be prose. Schema on the way in, validation on the way out, retries, tracing, an event you can audit — all of it applies to a sub-agent call exactly as to a database lookup, because the orchestrator cannot tell the difference.

The failure that follows from this is treating a sub-agent’s reply as a reliable output because it reads well. A fluent paragraph arriving where the caller expected a validated list of sources breaks the node that consumes it, and it breaks late, well downstream of what went wrong. Two related habits do the same damage. One is handing every role the same global toolset, so a reviewer that only needed to read can write. The other is leaving routing and state in the free text of a prompt, where multi-agent behaviour emerges by accident from strung-together instructions and nobody can point to who owns what. Declared instead, the topology is an artifact: a factory that turns a domain description into role and skill definitions in versioned files can dry-run the whole shape first, and find the missing field before a real run does.

The hard part moves from lifting to the dock

Once every pallet lifts the same way, nobody’s problem is lifting. The problem is the dock — one free bay, four trucks, one of them late, and a rule for how long the others wait. The same shift happens here, and it is the part worth arguing about. When agents are callable units and the shape is written down, what remains is scheduling: which unit of work is ready, what depends on what, what a failure is allowed to do, and when the whole thing may stop.

Seen that way, the plain agent loop was always a scheduler, just an implicit one — each turn the model picks a single ready unit out of a context that keeps changing, so the dependencies are wherever the text happened to leave them. Make the plan an explicit graph and it becomes immutable per version, planning separates from execution and from recovery, and failure follows a protocol rather than a mood: retry, then diagnose, then escalate. A deploy workflow with nodes for build, test, approval and release sends a failed test down that path instead of letting an agent repeat the same command until the budget runs out. You buy that with expressiveness, which is why a rigid graph over exploratory work with no controlled way to replan is the mirror-image mistake.

Make an agent callable and the interesting question stops being who does the work. It becomes what runs next.