---
title: "One Agent, Many Teams: Fold the Subagents, Not the Teams"
pubDate: 2026-11-20T00:00:00.000Z
tags:
  - AI
  - Architecture
  - Agents
image: /images/blog/one-agent-many-teams/featured.png
---

import TeamMap from '../../components/TeamMap.astro';
import TeamFigure from '../../components/TeamFigure.astro';

## TL;DR
Anthropic [advises against](https://claude.com/resources/articles/building-agents-when-to-fold-subagents-into-your-main-agent-loop) splitting an agent into subagents along team lines, and I've seen products fail that way. The opposite doesn't work either: when one team owns the agent, every other team waits on it. Customers need one coherent conversation; teams need to ship without each other. So keep one agent and split who owns its parts: a platform team owns the agent loop, and feature teams contribute skills, MCP servers and eval cases without touching the model or the prompt. One central eval set, which every team adds cases to, runs on each pull request; a team merges once its change hasn't broken another team's conversations.

<TeamFigure name="shapes" />

*Three ways to split one agent among three teams. In the first, the teams' agents pass the customer between them; in the second, every team waits for one; in the third, one agent serves the customer and each team ships its own parts.*

## Subagents per team: the handoffs break the conversation

The running example is invented to protect the client, but the projects behind it are real. Northstar Bank automates its first-level support. Three teams own the systems the agent needs: Accounts (logins, locks), Cards (blocks, replacements) and Payments (transfers, limits).

The obvious design gives each team its own subagent behind a router. Each team writes its own prompt, picks its own tools and ships on its own schedule. The teams are independent, but each subagent sees only its part of the customer's problem.

Alex Carter writes in: their account is locked, and the card they tried in the meantime was blocked too. The router has to pick one subagent, and whichever it picks hands half the problem to the other.

<TeamFigure name="handoff" />

*Accounts passes the card on, but not the lock or the account number, so Cards asks Alex for something Alex already wrote.*

Anthropic's article names the pattern: the architecture becomes "a copy of their org chart (Conway's law at work)", and information degrades "with each handoff". It also describes a system prompt where "every team adds a sentence", evals nobody owns end to end, and a single loop running about twice as fast as the multi-agent version.

## One team owns the agent: everyone else waits

The article's fix is one agent loop: one model, one context window, skills and tools loaded as needed. But one loop easily becomes one team. If the agent team owns the account lookup, the card tools and the bank's procedure for a locked account, every change in Accounts, Cards or Payments queues behind it, and the teams who know their systems best end up writing tickets. I've seen projects struggle when teams were coupled so tightly that none could work on its own.

A team that has to coordinate with three others before changing its own part changes it less often. The question is how to get one loop at runtime while every team still ships on its own.

## What others report

| Who | Runtime design | What they report |
| --- | --- | --- |
| [Anthropic](https://claude.com/resources/articles/building-agents-when-to-fold-subagents-into-your-main-agent-loop) (Oct 2026) | One loop, skills and tools loaded as needed | Agents split by team copy the org chart; a single loop often matched or beat them on quality, cost and latency |
| [Shopify Sidekick](https://shopify.engineering/building-production-ready-agentic-systems) (Aug 2025) | One loop | The system prompt grew into conflicting special cases; they moved instructions into the tools |
| [Cognition](https://cognition.com/blog/dont-build-multi-agents) (Jun 2025) | One agent | With subagents, decisions get dispersed and context isn't shared well enough |
| [Sierra's MCP gateway](https://sierra.ai/blog/building-sierras-mcp-gateway-an-engineering-iceberg) | One gateway, many owners | A central team configuring every integration became the bottleneck; service owners took over |
| [monday.com Sidekick](https://langchain.com/blog/building-monday-com-sidekick-why-capable-agents-need-more-than-just-tools) (Aug 2026) | One loop, then an orchestrator with subagents | Adding one tool broke unrelated workflows and testing became combinatorial; subagents gave clearer ownership |

Almost all of these come from vendors or vendor-hosted blogs, Anthropic's included, and I found no independent post-mortem. They agree that a shared gateway works when each team configures its own part. They disagree on what one loop costs: one team's new tool can change which tool the model picks for another team's request, and one team's change can fail another team's evals. Shopify kept the loop and moved instructions into the tools; monday.com split it up. monday.com's post names no model, and tool selection depends heavily on the model, so your own evals on your model are better evidence than either.

## One loop, many owners

<TeamMap preset="overview" />

*The platform team owns the loop, the system prompt, the model, the gateway and the eval gate. Each feature team contributes a skill, an MCP server and eval cases.*

### Skills: how each team works

<TeamMap preset="skills" />

Accounts writes the skill for a locked account: look the customer up, never ask for what we can find, check the security flag before any unlock. The procedure lives with the team that knows it, not in a shared system prompt, and the agent loads it when a message needs it. Shopify [returns instructions with each tool's results](https://shopify.engineering/building-production-ready-agentic-systems) instead, which also keeps them with the team. But the model sees those only after calling the tool, too late to help it choose one; a skill is found before the agent acts.

### Tools: one MCP server per team

<TeamMap preset="tools" />

Accounts runs an MCP server with `accounts_lookup` and `accounts_send_unlock_link`; Cards runs one with `cards_get_status`. Each registers with a central gateway such as [LiteLLM's](https://docs.litellm.ai/docs/mcp), which handles authentication and decides which tools the agent sees, so no team builds auth itself, as an [enterprise MCP platform write-up](https://newsletter.optimistengineer.com/p/building-an-enterprise-mcp-platform-594) also argues. Behind a stable interface, a team changes its server whenever it likes. Sierra's gateway scaled once each service's owners, not a central team, configured its integration.

### Evals: one shared test suite

<TeamMap preset="evals" />

There is one central eval set for the one agent, stored in a tool such as [MLflow](https://mlflow.org/docs/latest/genai/). Every team adds cases to it: Accounts adds cases like Alex's, with the reply an expert would accept. The platform team runs the whole set on every pull request, its own included.

## Keeping the teams independent

In one loop, a team's change can break another team's conversations. The balance is delicate: with too much central control, teams wait on the platform team again; with too little, the agent falls back into team-shaped pieces. So every change takes the same self-service path, a pull request:

1. Cards opens a pull request that adds a tool, say `cards_order_replacement`, together with eval cases for it. CI rejects a new tool that comes without cases.
2. CI runs the central eval set, now including Cards' new cases, against the whole agent.
3. If the existing cases aren't significantly broken, Cards merges. Someone from the platform team may have to approve, but they check the eval results, not Cards' domain logic.

The platform team maintains that path and the interfaces behind it: the loop, the gateway and the eval set. Its job is to keep the path self-service, not to review every team's work. If teams start waiting on it, it has become the bottleneck this design was meant to remove.
