14K Stars Open-Source Desktop App cc-haha: 5 AI Agents That Divide and Conquer on Their Own

One Command, Five AIs That Split the Work Themselves

Traditional AI coding assistants require human-issued instructions one at a time: tell it to write the frontend, then the backend, then manually arrange testing. In the open-source Claude Code desktop client called cc-haha, things work quite differently — content creator AJiang issued a single command, and the agents divided up the work entirely on their own.

In AJiang's demo, five AI Agents worked simultaneously. Who handled the frontend, who handled the backend, who did testing, who did code review — none of it was manually assigned. The agents negotiated the division of labor themselves. Even more interesting: after finishing their current tasks, each Agent would proactively "pick up" the next item on the list, forming a kind of self-organizing workflow.

Agent Teams: A Captain-Led Collaboration Mechanism

At the heart of this system is Agent Teams — an experimental feature officially introduced for the first time by Anthropic. Its organizational structure has a distinctly "team-based" feel:

• Team Leader: Responsible for creating team members and building the entire shared task list;
• Members: Each picks up and executes tasks, marks them complete, then automatically moves on to the next;
• Task Dependencies: The full task list clearly shows which tasks depend on others and the order in which they should be executed.

Crucially, there's a communication protocol between Agents. The Team Leader can assign tasks and send direct messages to members; members report progress back to the leader; system messages flow throughout. This makes multi-AI collaboration observable and traceable rather than a black box.

The theoretical foundation behind Agent Teams is the Multi-Agent System (MAS). In traditional software engineering, decomposing large tasks across multiple specialized roles for parallel execution is well-established practice. Agent Teams transplants this idea into the LLM domain: each Agent instance has its own independent context window and tool-calling capabilities, coordinating through message passing rather than sharing a single conversation stream. The core advantage of this design is context isolation — the frontend Agent only needs to focus on frontend-relevant information, without "seeing" backend implementation details, reducing interference and the likelihood of errors. The Team Leader Agent essentially acts as an Orchestrator, responsible for Task Decomposition and building a Dependency Graph; member Agents serve as Executors. This architecture aligns with the design philosophy of multi-agent frameworks like LangGraph and AutoGen, but Anthropic has built it directly into the Claude Code SDK layer, sparing users from having to manually construct an orchestration layer.

How to Use It in cc-haha? The Steps Are Simple

cc-haha is an open-source project with 14K Stars, and the Agent Teams visualization page is its newest feature. The setup isn't complicated:

1. Update cc-haha to the latest version (the demo uses 0.6.3);
2. Go to the "General" section in Settings and confirm that Agent Teams is enabled (it's on by default; you can disable it if not needed);
3. Add the phrase "use agent teams to collaborate" to your prompt.

AJiang notes that a reasonably capable model, upon receiving this instruction, will know to use Agent Teams for subsequent planning. For a task like full-stack development, it will first establish the "contract" — completing design documents, defining API structure, and clarifying how the frontend and backend will interact — before splitting out specific tasks and creating the corresponding members. Once planning is done, a card appears in the interface; clicking it takes you back to the team collaboration visualization.

The 40 Million Token Cost and Where It Makes Sense

This powerful collaboration comes with a significant price tag. AJiang was candid: the demo task consumed roughly 40 million tokens, though a cache hit rate of 99% substantially offset the cost.

This leads to a pragmatic takeaway: not every task is suited for Agent Teams. Many tasks are perfectly handled by a regular subagent, and some are inherently sequential by nature — forcing them into a multi-agent framework is wasteful. Agent Teams is better suited for complex development scenarios that are naturally parallelizable and require multiple specialized roles. In other words, it's a powerful tool, but only when used in the right context.

The 40 million token figure sounds staggering, but "99% cache hit rate" is the key to understanding the actual cost structure. The Claude API supports Prompt Caching: when multiple Agents repeatedly read the same design document, codebase context, or system prompt, that content is only charged at full price on the first request — subsequent cache hits cost roughly 10% of the original price. In parallel multi-agent scenarios, member Agents share large amounts of common context (such as API contract documents and code style guides), which is precisely where caching shines. As a result, the actual bill is often far lower than a simple "raw token count × full price" estimate. For cost-conscious developers, before enabling Agent Teams it's worth evaluating how much shareable context exists in the task: the more shared content and parallel rounds there are, the more significant the caching benefit.

Want to Dig Into the Internals? The Code Is All Open Source

For developers who want to understand the underlying mechanics, the Agent Teams code — including its SDK layer and cc-haha's visualization code — is all available in the open-source repository. AJiang suggests that interested developers clone it and even let an AI Agent help analyze how the collaboration mechanism is implemented.

It's worth noting that Agent Teams remains an experimental feature on Claude Code, and cc-haha's visualization implementation is similarly exploratory. It represents a direction for AI-assisted programming — moving from "solo work" toward "team collaboration" — but it's still some distance from production-grade stability. For developers willing to experiment and comfortable with higher token consumption, this is undeniably an open-source project worth getting your hands on.