DEV Community

Jo Yet
Jo Yet

Posted on

Coordination: The Last Human Step

At the end of the previous post I drew a line: a capability pack only covers how a single feature gets implemented faithfully. It lets an Agent take a spec and do the work right, but it can't address another question — who coordinates the space between one piece of work and the next.

This post is about the gap on the other side of that line. One caveat first: the previous four posts describe assets that have actually run on our internal projects. This one doesn't. The shape of this layer is still being validated, so I can't give you "configure it like this and it will run" — all I have is an architectural argument.

Multi-Agent Is Not Copying the Capability Pack a Few Times

The previous four posts dealt with a single Agent's ability to execute: hand it a ProjectSpec, hand it eight SKILLs, and it discusses the issue chain, implements the delivery chain, and verifies the evidence chain. In that slice, the capability pack is an enhancer.

But the moment you step into multi-Agent territory, the problem moves to a different dimension. Multi-Agent is not simply a matter of copying those eight SKILLs a few times and handing each Agent a set. The first thing multi-Agent has to face is a scheduling problem.

The model is the base capability, the Agent is the model's driver, and above that you need a scheduling controller. The model provides understanding and generation, the Agent turns the model into a role that can carry out a concrete task, and the scheduling controller decides who does the work, who talks to whom, when the work counts as done, and when it's time to call in a human.

That scheduling layer should never be another "super Agent", and it should never be hard-wired to one particular Agent. It has to be a protocol. Down the stack it adapts to many kinds of Agent; up the stack, Agents can mount many kinds of model. Only then can users compose freely around a task goal: which kind of Agent, how big a communication budget, who it is allowed to contact — all of that is handled by the protocol layer instead of being locked in by some rigid toolchain.

That is the first principle of multi-Agent work — composable scheduling. Stand up the protocol layer first and decouple models, Agents, and task goals completely; only then do safety, permissions, and budgets have somewhere real to land.

Human Time Still Gets Eaten by Coordination

Take the most common scene. An engineering lead's afternoon is usually chopped into pieces: align with product on a requirement's boundaries, confirm a technical choice with the architect, pull two people together to sync progress, and in between answer a few messages asking "who should I talk to about this".

There is a harsh fact buried in that afternoon: almost nothing he did required real technical judgement. All of it was process coordination.

If nobody does these things the system falls apart, but the time they take comes out of the same pool as thinking about architecture and making technical decisions. Once AI entered the picture, this crowding-out effect got worse, not better. Code generation got faster and tests run faster, but the speed of collaboration didn't change at all. People are still pinned to every handoff point, restating and signing off. The faster execution gets, the more fatal the congestion in coordination becomes.

So what multi-Agent has to take over is not "a few more lines of code" but coordination itself. And coordination is not something you can let go of by saying "you all talk to each other". One point I keep stressing to my team: a result from an uncontrolled process means nothing. If the method is right, then even when the result goes wrong for a while we know which point to correct; if the method is wrong, a "correct" result that came out of a lucky fluke only plants a bigger risk. When you hand a goal to an Agent, if you lose control of the process, the output you get is guaranteed to be a disaster. Making the process controllable and auditable depends on that scheduling protocol — the task, the role, the communication, the context, and the stop-loss point, all of it defined clearly.

Data Doesn't Leave the Domain: The Hard Constraint on Landing the Protocol

Once the protocol layer lets Agents pass conclusions and requests directly to each other, you hit a wall right away: where do those messages travel, who judges the permissions, and does the trial-and-error process count as sensitive data?

At that point "interaction doesn't leave the domain" has to be put on the table as a hard constraint. Who proposed what, who rejected what, which path was abandoned as a dead end — these intermediate states of trial and error are often more sensitive than the final conclusion. If every round of scheduling has to go through an external service, then the discussion itself is a continuous data leak.

The Five Things the Protocol Layer Has to Build

Handing coordination to Agents means rebuilding, in the protocol layer, the five mechanisms that human organizations already have:

First, context isolation. Letting Agents share context causes serious cross-contamination — one Agent's hallucination or intermediate reasoning seeps in and distorts another's judgement. Every Agent has to have its own context, and may only pass "conclusions and requests" through an abstract channel (a ticket, for example). Passing "the thinking process" must never be allowed. The isolation here is isolation of the protocol channel, not the protocol layer taking custody of an Agent's internal state. The protocol layer only makes sure contexts don't bleed into each other; it doesn't touch how an individual Agent splits, compresses, or records its own context.

Second, roles and responsibilities. An Agent with a name but no responsibilities will either accept everything or refuse everything. Responsibilities exist to mark the boundary of accountability — what it should do, and what it should ask for help with. That boundary has to be stated explicitly in the protocol; it can't rest on some vague tacit understanding of context.

Third, communication permission. Hard-code the collaboration flow and it jams; leave it open and it becomes chaos. The right answer is: permissions fixed, flow open. People only compose a whitelist of who may ask whom questions and who may report to whom. Once that is configured, how the work actually moves and how many rounds it takes is decided by the Agents inside the whitelist. People don't need to predict the flow; they only need to draw the permissions.

Fourth, communication budget and escalation. The failure mode more hidden than token consumption is two Agents going back and forth on one question, making no progress, until the ticket is completely stuck. Governing dialogue turns is more direct than governing tokens. Any time a ticket passes into an Agent's hands, the number of conversations it may start needs its own absolute budget. If the budget runs out with no conclusion, the ticket is suspended immediately and the user is called. This is not a technical patch against infinite loops — it is a hard interface between human and machine, forcing the user to step in at that moment.

Fifth, a record of the interaction. Keeping a record matters not only for monitoring while things are happening, but more importantly for precise auditing afterwards. What gets recorded is not just the message text; it also has to include the decision metadata of the context's lifecycle: when it was switched, when it was compressed, what the compression was based on, and whether it is still locally addressable. The core of an audit is decisions, not the residual text left after compression. Only with this data can users keep tuning the Agents' collaboration network.

These five things happen to fill out the core definition of a scheduling protocol. The protocol doesn't lock down a specific flow; it constrains interfaces and boundaries only, which is what makes downward multi-Agent adaptation and upward free composition of tasks possible.

The Self-Governing Boundary of Context and Memory

Once those five mechanisms stand up, one gap remains, and it is easily hidden by the phrase "context isolation": the protocol layer says what Agents may not pass to each other, but it never answers who manages an Agent's own context and memory.

In the single-point human-driven mode, the user makes lifecycle decisions for the Agent by hand: switch the session when a topic ends, clean up proactively when usage runs high. But in automated scheduling mode, that decision authority can only be delegated. Delegated to whom?

The answer: it has to be delegated entirely to the Agent itself. Context management and memory management are two sides of one thing; they are a single Agent's internal craft and should never be taken over by the protocol layer. If the protocol layer starts deciding which memory to keep and when to compress, it not only locks down the Agent's autonomy but makes the protocol itself immensely bloated.

They are two sides of one thing because context is memory's cache layer, and memory is context's persistence layer. Which piece of information in the active window is worth sinking into long-term memory? Which piece of long-term memory needs to be woken up again? When does the current working memory's scope end? The logic at each end interlocks with the other. Only when one Agent schedules both of them does information compression become a reversible operation — a degraded representation that keeps a handle for retrieval — instead of lossy destruction that is gone once compressed; and only then can recall be a targeted search driven by what a ticket needs instead of mindlessly dredging up the past.

So the isolation is channel isolation, never the protocol layer taking over as custodian. The protocol layer manages neither context nor memory. It only draws ticket boundaries for the Agent, issues budget signals, and receives lifecycle metadata for scheduling and auditing. How context is split, how memory is stored, how compression is done — all of that goes back to the Agent's own self-governance. It falls outside the five mechanisms, yet it is the physical precondition for those five to hold.

People Go Back to the Place of Judgement

Taken together, this machinery is not meant to push people out of the picture. It is meant to return their energy to the only place it belongs: judgement calls.

Engineering has an eternal hard problem: getting things right is hard, but deciding to do the right thing is harder. In the R&D chain ahead, who is better suited to getting things right? AI. Give it a clear enough spec and it will check every line of code and enforce every rule without tiring. Who is better suited to thinking about what the right thing is? People. Whether a piece of work should be done at all, which of two architecture options to pick, when to cut losses in time — Agents still can't do these, and shouldn't be asked to.

So letting Agents take over coordination is not because AI has become a substitute for human decisions. It's the opposite: once AI has drained away the mass of process restatement and mechanical handoffs, it is in effect pushing people back onto the one position that truly can't be replaced — making the calls that nobody else can take responsibility for.

Preview and Boundaries

As usual, let me be clear about the boundaries of this argument.

It doesn't cover whether a single Agent is capable enough — that is what the previous four posts on capability packs are for. It doesn't guarantee that the person who gets called can make the right decision — the system only guarantees that the call for help happens at the right point; it can't make up for someone's level of skill. And it doesn't promise that these five mechanisms are the end state; there could easily be a sixth or a seventh that hasn't been discovered yet.

The previous four posts were about how to get AI to do things right. This one points at the next step — how to get multiple Agents and people to get things done together. The scheduling protocol is the clear gap I can see right now: it really exists, but I don't yet have a complete answer for filling it.

Top comments (0)