Wink Pings

Multi-agent isn't always smarter: Google research finds divisible tasks improve 80.8%, while chain-like tasks are 70% worse

Google Cloud released five research-backed agent orchestration patterns. The most memorable takeaway: when tasks can run in parallel, agent teams are up to 80.8% better; when each step depends on the previous one, they are instead 39% to 70% worse. Includes one ready-to-use prompt.

Google Cloud published a guide to multi-agent collaboration, written by YK Sugi. The article presents five research-backed agent orchestration patterns and includes ready-to-use prompts. Many teams now orchestrate agents by vibe; the value of this piece is that it lays out the criteria and data.

What is really interesting is the opening set of data: when a task can be cleanly split, agent teams are up to 80.8% better than a single agent; when the task is chain-like and each step depends on the previous one, they are instead 39% to 70% worse.

Here's the conclusion up front: don't treat 'multi-agent' as the default option. It only wins when a task can be split into independent parts. Once there are many dependencies, context is lost with each handoff, and the team is worse than one person.

Here, agent means an AI coding agent that can call tools and edit code on its own. This Google Cloud guide applies to Antigravity, Claude Code, or other coding agents.

Five patterns:

Builder + Verifier
Separate building and verification. One agent makes the change; another agent, in a new thread, only reads and checks whether the diff meets the requirements. When a model reviews its own output in the same thread, it tends to approve of itself. Research also shows that models have difficulty correcting their own reasoning without external feedback.
Use for: important changes. For small changes or when tests provide a safety net, self-review is enough.

Lanes
Split tasks by directory or domain into non-overlapping lanes, e.g., one subagent each for web/, api/, and docs/, with none touching the others' files. A 2026 study of 652 coding tasks found that two agents modifying overlapping code had a success rate about 30% lower than one agent doing two tasks. Google and MIT research shows that on divisible finance tasks, agent teams were 80.8% better, while on planning tasks they were 39% to 70% worse.
Use for: parallel work that can be split cleanly. Do not use for small bug fixes.

Best of N
Run multiple parallel attempts of the same task and use a test suite or eval to pick the best. DeepMind's AlphaCode follows this idea. In 2024 research, for tasks with automatic checks, pass rate kept rising with the number of attempts; real GitHub issues rose from 15.9% with one attempt to 56% with 250 attempts. Without automatic checks, majority voting or scoring models stopped improving after about 100 attempts.
Use for: tasks with clear automatic evaluation.

Council of Models
Multiple models independently propose solutions, then a fresh batch of reviewers scores them without knowing the authors, and finally the strongest ideas are merged. This pattern suits architecture and design questions that have no tests or automatic checks. Research shows that combined scoring from multiple models exceeds a single frontier model; a jury made up of different models gets closer to human judgment than a single large judge.
Use for: decisions with no objective standard, such as architecture and visual design.

Team of Reviewers
Multiple read-only reviewers work in parallel, each responsible for only one role: UX, simplicity, edge cases, security. A 1995 study of human reviewers found that teams where each person focused on one type of error found about 35% more problems than teams using the same general checklist. LLM judge research reached similar conclusions. After fixes, bring in fresh reviewers to recheck until all approve.
Use for: the review step before merging a PR.

The five patterns can be mixed and matched. The original Google Cloud article includes flowcharts and more prompts.

One ready-made use: X user namcios turned this guide into a prompt that can directly have Claude Code configure these five patterns in .claude/skills/, and indicate when to use which pattern and when a single agent is more suitable. The full prompt is below:

read this Google Cloud article: https://x.com/googlecloud/status/2123428849262248255 (if you can't open it, use the summary below)

set up this repo to run agent teams with its 5 patterns, as skills in .claude/skills/:
1. builder + verifier: after any change that matters, a fresh read-only subagent checks the diff does what I asked
2. lanes: split work across parallel subagents only when it divides cleanly by folder (e.g. web/, api/, docs/), each one edits only its own files. keep step-by-step work and small bug fixes in one thread
3. best of N: when there are tests or evals, run several attempts in parallel worktrees and let the tests pick the winner
4. council: for calls with no automatic check (architecture, design), get independent proposals, have fresh judges score them with authors hidden, then merge the best ideas
5. reviewer team: before a PR, run parallel read-only reviewers for UX, simplicity, edge cases and security, fix what they find and repeat with fresh reviewers until all approve

add a short rule for when to use each pattern and when a single agent is better. show me the plan before changing anything

Some commenters said this is the AI version of Brooks's Law: adding people only helps when work can be parallelized; when each step depends on the previous one, every handoff is a loss. Others cautioned that an agent team needs someone accountable for the final result; otherwise coordination becomes a meeting without minutes.

Original article: Google Cloud: 5 agent orchestration patterns backed by research
Prompt from: namcios's tweet

发布时间: 2026-11-20 20:02