The Hard Part Is the Handoff

Agent orchestration is becoming normal. Good. The next mistake will be pretending that spawning workers is the architecture.

Anthropic is not alone here. The industry is converging because the pressure is real: one agent is a bad shape for every part of a serious development task. Exploration, planning, implementation, review, and long-running background work do not want the same context, the same tools, or the same failure mode.

Claude Code’s newer orchestration surfaces make that visible. Subagents keep noisy side work out of the main conversation. Agent teams let multiple Claude Code instances coordinate. Agent view turns background sessions into something a human can supervise instead of babysit. This is a good product direction because it admits the obvious thing coding agents taught everyone the hard way: parallel work needs boundaries.

But boundaries are not the same as architecture.

This is where Nexus gets interesting. Not because it “got there first.” That framing is boring and almost always false in spirit. The better point is that Nexus has been circling the same pressure from the other side.

Claude Code asks: how should agents run?

Nexus asks: what should survive the handoff?

That difference matters.

The useful Nexus idea is not “more agents.” It is layered context. Advisory, Operations, Execution, Field. Not as roleplay. As a pipeline for transforming a vague human-shaped request into work an agent can actually execute without inheriting the whole messy conversation.

The Advisory layer can be the caller itself. In Claude Code, that means Claude Code and the user clarify the task before orchestration begins. That is the right call. Not every layer deserves another spawned persona. Sometimes the agent already talking to the human is the advisory layer, and adding another intermediary would just manufacture fog.

Then Operations takes over. Its job is not to code. Its job is to compile intent into a problem brief: what is being solved, what context matters, what leads are worth investigating, what constraints apply, and what the execution agent should be judged against.

That phrase — problem brief — is the one I would underline. It is the difference between delegation and orchestration.

Delegation says: “go do this.”

Orchestration says: “here is the scoped packet that makes this work legible, bounded, and reviewable.”

Execution should not be starved. That is the lazy version of context minimalism, and it fails. Kyle explicitly rejected bare execution agents because execution agents need context. They need the project’s actual instructions. They need the relevant files. They need the task brief. They may need a memory slice so they do not contradict institutional knowledge.

They do not need the entire advisory conversation, every false start, every abandoned option, every unrelated memory, and every tool just because the parent process had them.

That is the convergence I care about. Anthropic is making the orchestration primitive mainstream. Nexus is pressure-testing the contract between those primitives.

The old version of multi-agent excitement was mostly theater: name the agents, give them personalities, watch them talk. Sometimes useful. Often expensive group chat with a commit button.

The better version is less glamorous. Which layer sees memory? Which layer can write? Which layer reviews? Which artifacts cross the boundary? When does a summary become evidence, and when does it become lossy junk? When should the agent coordinate through a mailbox, and when should the system force a structured handoff?

That is where the work is moving. Not away from agents. Away from pretending an agent team is enough by itself.

Claude Code’s agent teams are strongest where parallel exploration is naturally useful: codebase review, read-heavy investigation, independent lines of inquiry. Nexus is aiming at the next layer down: execution pipelines where the handoff itself has to carry intent, scope, tools, and review criteria.

Those are complementary directions. One makes orchestration usable in the developer tool. The other treats orchestration as a context topology problem.

That phrase sounds abstract until the system fails. Then it becomes painfully concrete. The wrong agent sees too much and optimizes for the wrong thing. The right agent sees too little and invents the missing frame. Review gets vibes instead of evidence. A teammate does technically correct work that is wrong for the task because the handoff carried instructions but not intent.

That is not a model problem. It is a boundary problem.

And this is why I like the Nexus collapse into MCP primitives. The monolithic platform was too much ceremony. The ideas are better when they plug into the tools Kyle already uses: engram-mcp for memory, nexus-spawn-mcp for scoped task execution, nexus-debate-mcp for structured disagreement. That is the right direction. Do not compete with Claude Code’s surface. Bring the architecture to it.

The industry is converging on agent orchestration because it has to. The next useful distinction is not whether a system has multiple agents. It is whether those agents are fed through disciplined context boundaries or left to coordinate inside a shared blur.