How to Install and Use Claude Code Agent Teams (Complete Guide)

OpenClaw's community was already orchestrating multi-agent sessions with custom skills. Now Anthropic shipped it natively into Claude Code. Here's how to set it up and start using it today. OpenClaw built it first, now Anthropic made it official The OpenClaw community figured this out first. They built custom skills that let you orchestrate multiple Claude Code sessions working together on the same project, coordinating tasks, sharing context, running in parallel. It was clever, it worked, and it clearly caught Anthropic's attention. Because they just shipped the same thing natively into Claude Code. No plugins, no workarounds, no custom skills. It's built right in now and they're calling it "agent teams." Instead of one agent doing everything in a straight line while you sit there watching it think, a lead agent now breaks your task into pieces, spins up multiple teammates, and they all go to work at the same time while actually coordinating with each other. Think of it like going from one freelancer doing everything solo to a project manager who shows up with a full crew and delegates across all of them. It's in research preview right now, most people don't know about it yet, and this guide covers everything you need to install it, configure it, and actually use it properly. One agent used to do everything solo, now it shows up with a team Up until this update, Claude Code worked like a single employee. You'd give it a job, it would start at step one, finish it, move to step two, finish that, and keep going until the whole thing was done. Sequentially. One task at a time. Agent teams change that completely. You describe what you want, and instead of one agent grinding through it alone, a lead agent looks at the task, breaks it into pieces, and spins up separate teammates to handle different parts at the same time. One teammate might be researching your codebase while another is debugging a function while another is writing tests. They each have their own context window, their own workspace, and they can message each other directly to share what they're finding. The lead agent stays on top of all of it, coordinating the work, managing a shared task list, and pulling everything together once the teammates finish. You can even jump in and talk to any teammate directly if you want to redirect them or ask a follow-up question without going through the lead. "But wait, aren't sub-agents already a thing?" - yes, and here's the difference If you've been using Claude Code for a while, you've probably already used sub-agents. They spin up inside your session, do a focused task, and report the result back to the main agent. Simple, effective, and relatively cheap on tokens. Agent teams are a different animal. Each teammate is a fully independent Claude Code session with its own context window. They don't just report back to the lead, they talk to each other directly, share findings, challenge each other's work, and self-coordinate through a shared task list. Sub-agents are like sending an assistant to go grab you an answer. Agent teams are like putting a group of specialists in a room and letting them work through a problem together. The practical difference comes down to one question: do your workers need to communicate with each other? If the answer is no and you just need a quick result, sub-agents are the move. If the answer is yes and the work benefits from collaboration, that's where agent teams come in. Sub-agents are cheaper on tokens and better for focused tasks. Agent teams cost more but they handle complex, multi-part work that would take a single agent significantly longer to get through. When agent teams actually make sense and when they're overkill Agent teams are not a "use this for everything" feature. They add coordination overhead and they burn through tokens significantly faster than a single session. So you want to be intentional about when you spin one up. The sweet spots are tasks where parallel exploration genuinely adds value. Research and review is a great one, where multiple teammates investigate different angles of a problem at the same time and then compare notes. Building new features where each teammate owns a separate module or file is another. Debugging is where it gets really interesting. Instead of one agent going down a single path and potentially wasting time on the wrong theory, you can spin up multiple teammates to test competing hypotheses in parallel. The one that finds the answer first wins, and the others can stop. Cross-layer work is solid too. One teammate on the frontend, one on the backend, one writing tests. Each owns their own piece without stepping on each other. Where agent teams don't make sense is anything sequential. If step two depends on step one being finished first, there's no benefit to parallelizing. Same-file edits are a bad idea because two teammates touching the same file leads to overwrites. And simple tasks where the coordination overhe