Multi-Agent Orchestration Is Eating Your Budget Alive (And Most Teams Are Building It Wrong)

The War That Broke Out in June 2025 (And Why It Matters)

In June 2025, Cognition, the company behind Devin, published a post called 'Don't Build Multi-Agents.' Within 24 hours, Anthropic fired back with their own post on how they built a multi-agent research system using Claude. The AI community lost its mind. Two serious, well-funded teams with real production systems came to almost opposite conclusions about the same architecture. That's not a coincidence. That's a signal. Cognition's argument was essentially about context engineering: every time you hand off a task between agents, you lose context, you introduce latency, and you multiply your failure surface. Their position is that a single well-prompted agent with access to the right tools will outperform a fragile chain of specialized agents nine times out of ten. Anthropic's counterpoint was that for genuinely complex, long-horizon research tasks, parallelism and specialization are worth the coordination overhead. Both of them are right. The problem is that most teams building multi-agent systems today are not doing either thing well. They're copying tutorial code from GitHub, wrapping it in a Slack bot, and calling it an autonomous workflow. That's not orchestration. That's chaos with a nice UI.

The Four Patterns That Actually Work (And One That Doesn't)

• ●Orchestrator-Worker: One controller agent breaks down the task, dispatches subtasks to specialized workers, and aggregates results. Works well when subtasks are genuinely independent. Breaks badly when workers need to share state mid-execution.
• ●Parallel Execution with a Critic: Run multiple agents on the same problem simultaneously, then use a separate critic agent to evaluate and select the best output. Costs more compute upfront but dramatically reduces the 0.95^n failure compounding problem.
• ●Hierarchical Delegation: Multi-level orchestration where a top-level planner delegates to mid-level coordinators who manage execution agents. Scales to genuinely complex enterprise workflows. Requires serious investment in inter-agent communication design.
• ●Reflection Loops: A single agent executes, a second agent critiques, the first revises. Simple, powerful, and underused. Anthropic's research system leans heavily on this. It's not flashy but it's reliable.
• ●The Pattern That Doesn't Work: Sequential chaining with no error recovery. This is what most people build first. Agent A passes output to Agent B passes output to Agent C. One bad step and the whole thing halts or, worse, silently produces garbage downstream. No checkpointing, no retry logic, no human-in-the-loop escape valve. This is how you end up with an 'automation' that needs more babysitting than the manual process it replaced.

The Part Nobody Talks About: Computer Use Changes Everything

Most multi-agent orchestration discussions are stuck in a world where agents only call APIs and process text. That world is fine for narrow tasks. But the moment you need an agent to actually interact with a real desktop, navigate a legacy web app that has no API, pull data from a tool your IT team will never integrate, or execute actions across a real operating system, you need computer use. Not API calls. Not scraping. Actual computer use, where an AI agent sees a screen, moves a cursor, types, clicks, and verifies the result visually. This is where the architecture gets interesting and where most orchestration frameworks completely fall apart. Frameworks built around text-in, text-out agent loops have no concept of visual state. They can't handle a popup that blocks the next action. They can't recover from a UI that loaded slowly. They assume the world is stateless and predictable. Real desktops are neither. This is why the computer use agent benchmark, OSWorld, exists. It measures whether an agent can actually complete real tasks on a real computer, not whether it can answer questions about completing tasks. The gap between those two things is enormous, and most teams don't discover it until they're already in production.

The Orchestration Architecture for Computer-Using Agents

When you're orchestrating agents that use computers, not just text, the patterns shift. You need visual state management between handoffs. If Agent A fills out a form and Agent B needs to verify the submission, Agent B can't just read a JSON payload. It needs to see the screen. You need idempotent actions wherever possible. Clicking 'submit' twice is not the same as calling an API endpoint twice. Computer use actions have real-world side effects. You need rollback strategies. What happens when Agent C encounters a CAPTCHA that Agent B didn't anticipate? Does the whole workflow fail? Does it page a human? Does it retry with a different approach? These aren't edge cases. They're the default state of working with real software in real companies. The orchestration layer has to be built around visual context, not just text context. That means your orchestrator needs to understand screenshots, not just strings. It means your worker agents need to report visual state, not just task completion status. And it means your error recovery logic has to account for the fact that the UI might look completely different from what the agent expected. This is hard. It's genuinely hard. Anyone telling you it's solved is selling something.

Why Coasty Is Built for This Exact Problem

I'm not going to pretend I stumbled onto Coasty by accident. I was looking for a computer use agent that could actually be orchestrated at scale, and the benchmark numbers are what stopped me. 82% on OSWorld. That's not a marketing number, it's the publicly available leaderboard score, and it's higher than every competitor shipping today. Anthropic's computer use, OpenAI's Operator, the academic baselines, all of them are behind. But the score isn't even the main thing. The architecture is. Coasty is built around the idea that computer use agents need to run in parallel, not just in sequence. Their agent swarm capability lets you spin up multiple computer-using agents executing different tasks simultaneously, which is exactly the parallel execution pattern that actually works. You're not chaining fragile agents in a line. You're running independent workers with a coordinator that aggregates results. It controls real desktops, real browsers, and real terminals. Not a sandbox. Not a simulation. The actual environment your workflows live in. And because it supports BYOK and has a free tier, you're not locked into a pricing model that makes parallel execution prohibitively expensive. That matters a lot when you're thinking about running ten agents at once instead of one.