ClawTeam Explained: Multi-Agent Swarms for OpenClaw and Claude Code
Prefer to watch? Watch on YouTube · Subscribe for new builds · Read the transcript
In this video I break down ClawTeam, a GitHub repo that lets AI agents form teams, split up the work, and talk to each other while they build. If you run OpenClaw, Claude Code, or any other CLI agent and want to know where multi-agent setups are going, this one's for you. I recorded this in March 2026, when the repo had passed 2,600 stars in its first week. Tools like this change fast, so check the current docs in the repo before you set anything up.
What I cover in this video
- 0:00: What ClawTeam is and why it made me stop scrolling
- 1:30: How the swarm works, with a leader agent and specialized sub-agents
- 3:01: How it differs from other multi-agent frameworks
- 5:19: AutoResearch: 2,000+ experiments with no human stepping in
- 6:04: Full-stack development and investment analysis use cases
- 7:34: Reusable team templates in TOML files
- 8:20: How this connects to my own OpenClaw agent crew
- 9:05: How I'd use it as a solo founder building an MVP
How the ClawTeam swarm works
ClawTeam came out of a university data science lab in Hong Kong, so it's built by researchers, not thrown together at a weekend hackathon. It lets any CLI agent, whether that's Claude Code, Codex, OpenClaw, or Cursor, work as part of a team instead of just running next to other agents.
It starts with a leader agent, which works like a project manager. You give the leader a goal, something like "build me a full stack app with authentication and a dashboard." The leader then:
- Spawns specialized sub-agents, each with its own Git worktree, its own tmux window, and its own identity
- Plans the task allocation: what has to happen first, what depends on what, and who gets which piece
- Runs work in parallel. One agent might build the auth module while another sets up the database schema and a third builds the front-end components
The agents talk through an inbox system. They check their inboxes, update their task status, and report results back to the leader. The leader tracks progress, spots bottlenecks, and can move work around. If one agent gets stuck, the leader can hand that task to someone else or spawn a new agent to help.
You can watch all of it live, either in a tiled tmux window that shows every agent at once or in a web dashboard on localhost. I spent way too long watching their demo video.
Why it's different from other multi-agent frameworks
With most multi-agent frameworks, you, the human, write the orchestration code. You define the workflow, write YAML configs, and set up Docker containers, Redis, and message brokers. That's a lot of infrastructure, and for many people it's a deal-breaker. You wanted AI to do the work, not hand you more of it.
ClawTeam turns that around because the agents themselves use it. You pip install it, give your leader agent a prompt, and that's the setup. The infrastructure is just a file system plus tmux. There's no Redis, no message queue, and no database. The agents coordinate through CLI commands that get auto-injected into their prompts.
I also like the isolation model. Instead of containers or virtual environments, each agent works in a Git worktree, so every agent is on a real branch with real diffs. When an agent finishes, you can see exactly what it changed, then review it and merge it. Agents don't step on each other's code, so you avoid the merge conflicts that cause trouble in other multi-agent coding setups.
The use cases they showed
AutoResearch
This one builds on Andrej Karpathy's autoresearch project. In their demo, a leader agent ran eight specialized research agents across eight H100 GPUs. The system ran over 2,000 experiments on its own and improved their validation score by 6.4% with zero human intervention. The agents came up with hypotheses, ran experiments, analyzed the results, and iterated. That's months of manual hyperparameter tuning squeezed into about 30 GPU hours.
Full-stack development
This is the one I think matters most for builders. You give the leader a prompt or a project spec, it breaks the project into components, and agents build the front end, back end, database, and tests at the same time while coordinating so the pieces fit together. To be straight with you, I haven't tested this myself. The architecture makes sense, though, especially the worktree isolation.
Investment analysis
They also showed a multi-strategy portfolio optimization setup covering market research, risk assessment, and algorithmic trading execution. I'm not going to tell you it's printing money like some posts on X do. It shows how flexible the framework is, but the real results remain to be seen.
Team templates
You can define custom team configurations in TOML files, like a content production studio, a scientific research team, or a business operations team. You save the setup once and reuse it whenever you want to spin up that team.
How this fits my OpenClaw setup, and how I'd use it
I run my own crew of AI agents on OpenClaw, named after the Wu-Tang Clan. RZA runs the content pipeline, Inspectah Deck handles X, Ghostface does intel, Method Man does clips, and GZA does security. They work well, but they mostly work alone. Each one does its job on a schedule, and they don't collaborate in real time the way ClawTeam agents do. There's already an OpenClaw fork of ClawTeam, so it could plug into what I'm building. Am I switching my whole setup tomorrow? No. My agents are dialed in and working. But this is the direction things are heading.
Say you're a solo founder who wants an MVP. You'd install ClawTeam with pip, set up your preferred agent (say Claude Code), and tell the leader something like:
I need a SaaS app with user auth, a dashboard that shows my analytics, a billing integration with Stripe, and an admin panel.
The leader would split that into tasks, spawn four or five sub-agents, and have each one build in its own worktree. At the end, you'd have branches to review and merge. It probably won't be perfect on the first run. You'll still need to review the code and test it. If you're new to building apps with AI, that review step stays non-negotiable.
The easiest way to start is to grab the repo link, give it to your agent, and ask: "How would this help me? Will it make our current system better? Why or why not?"
Key takeaways
- ClawTeam (HKUDS/ClawTeam) is open source, MIT licensed, and works with any CLI agent, including Claude Code, Codex, OpenClaw, and Cursor.
- A leader agent plans the work and spawns sub-agents, and they all coordinate through an inbox system.
- There's no Redis, Docker, or message queue to set up. It runs on a file system plus tmux, and each agent gets its own Git worktree.
- The AutoResearch demo ran over 2,000 experiments on its own. I haven't tested the full-stack use case myself.
- Agents are moving from working solo to working as teams, and that's worth paying attention to even if you don't switch today.
FAQ
What is ClawTeam?
ClawTeam is an open-source, MIT-licensed GitHub repo from HKUDS that lets CLI agents work together as a team. A leader agent breaks a goal into tasks and spawns sub-agents that work in parallel and talk to each other through an inbox system.
Does ClawTeam work with OpenClaw and Claude Code?
Yes. It's designed for any CLI agent, including Claude Code, Codex, OpenClaw, and Cursor. There's also already an OpenClaw fork of the project.
Does ClawTeam need Docker or Redis?
No. The infrastructure is a file system plus tmux, with no Redis, message queues, or database. Each agent gets its own Git worktree instead of a container.
How do I watch ClawTeam agents work?
You can watch every agent at once in a tiled tmux window, or open a web dashboard on localhost to follow their progress in real time.
Chapters
Transcript
Read the full transcript
0:00This GitHub repository got over 2,600 stars in just 1 week, and if you're running Open Claw, you need to hear this. This is one of the coolest GitHub repos I've seen in a long time, and I'm not exaggerating when I say this, it actually made me stop scrolling on X and actually read the tweet. So, there's this repo called Claw Team, and it's going crazy viral right now, and what it does is kind of wild. It lets AI agents form swarms, like actual teams of AI agents that organize themselves, they divide up the work, and they talk to each other in real time, and they actually get stuff done. One command, and that's it. You give it a goal, and the agents figure it out all by themselves. I'll put the link to it down below, by the way, you can check it out
0:45for yourself. Now, I know what you're thinking, you know, we've heard of the multi-agent thing before, this isn't new. Every week, there's some new framework promising to revolutionize everything, but this one is a bit different, and I want to explain why. Claw Team came out of the HKUST Data Science Lab, which is in the Hong Kong University of Data Science, and these are actual researchers building real tools, not just some weekend side project that someone threw together in a hackathon. And what they actually built is basically a way for any CLI agent, whether that's Claude Code, Codex, Open Claw, Cursor, whatever your tool you're using, to work as a team, basically, not just side by side. And they're actually coordinating, sharing insights, and
1:30converging on these solutions together. So, here's how it actually works. You have a leader agent, think of it like a project manager. You give the leader a goal, something like build me a full stack app with authentication and a dashboard. The leader then spawns specialized sub-agents, each one gets its own Git work tree, its own TMUX window, and its own identity. So, they're all working in an isolated environment, but they can communicate through an inbox system, which I think is pretty dang amazing. The leader designs the task allocation, it figures out what it needs to happen first, and what depends on what, and it assigns work accordingly to the task at hand. So, one agent might be working on the off module, while another is setting up the database schema, while a third is building the front-end components, all
2:16at the same time, in parallel, all coordinated. The part that really got me is, you know, the agents check their inboxes, and they all communicate with each other. You know, they update their task status, they report results back to the main coordination agent, and then the leader monitors everything, it tracks the progress, it identifies the bottlenecks, and can reallocate resources dynamically. So, if one agent is stuck, the leader can reassign that task, or spawn a new agent to help out. You can even watch all this happening in real time. They have a tiled TMUX window where you can see every agent working simultaneously, or you can open a web dashboard on localhost and watch it from there, which is pretty freaking cool. It's like having a window into a hive mind, you
3:01know, I I've spent way too long just watching the demo video they posted, and honestly, it's crazy. Now, I'm going to compare this to what other most multi-agent frameworks look like, because this is important that we know the difference. Most multi-agent frameworks require you, the human, to write the orchestration code. You're defining the workflow, essentially, you're writing the YAML configs, you're setting up Docker containers, Redis queries, message brokers. It's infrastructure-heavy, and honestly, a lot of people, that's a deal-breaker right there. That's intimidating. You wanted AI to do the work, not create more work for you. Claw Team flips that completely. The agents themselves use it. You just pip install it and give your leader an agent a prompt, and that's the setup. The infrastructure is
3:47literally a file system in TMUX. No Redis, no messaging queues, no database required. The agent coordinates everything through the CLI commands, and they get auto-injected into their prompts. And the isolation model is really smart. Instead of containers or virtual environments, they use Git work trees. So, each agent is working on a real branch with real diffs. When they're done, you can actually see what an agent changed, and then merge it or review it if required. It's practical, and it makes sense for how developers actually work. Real quick, before we keep going, if you're watching this and you want to actually build with some of these tools, not just watch videos about them, then you're going to want to check out our community down below, Shipping School. We have a full Claude Code course, a full Open Claw course, and
4:34four live bootcamps every single week, where we actually help you get set up from scratch. Like, actually set this thing up, not just watch a tutorial and figure it out by yourself. And we also provide one-on-one coaching, so you could book a call with me, we could share screens, and I can help you get Claude Code or Open Claw running on your machine. That's it, no fluff. I built this community because watching YouTube's only gets you so far. We launched it just 3 days ago, and we have over 55 members. You need people around you who are actually building, people who hold you accountable, and coaches who can help you when you get stuck. I'll put the link in the description down below. Get in now before the price goes up. Now, I'm going to talk about some of these use cases they showed, because this is where it gets more
5:19interesting. The first one is auto research. This is based on Andrej Karpathy's auto research project. So, you know Karpathy, the guy who used to run AI at Tesla. The idea is that you point Claw Team at a machine learning problem, and it spawns a team of research agents across multiple GPUs. In their demo, they had a leader agent orchestrating eight specialized research agents across eight H100 GPUs. The system is designed over 2,000 experiments autonomously, and it improved their validation score by 6.4% without any human intervention. Zero. The agents were generating hypotheses, running experiments, analyzing results, iterating, all on their own. So, if you think about what that means for a second, that's months of manual
6:04hyperparameter tuning compressed into about 30 GPU hours. Labs and research teams spend weeks doing what this thing just did overnight. The second use case is full-stack development, and this is the one that I think matters most for builders like you and me. You give the leader agent a prompt a prompt or a project spec, and it breaks it down into components. It assigns agents to each piece, and they build the whole thing in parallel. So, you got the front-end agent working on the back-end, database, and testing, all happening at once, simultaneously, with agents coordinating to make sure everything integrates properly. I want to be honest and straight-up with you. I haven't tested this myself, but the architecture makes sense, and the fact that each agent
6:49works in its own Git work tree means you're not dealing with merge conflicts from other agents stepping on each other's code, and that's a real problem with other multi-agent coding setups, and they solved it elegantly. The third use case is the investment analysis. They showed a multi-strategy portfolio optimization. This setup where the agent goes and they're doing automated market research, risk assessment, and even algorithmic trading execution. Now, I don't know how well this actually works in practice, and I'm not going to sit here and tell you it's printing money, like most of the posts on X. The architecture is interesting, and it shows the flexibility of the framework, but still, the actual results remain to be seen. And there's the template system that they have. You know, you could
7:34define a custom team configurations in the TOML files. You could set up a content production studio team, a scientific research team, a business operations team, whatever you need, and then reuse that configuration every time you want to spin up that team. You save it once, use it forever. Here's why this matters to me personally. I run my own agent crew on Open Claw. We got the whole Wu-Tang Clan handling all the database and back-end operations. RZA handling the content pipeline, Inspectah Deck handling all the things that regard X. We got Ghostface doing the intel work, we got Method Man doing the clips, we got GZA doing security, and they all work great for what they do, but with their they're mainly all independent. Each one does its thing on a schedule, they don't really collaborate in real time the way the Claw Team agents do.
8:20Claw Team is showing what the next level of this evolution looks like, agents that actually work together, that share contacts, that adapt on the fly. And the fact that it already has an Open Claw fork means someone is already integrating this with their exact framework we use. So, this could potentially plug right into what I'm already building. Now, am I going to go and switch my whole setup to Claw Team tomorrow? No, probably not. My agents are already dialed in, and they're doing their jobs, and you know what, it's working. But this is the direction things are heading. And if you're building with AI agents right now, you need to be at least be aware of what's coming. The other thing I want to point out is the star count, like over 2,600 stars in 1 week, it's pretty good. That doesn't happen by accident. The
9:05developer community is clearly excited about this, and when you look at what's trending on GitHub in the AI space right now, it's all about multi-agent coordination. The solo agent era is still alive and well, but the swarm era is just getting started. I want to walk you through practically what I would do, and what I would actually, you know, use this if I was using it day-to-day. You know, say you're a solo founder, and you want to build an MVP, let's say. You'd install Claw Team with a pip, set up your preferred agent, let's say Claude Code, then you'd tell the leader agent something like I need a SaaS app with user auth, a dashboard that shows my analytics, a billing integration with Stripe, and an admin panel. The leader would break that into task, spawn four or five sub-agents, assign each one of
9:51those agents a piece of work, and they'd all start building their own Git work trees. And as they finish, they basically report back. The leader would coordinate with the integration, and at the end you'd have branches you could review and merge. Now, is it going to be perfect on the first run? Most likely not. Welcome to building with AI. You're still going to need to review the code. You're still going to need to test things. You know, nobody one-shots a million-dollar app without making mistakes, right? But the fact that this is even possible right now is pretty insane. So, if you think about where we were a year ago, and we were excited about AI writing a single function, now we're talking about teams of AI agents building entire applications together in parallel. That is honestly what excites me about the space the most and about being in this space and how it's
10:37evolving. The progress isn't linear. It's exponential at this point. And if you're paying attention to building with some of these tools, you're positioning yourself to ride the wave instead of getting hit by it. So, I think that the big takeaway here is the speed of progress in the AI agent space and how it's accelerating. Every week there's something new that makes the previous week breakthrough look crazy incremental. Claw team is one of those moments where you can see the trajectory clearly. We're going from solo agents to agent teams, and then agent swarms, and eventually those swarms are going to be able to tackle problems that no single agent, no human team could even handle efficiently. If you want to check out, I put a link down below or search Claw team on GitHub. It's under the HKUDS/Claw
11:22team. It's open source. It's MIT licensed. It works with a lot of the IDEs you use, Claude code, Codex, Open Law, whatever. Any CLI agent you prefer. The documentation is solid, and they've got a demo showing you the whole thing in action. It's worth watching. So, for those of you in the community inside of Shipping School, I'll be doing a deeper walk-through of this and putting it in the resources tab for us. Everything that I talk about in these videos always goes into the resource tab and how it could help you potentially get going with your open call setup. I think that there's some real potential here for people who are building products with AI agents. If you want to join us in the community, I'll put the link down below. We've got over 115 builders in there right now shipping real products with AI. People building SaaS apps, automating their businesses, leading to
12:08work with other AI tools from scratch. It's a great community, and I'd love to have you there. We do live build sessions six days a week, so there's always something going on. So, yeah. Claw team, agent swarm intelligence, 2,600 stars in a week. One command to full automation. The future of multi-agent coordination in AI is looking pretty crazy right now. I You should check it out. It's linked below. Just take a look at it. Grab the link of the GitHub repo, give it to your agent right now and say, "How would this help me? Will it make our current system better? Why or why not?" And it'll be honest with you. Give it the feedback, and maybe it will help you. I want to keep making these videos, keeping you up to date on what's going on with GitHub, all these cool AI releases. And if you like AI news just like this, we release about four to six videos every single day. I highly recommend you subscribe
12:54and hit the notification bell so you get notified when the next video drops. Otherwise, have a blessed Sunday, and we'll see you in about an hour. Bye-bye.
Ready to start building with AI?
Join the Shipping Skool community free. Paid members get live bootcamp calls every week and weekly-updated courses.
Join Shipping SkoolKeep reading
Claude Code Agent Teams: The Observer Pattern for Multi-Agent Coding
The observer pattern adds one read-only agent to your Claude Code team. It watches every parallel worker through file changes, status files, and logs, then writes a shared summary of what's done, what's in progress, and what's conflicting. Nobody has to dig through each agent's work to figure out where things stand.
Paperclip AI Agent Orchestration: Run Your Agents Like a Company
Paperclip is an open-source, self-hosted Node.js platform that runs your AI agents as a company, with org charts, per-agent budgets, goal tracking, governance, and a dashboard. It works with OpenClaw, Claude Code, Codex, and Cursor, and you install it with npx paperclipai onboard --yes.
Claude Code Review Explained: Multi-Agent Bug Hunting for Pull Requests
Claude Code Review is Anthropic's multi-agent code reviewer. Specialized agents scan a pull request in parallel for security, performance, logic, and style issues, then a coordinator agent ranks what they found by severity and leaves a summary comment plus inline notes. When I recorded this, it was only on Claude Team and Enterprise.
