> AI Agents Need a Control Plane, Not Just Better Code

The hype cycle for AI coding agents has shifted. We are no longer impressed by an LLM completing a function; we are now staring down the barrel of multi-agent chaos. In a recent deep dive on DEV.to, developer mottych argues that the bottleneck in modern software development is no longer code generation, but process orchestration. After nearly six months of building a custom system called IssueFlow, the conclusion is stark: capable agents are useless without a rigorous control plane to manage dependencies, human gates, and infrastructure failures.

The Glue Problem

Mottych describes a familiar nightmare for anyone running multiple agents like Claude Code, Cursor, or Windsurf. You start with the best intentions, automating tasks that used to require constant interaction. But soon, you become the human middleware. You are manually tracking which agent is working on which GitHub issue, resolving merge conflicts between concurrent agents, and deciding if a CI failure is a code error or an infrastructure hiccup. The developer becomes the 'glue' holding the entire system together, attached to the chat all day long, which defeats the purpose of automation.

Workflow Is Not a Straight Line

The core insight from the IssueFlow experiment is that software development is non-linear and messy. A standard issue might require design review, approval, implementation, and testing, but failures happen in unpredictable ways. A design review might reject the approach, sending work back for revision. A test failure might require a complete redesign. An infrastructure error might need a retry, not a code rewrite. Mottych argues that existing agent frameworks struggle with this dynamic routing. They expect linear progress, but real development involves loops, escalations, and cross-repository dependencies that break simple prompt chains.

Defining the Development Control Plane

The proposed solution is a 'development control plane' that sits on top of existing tools like GitHub and IDEs. This layer manages explicit dependencies and concurrency rules, ensuring agents don't collide over shared resources. Crucially, it distinguishes between deterministic operations and agentic reasoning. Some steps, like source control merging, should be handled by process executors, not LLMs, to save tokens and reduce latency. Other steps, like architectural decisions, require agentic reasoning. The control plane routes work based on evidence from execution, escalating to a human only when judgment is genuinely needed.

The Human-in-the-Loop Gate

Contrary to the 'full automation' hype, mottych insists on preserving human agency for high-stakes decisions. The system is designed with configurable human gates. A minor documentation change might bypass approval, while a major domain model redesign in a DDD/CQRS architecture demands explicit sign-off. This prevents agents from making costly mistakes, like choosing a new architectural pattern or triggering a $2,000 AWS bill increase, without supervision. The goal is not to remove humans from the loop, but to remove the mechanical coordination work, allowing developers to focus on product intent and quality.

Key Takeaways

• Orchestration is the new bottleneck: Writing code is solved; managing the workflow around code is not.
• Non-linear routing is essential: Development processes involve loops, retries, and cross-repo dependencies that simple agent chains miss.
• Hybrid execution matters: Combine LLM agents for reasoning with deterministic process executors for mechanical tasks like merging.
• Human gates must be configurable: Not every decision requires approval, but critical architectural changes must be gated.
• Visibility is key: Track token consumption, waiting times, and failure rates to identify workflow bottlenecks.

The Bottom Line

We are moving past the era of 'prompt engineering' and into the era of 'workflow engineering.' If your AI agents are creating more coordination overhead than they save in coding time, you are building the wrong abstraction. The future belongs to those who can govern the chaos, not just generate the code.