Claude Code's New Agents Team Are Absolutely Insane

Agent Teams in Cloud Code: A Detailed Overview

Key Concepts:

• AI Coding Agents: Autonomous systems leveraging Large Language Models (LLMs) to generate and modify code.
• Sub-agents: Lightweight, independent worker agents used for focused tasks within Cloud Code.
• Agent Teams: Multiple instances of Cloud Code working collaboratively, communicating and coordinating through a shared task list and messaging system.
• Team Lead: The primary Cloud Code session that manages and coordinates the Agent Team.
• Shared Task List: A central list of tasks visible to all team members.
• Mailbox: A messaging system enabling communication between agents within the team.
• MCP (Model Context Parameters) Servers & Skills: Resources providing agents with specific capabilities and knowledge.
• Context Window: The amount of text an LLM can process at once, influencing its ability to understand and respond to information.

1. The Problem of Agent Degradation & Initial Solutions

The core issue with AI coding agents, specifically within Cloud Code, is a decline in performance – “they get dumber the longer they work” – as details become blurred and quality decreases. Anthropic’s initial response was the introduction of sub-agents. These are designed for quick, isolated tasks, receiving assignments from a main agent, completing them, and returning a summary. While theoretically sound, this approach falters when sub-agents need to coordinate or share information, leading to potential conflicts and redundant work.

2. Introducing Agent Teams: Collaborative AI Development

To address the limitations of sub-agents, Anthropic has introduced agent teams. This system utilizes multiple independent instances of Cloud Code capable of communicating and collaborating.

• Traditional Sub-agent Architecture: A central orchestrator (main agent) assigns tasks to individual sub-agents, which operate in isolation and report results back. This works best for independent, focused tasks.
• Agent Team Architecture: A team lead (replacing the simple orchestrator) manages the team. All team members have access to a shared task list and can communicate with each other and the team lead. Users can also directly interact with individual team members.

3. Agent Teams in Action: A C Compiler Case Study

An engineer at Anthropic successfully built a fully functional C compiler using agent teams over 2,000 Cloud Code sessions, incurring an API cost of 20,000. This demonstrates the potential of the system for complex projects.

4. Sub-agents vs. Agent Teams: When to Use Which

| Feature | Sub-agents | Agent Teams | |---|---|---| | Context Window | Each agent has its own independent context window. | Each team member has its own independent context window. | | Communication | Limited; results-focused, no cross-communication. | Extensive; agents can communicate and coordinate. | | Best Use Case | Focused, isolated tasks. | Complex problems requiring discussion and collaboration. | | Cost | Lower token cost. | Higher token cost due to running multiple Cloud Code instances. |

5. Agent Team Architecture: Core Components

The agent team architecture consists of four key components:

• Team Lead: The primary Cloud Code session responsible for team creation, coordination, and communication.
• Team Members: Separate Cloud Code instances assigned to specific tasks.
• Shared Task List: A centralized list of tasks for team members to work on.
• Mailbox: A messaging system facilitating communication between agents.

These components operate through files (MD or JSON) stored locally, coordinating the team’s activities.

6. Setting Up and Using Agent Teams in Cloud Code

The feature is experimental and requires enabling via the settings.json file or a specific Cloud Code command. Using a tool like T-Max is recommended for a split-view interface, allowing simultaneous observation of multiple agents working in parallel and direct communication with each team member.

7. Practical Considerations & Best Practices (Based on Eddie Usmani’s Insights)

Eddie Usmani (Director, Google Cloud AI) provides guidance on effective agent team utilization:

• Task Sizing: Avoid tasks that are too small (high coordination overhead) or too large (wasted effort, lack of check-ins). Focus on self-contained units with clear deliverables.
• File Ownership: Minimize simultaneous editing of the same files to prevent conflicts. Assign different files to different agents.
• Context Loading: While all agents access the root cla.md file and MCP servers, they do not inherit the team lead’s conversation history. Include task-specific details in each agent’s prompt to maintain context.
• Lead Role: The team lead should delegate tasks rather than directly implementing code. LLM behavior can sometimes lead to the lead taking on implementation responsibilities.
• Task Status: Be aware that task status updates may lag due to the system’s experimental nature.
• Team Nesting: Currently, only one team per session is supported; nested teams are not possible.
• Code Volume vs. Value: Multi-agent systems often generate more code, but this doesn’t necessarily translate to increased value. Maintain focus on specific tasks.
• Problem-Driven Tooling: Let the problem dictate the tools used, not the other way around. Agent teams aren’t necessary for every task.

8. Data & Statistics

• A working C compiler was built using 2,000 Cloud Code sessions and 20,000 API cost utilizing agent teams.
• Agent teams incur higher token costs compared to sub-agents due to the simultaneous operation of multiple Cloud Code instances.

9. Display Modes

• Split Panes (iTerminal 2 or T-Max): Provides a visual representation of multiple agents working concurrently.
• Process Mode (Terminal/VS Code): Agents operate sequentially; users can switch between them using shift + up/down arrows.

Conclusion:

Agent teams represent a significant advancement in AI-assisted coding, offering a collaborative approach to complex software development. While still experimental and carrying a higher cost, the ability for agents to communicate, coordinate, and share knowledge promises to overcome the limitations of individual agents and unlock new levels of productivity. However, careful task management, context awareness, and a problem-focused approach are crucial for maximizing the benefits of this powerful new feature. The key takeaway is to strategically apply agent teams to problems that genuinely require collaboration and communication, rather than simply adopting the latest technology.