Summary of "AI 코딩 에이전트가 갈수록 멍청해지는 이유? Anthropic의 파격적인 해결책 'Agent Teams'"

Anthropic’s “Agent Teams” — Summary

Problem

Single AI coding agents tend to degrade in long or complex sessions: details blur, coordination fails, and independently-running agents can produce conflicting changes to the same codebase.
A previous fix (subagents / lightweight workers) helps for isolated tasks but breaks down when multiple workers need to coordinate or share state.

What “Agent Teams” are

Agent Teams are a multi-instance cloud-code pattern consisting of multiple independent agent instances (team members) plus a team lead (the main orchestrator). Key properties:

Each team member is its own agent instance with an independent context window.
All members can:
- Read a shared task list.
- Communicate with each other and with the team lead.
- Be messaged directly by the human user.
Implementation details: teams are represented as local files (MD/JSON configuration) and use a mailbox-like messaging system for inter-agent communication.

Architecture (four components)

Team Lead — main cloud-code session that creates teams, assigns tasks, and coordinates.
Team Members — separate cloud instances that carry out tasks.
Shared Task List — a visible list of work items that all members can see.
Mailbox — a messaging system for inter-agent communication.

When to use Agent Teams vs Subagents

Subagents: best for focused, isolated tasks where only the result matters and internal interaction between workers is unnecessary.
Agent Teams: best for complex problems requiring discussion, coordination, cross-component reasoning, or staged dependencies.
Trade-offs: Agent Teams spawn multiple full cloud-code instances (each with its own server/tooling), so token and compute costs are significantly higher than with subagents.

Practical demo / usage notes

Feature status: experimental in Cloud Code — must be enabled (edit settings JSON or ask Claude Code to toggle).
Interfaces:
- Interactive UI (e.g., “Tmax/TeamMax”) provides split panels for parallel agents.
- In a plain terminal it runs in process mode (no split-panel UI), but you can still message and select team members.
Controls:
- You can request a specific number of team members or let the system decide.
- Team members can block waiting for others (visible dependency behavior).
- The user can send individual messages to agents; the team lead mediates communication.
Example claim from the demo:

An engineer assembled a working C compiler across roughly 2,000 cloud-code sessions using Agent Teams.

Practical considerations, limitations, and cautions

Cost: many agent instances result in much higher token and compute consumption.
Coordination overhead: too-small tasks make coordination wasteful; too-large tasks risk agents working without synchronizing. Rule of thumb: assign independent units that yield clear results.
File ownership and conflicting edits: explicitly manage which agent touches which files and when to avoid overlap.
Context inheritance inconsistencies: subagents and team members can access project files but do not always inherit the lead’s conversation history — include task-specific details in prompts to reduce disconnects.
Leads doing work: team leads may start implementing tasks instead of delegating — monitor roles and prompts to avoid role drift.
Experimental & constrained: currently one team per session, possible status delays, and overall immaturity. More code produced by many agents does not automatically mean more value.

Best practices

Use Agent Teams only when the problem complexity warrants the coordination overhead.
Design tasks at the right granularity (not too small, not too large).
Explicitly define file ownership and interfaces in prompts.
Include task-specific context in team member prompts to avoid context loss.
Prefer subagents for simple, isolated tasks to save cost and complexity.

Verdict from the video

Agent Teams are a promising experimental feature for tackling complex, collaborative coding tasks, but they add cost, complexity, and new failure modes. They are worth experimenting with, but should be used judiciously.

Main speakers / sources cited

Anthropic — introduced Agent Teams in Cloud Code / Claude Code
Claude Code (product / cloud code agent)
Eddie Usmani (Director, Google Cloud AI) — guidance cited on task sizing, coordination, and file ownership
Video narrator / demonstrator (unnamed) — provided the demo, setup walkthrough, and practical tips