When you build a multi-agent system, you soon hit an architectural choice: should each agent just execute one specific task, or should it own a whole domain? The difference looks small at first, but it shapes the behaviour of the entire system. Let’s get to know the two ends of this spectrum.

The one-step worker

The simplest kind of agent is a one-step worker: it performs an action, returns the result, and steps aside. It reads a record, runs a search, computes a value. This worker holds nothing over time, and it doesn’t need to know what came before it or what will come after. It takes input, gives output, done. This pattern is excellent for independent, stateless tasks.

The domain-owning specialist

But some tasks aren’t a single action; they are a flow that unfolds across several interactions. Here you need a different kind of agent: one that owns a domain, holds its state across interactions, decides for itself when the flow is complete, and manages the transitions. This agent is no longer a simple executor; it’s a specialist.

A useful metaphor: a one-step worker is like someone you tell β€œrun this test” and get a result from. A specialist is like a doctor who holds the patient’s file: they know what happened before, decide what the next step is, and take responsibility for the whole path.

Where the difference shows in practice

The key difference is in ownership of state and logic. The one-step worker sees only its own task definition; it needs no context about the past or future. But the specialist owns the complete lifecycle of a flow: it reads the prior state, determines the next step by the rules of the domain, updates the state, and knows for itself when the flow is complete. No external planner tells it what to do at each step; that knowledge lives in the specialist itself.

This focus has a hidden benefit too: because the specialist is concerned only with its own domain’s logic, it doesn’t need to know about the existence of other agents, the overall routing, or the state of the whole system. The system worries about coordination and ordering; the specialist worries about its own work. This separation makes both the agent simpler and the system more stable.

When to use which

The choice between the two depends on the nature of the task. If a task is independent and stateless β€” one action, one result β€” the one-step worker is simpler and better; adding state and a lifecycle just brings needless complexity. But if a task unfolds across several interactions and each step’s decisions depend on the previous ones, you need a specialist to own that flow.

The common mistake is to build everything out of one-step workers and then force the flow logic into the coordination layer β€” where it doesn’t belong. When a domain has a flow, let the specialist of that domain own it. This is the difference between a system that grows and one that gets more fragile with every new capability.