Claude Code Just Went Multi-Agent. Most Teams Aren't Ready.

Anthropic pushed a research preview into Claude Code this week that shifts the product's center of gravity. Dynamic workflows let Claude, specifically Opus 4.8 with the ultracode reasoning flag, write its own orchestration scripts and spawn coordinated subagents to attack large tasks in parallel. You are not looking at one model with a fat context window, reasoning linearly through your codebase. You are looking at a fleet. That changes how you build.

We have been running multi-agent systems for client projects and our own ventures at Kerber AI for a while now. The dirty secret is that the hard part was never the orchestration syntax. Anyone can spin up ten LLM calls and pipe JSON between them. The hard part is state management, cost discipline, and failure isolation. That stuff only surfaces when you are in production at 2 AM and three subagents have decided the same file needs conflicting edits.

From pair programmer to engineering manager

Single-agent coding assistants hit a ceiling. Part of it is context window. Part of it is cognitive architecture. You can stuff 200K tokens into a model, but it still reasons in a single thread. Dynamic workflows break that thread apart. Claude now acts more like an engineering lead. It scopes work, delegates to specialized subagents, and pulls their outputs together.

That sounds like the dream. In practice, your AI system just gained organizational complexity. You are not debugging one model's reasoning chain anymore. You are debugging distributed state. Did subagent A read the file before subagent B wrote to it? Does the orchestration script actually check for merge conflicts, or does it assume success because an LLM generated it? When a subagent hallucinates an API signature, does the parent catch it, or does it ship the hallucination downstream?

These are not theoretical concerns. We have seen agent fleets double their token burn because a parent agent kept spawning retry loops that never converged. We have seen coordinated subagents all try to patch the same function and produce a git history that looks like a Jackson Pollock painting. Anthropic's new feature makes the orchestration layer generative, which means the orchestration itself is now subject to the same hallucination risks as the code it produces.

What production teams should do now

If you are building with AI agents, treat this release as a signal, not a tool. The major labs are moving past the one smart assistant model and toward agent-native software architecture. Your stack needs to catch up.

That means three hard changes. First, observability cannot be an afterthought. You need tracing across agent boundaries. Token counts per call are not enough. You need full dependency graphs showing which subagent spawned which, what state they shared, and where they diverged. Second, cost controls need to be structural, not manual. Dynamic workflows can spin up a large fleet without asking. If you do not have budget guards and concurrency limits wired into the infrastructure layer, your next invoice will be a horror story. Third, fallbacks need to be first-class. When the orchestration script itself is generated by an LLM, you need deterministic escape hatches like human-in-the-loop triggers, circuit breakers, and rollback paths that do not depend on the agent correctly diagnosing its own failure.

At Kerber AI, we treat agent teams like distributed systems because that is what they are. The ventures we build and the client systems we run all share the same primitives: isolated execution contexts, explicit state contracts between agents, and telemetry that follows a task from initial prompt to final commit. Anthropic's dynamic workflows make the surface area bigger, but the underlying production discipline stays identical.

The labs are giving us more rope. The teams that thrive will be the ones that know how to tie knots.