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)

1. Team Lead — main cloud-code session that creates teams, assigns tasks, and coordinates.
2. Team Members — separate cloud instances that carry out tasks.
3. Shared Task List — a visible list of work items that all members can see.
4. 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