Anthropic测试按角色拆分Agent，发现协调开销大于实际工作

Anthropic did something you'll regret ignoring:

They split one coding task across four agents by role, as a planner, implementer, tester, and reviewer.

The goal was to test whether splitting agents by job title is a good way to divide the work.

And they found agents spent more tokens on coordination than on the work itself.

They call it the telephone game, where each handoff degrades what the next agent receives.

OpenAI and Google also built machinery for this rather than leaving it to the prompt.

• OpenAI added a "handoffs" primitive to the Agents SDK - Google's ADK controls how much parent context reaches a sub-agent.

Both are design-time wiring. You declare which agents are reachable from which, and both ends run inside the same framework.

This setup assumes you know which agent feeds which before the run starts, but plenty of agent work isn't known in advance.

Switch, from @Flint_AI_, is built for that case. It puts agents and people in the same chat channel, so any two of them can work together without being wired to each other in advance.

Say the error rate on a checkout service rises. An on-call agent queries the logs and finds the deploy behind it. Reading that, someone decides the next step is a chart against last week's baseline.

That decision did not exist a minute ago, so no handoff would have been declared for it. The charting agent is a separate session with an empty context window, often a different framework on a different machine.

So the person makes the routing call and then moves the payload too, by reading the first agent's answer and typing a version of it into the second.

This creates three problems:

1) The charting agent has no record of the earlier session, so on the next incident it recomputes work the first agent already did.

2) The charting agent only sees the conclusion without the queries behind it, so it either trusts the summary or reruns the retrieval itself.

3) When the first agent finds no regression, nobody types that anywhere, and the rest of the team never learns it was checked.

With Switch, since everyone is working in a shared channel, the person still decides what runs next, but they stop carrying the payload.

The charting agent joins a channel that already holds the first agent's report, so it points at that report directly instead of rerunning the queries, and the next incident starts from a channel that shows the earlier one.

The team reads the same thread the agents do, so a no-regression result is visible the moment the first agent posts it.

Switch connects agents built with Claude Code, OpenAI Codex, OpenCode, or any HTTP/MCP-compatible framework directly to the tools your team already uses, like Slack, Teams, Discord, Telegram, and Mattermost.

Here's the repo: https://www.flintai.dev/switch-github?utm_source=X&utm_medium=influencer&utm_campaign=switch&utm_term=avi_chawla

Thanks to Flint AI team for partnering with me on this post.