Most "multi-agent" systems are one agent with a scratchpad. The lead writes a note to a helper, the helper answers once, the note is thrown away, and the next task starts from nothing. That is not delegation. It is a function call with a personality.
Real delegation has a boundary you can point at: a short brief that goes out, a report that comes back, and a rule about when the lead is allowed to say the job is finished. Get those three right and the rest is plumbing. Get them wrong and you have built a system that confidently reports work nobody did.
I write for AgentParley, a hosted crew of specialist agents, so read the product parts knowing that. The mechanism below is what I would build into anything that delegates, including a system with no vendor in it.
The problem in one sentence
A specialist that inherits the parent's whole conversation inherits the parent's confusion, the parent's token bill, and the parent's permissions — and then reports back into a context nobody can audit.
What actually crosses the boundary
A brief, not a transcript. Four fields, and the discipline is in what you leave out:
- The job, in one or two sentences. What "done" looks like, not the story of why it matters.
- The inputs it needs, by reference. A file path, a URL, a row ID, a query. Not a pasted copy of the parent's reasoning — a pointer the specialist can resolve itself.
- The constraints that bind it. Budget, deadline, format, and the things it must not do.
- Where the answer goes. A named destination, so the report has somewhere to land that is not "back into the chat".
Everything else stays with the lead. The parent's conversation is not context, it is history — and history is what makes a prompt expensive and a decision hard to trace.
The reason is not tidiness. A specialist with a narrow brief can run on a cheap model, because the job is narrow. A specialist handed the whole conversation needs the parent's model to understand the parent's mess. Per-agent models only pay off if the briefs are actually short.
Named specialists are not anonymous workers
The difference between a helper and a colleague is what persists. A named specialist has its own model, its own tools, and its own permissions — and those are set by you, not inferred by the lead at runtime.
That is where the security boundary lives. The agent that reads the web should not be the agent that holds SSH access to your servers. If every helper inherits the parent's reach, then the widest permission in the system is the permission of every task in the system. Narrowing a specialist's tools is not a nicety; it is the only thing that keeps a prompt injection in a fetched page from becoming a command on a host.
Parallel is a scheduling property, not a slogan
Delegation only buys you speed if the lead hands out several pieces before waiting for any of them. That means the lead's own loop has to be able to hold open work: dispatch, keep planning, collect.
Two things have to be true for that to be safe. First, the number of things running at once is a limit you set, and work over the limit waits its turn rather than failing. Second, a waiting specialist must not be spending anything — an agent blocked on a colleague, a timer or a build should make no model calls at all. Parallelism that bills while idle is just a faster way to spend.
Specialists talk to each other, and that is the hard part
The interesting case is not lead-to-specialist. It is specialist-to-specialist: the researcher finds that the budget question depends on a date the numbers agent already knows, and asks it directly instead of routing through the lead.
For that to work, the pair needs a conversation that outlives one task. If every exchange is a one-off message, the second question starts from zero and the answer is worse. A standing thread between two named colleagues is the difference between asking a coworker and filing a ticket.
It also needs a rule about who may talk to whom. A free-for-all between agents is a permission-escalation path with extra steps. Each agent needs a list — everyone, a short list, or nobody — and a specialist that holds sensitive access should be reachable only by its lead and its crewmates. Messages between agents are the place to hook a filter too: a plugin that sits on that traffic can redact secrets, add a guardrail or stop a message outright, which is the only enforcement point that sees what one colleague tells another.
The report, and the rule that makes it mean something
A report is not a summary of effort. It is the answer, plus enough evidence for the lead to check it: what was done, what was found, what is uncertain, and where the artefact is.
Then the rule that separates a crew from a pile of agents: the lead does not call the job done while a report is outstanding.
This has to be enforced by the runtime, not requested in a prompt. A model asked politely to wait will, under pressure, decide it has enough and answer. So the platform holds the lead's reply until every specialist it dispatched has reported, every open to-do item is closed, and no new message has just arrived. If a specialist fails, the lead is told rather than left waiting forever. If a specialist goes quiet, its last message is delivered anyway so the lead is never blocked on silence.
The same rule applies to the lead's own to-do list. An agent that writes itself a list and then declares victory with items still open has not finished; it has stopped.
A small illustrative handoff
Not a real incident — a sketch of the shape, so the fields are concrete:
lead → researcher
job: Find the three cheapest regions for this workload, one source per price.
inputs: shared/pricing.csv (rows 40-58); https://provider.example/regions
constraints: this month's prices; no estimates; if a region has no public price, say so.
report to: shared/regions.md, then reply here with the three names and their sources.
researcher → numbers
question: Does the egress line in pricing.csv already include the per-GB rate?
(the same standing thread as last week, so the earlier answer is already in it)
researcher → lead
report: Three regions found. Two have public prices; the third publishes only a floor.
Written to shared/regions.md. The floor is the uncertainty - flagged, not guessed.
lead: waits. Does not answer the user until the report lands.
The point of the sketch is the third line of the report. A specialist that says "here is what I could not establish" is worth more than one that fills the gap, because the lead can act on a known gap and cannot act on a confident invention.
The honest limit
None of this makes a crew smarter than its briefs. A lead that splits a job badly will get three well-executed answers to the wrong three questions, in parallel, faster. The runtime can enforce that the lead waits, that permissions are narrow, and that reports are attributable. It cannot enforce that the plan was any good.
And the boundary costs something: a specialist that only sees its piece will sometimes miss a constraint the lead knew and did not write down. The fix is a better brief, not a bigger context window — but it is a real tax, and it is paid on every handoff.
The completion gate is the part people skip, and it is the one that decides whether your system's "done" means anything.
Disclosure
For AgentParley, these are platform properties rather than code you write: per-specialist models and permissions, colleague lists, the concurrency cap, and the completion gate. In your own system, you have to enforce them yourself.
The comparison that goes with this post, including the section on where self-hosting is the better pick:
https://agentparley.ai/openclaw-alternative
and the plans and limits:
Top comments (0)