DEV Community

Cover image for 5 agent orchestration patterns backed by research
YK for Google Cloud

Posted on Originally published at x.com

5 agent orchestration patterns backed by research

A lot of developers run teams of agents and agent orchestration by vibe, but is it actually effective?

In this article, I'll introduce five research-backed patterns for running agent teams in Antigravity, Claude Code, or any other coding agent. Whether you're creating new applications, maintaining legacy codebases, or running research, you'll learn when each pattern beats a single agent and get ready-to-use prompts to try it yourself.

Originally posted on: https://x.com/googlecloud/status/2123428849262248255

1. Separate the builder and the verifier. Instead of having a single agent handle everything, we can separate the building and verification into two separate threads. One agent builds. A second agent in a fresh thread checks whether the result does what you asked for. A model reviewing its own work in the same thread risks being biased by its own previous output.

In fact, studies show models are poor judges of their own work. They struggle to fix their own reasoning without outside feedback and favor their own output over others.

Use this pattern for changes that matter. Self-review can still be fine for small changes, or when tests give feedback.

Prompt: Start one fresh subagent as a read-only verifier. Have it check whether this diff does what I asked for.

Builder and verifier: the main thread writes the change and sends the diff to a fresh read-only verifier subagent, which reports back

2. Split work into lanes. When a task divides cleanly, give each part its own owner, such as one subagent each for frontend, backend, and docs. Have them work in parallel without editing the same files.

In a 2026 study of 652 coding tasks, two agents working on overlapping code succeeded about 30% less often than one agent doing both tasks.

In a Google and MIT study, agent teams scored up to 80.8% higher than one agent on a finance benchmark with independent parts, and 39% to 70% lower on a planning benchmark where each step depends on the last.

Agent teams scored up to 80.8% higher than one agent on a finance benchmark with independent parts, and 39% to 70% lower on a planning benchmark where each step depends on the last

For work that is hard to split into clean parts like frontend and backend, one thread often performs better. The same goes for small bug fixes, where parallel subagents did not help in another study.

Prompt: Start three subagents in parallel: one for the frontend in web/, one for the backend in api/, and one for docs in docs/. Each one edits only files in its own folder. When all three finish, check that the parts work together.

Split into lanes: the main thread splits work across frontend, backend, and docs writers, each editing only its own files, then collects the work

3. Best of N. Run the same task several times in parallel and let a test suite or eval pick the winner. AlphaCode, a coding system from DeepMind, worked this way. It generated many candidate programs and filtered them by running them. This method performed competitively in programming contests.

In a 2024 study of this Best of N approach, pass rates kept climbing across thousands of attempts on tasks with automatic checks. On real GitHub issues, one model went from 15.9% solved on one attempt to 56% at 250 attempts. Without an automatic check, picking a winner by majority vote or a scoring model leveled off around 100 attempts.

Best of N: N isolated tries run in parallel, and a test or eval picks the winner

Prompt: Run five subagents in parallel on Gemini 4 Hydrogen, each trying to optimize this in its own worktree. Score each attempt on the evals, pick the best one, and tell me the result.

4. Council of models. Ask several models for independent proposals, have judges vote with the model names hidden, then merge the strongest ideas. Use it when there is no clear test or automatic check, such as architecture or visual design.

In one study, combining answers from several models scored higher than a single frontier model. In another, a panel of different models matched human judgment better than a single large judge.

Council of models: three models propose, three judges vote blind, and a synthesizer merges the result

For example, I designed this ship logo with a council of models. Two rounds took it from a plain first try to the final icon.

Ship logo designed with a council of models over two rounds, from a plain first try to the final icon

Prompt: Ask Gemini 4 Carbon, Gemini 4 Neon, and Claude Opus 5.5 each for one independent design. Have three fresh agents on Gemini 4 Carbon, Gemini 4 Neon, and Claude Opus 5.5 score the designs with model names hidden. Merge the best ideas into the winner.

5. Team of reviewers. Run several read-only reviewers in parallel, each with one job, such as UX or security.

In a classic 1995 study with human reviewers, teams whose members each looked for a different type of mistake found roughly 35% more mistakes than teams where everyone used the same general checklist of common mistakes.

Turns out, a similar pattern holds for AI reviewers. In a study of LLM judges, a team with different roles matched human judgment better than a single judge, and did worse when all shared one role.

Team of reviewers: UX, code simplicity, edge cases, and security reviewers run read-only in parallel and report back to the main thread

Prompt: Start four read-only reviewers in parallel for UX, code simplicity, edge cases, and security. Fix what they report, then repeat with fresh reviewers until all four approve.


These patterns are more of building blocks than strict rules. You can mix and match them in any way that works for you, but here is a simple flowchart to guide you on which one to use when:

Flowchart for picking a pattern: single thread, builder plus verifier, split into lanes, best of N, or council of models, then a team of reviewers for large changes

Top comments (0)