I managed to unlock a crazy new hidden feature in Claude Code called Swarms. You're not talking to an AI coder anymore. You're talking to a team lead. The lead doesn't write code - it plans, delegates, and synthesizes. When you approve a plan, it enters a new "delegation... mode" and spawns a team of specialists who: - Share a task board with dependencies - Work in parallel as teammates - Message each other to coordinate work Workers do the heavy lifting, coordinate amongst themselves, then report back.show more

I packaged up an unlocked build of claude code so everyone can try it out

Update: it made the front page of HN but got pulled down my mods

Update: it’s back up on the main page 🤷‍♂️

This is very similar to codex new orchestration mode actually. Very interesting to see them both coming out with us at the same exact time

Are codex subagents async yet? Claude code is event driven. Most harnesses are lagging here atm

Yes they are. Gotta enable it in /experimental I wrote about them here! Thanks for the video, great work!

Awesome. I need to get back to playing with codex then. The lack of async subagents kept me from using it as main driver.

Yeah I totally get it. They're not quite as polished as Claude yet but we're heading in the right direction and the model is extremely smart. Enjoy and I followed you I'm looking forward to hearing more from you.

Yes likewise!

great tool to burn all your tokens

Takes up less tokens to break up work across subagents

@rizzytoday Wrong.

@rizzytoday nah

First off, you didn't "unlock/find" Swarm Mode.. it was never HIDDEN lol.. I was running parallel sub-agents, full swarm setups with delegation, coordination boards, the whole thing, way before they dropped the official sub-agent update in summer 2025. So spare me the "revolutionary" act. Second, the token burn is obvious to anyone who's actually pushed these systems hard. Every single sub-agent turn is a fresh reasoning chain.. new prompt, new generation, new tokens. Then you got the lead agent delegating tasks (tokens), sub-agents reporting back (tokens), merging results (tokens), resolving conflicts (tokens), and all the context you gotta duplicate or summarize across agents so they don't work blind (more tokens). That's not theory, that's straight math: one complex task in a single thread might take X tokens end-to-end, but split it across 4-8 sub-agents with coordination loops and you're easily at 3-5x the burn, minimum. I know this because I live it.. my weekly limits vanish in a day or two when I'm swarming heavy projects, versus stretching a week+ on single-threaded runs. Same tasks, dramatically different token spend. Yeah, the builds come out cleaner and faster because the work gets properly parallelized and specialized. Nobody's denying the engineering efficiency. But token efficiency? Night and day worse. So when you hit me with that weak "nah," it just shows you haven't actually stress-tested this stuff at scale. Come back when you've burned through a few limits yourself instead of theorizing from the sidelines. Basic stuff, man.

@rizzytoday yeah nah

Yea I’m right.. If you can’t explain it just say it.. making a thread like you discovered something that’s been baked into the CLI before u even started using it.. is tool behavior. The FACTS.. For non-trivial tasks, total token spend routinely hits 3–5x (or higher) vs. a well-prompted single agent that iterates in one long thread. This isn't just theory; it's the consistent complaint across similar frameworks where heavy users hit rate limits way faster despite cleaner outputs.

@rizzytoday nah

It’s funny, always the feature I’m missing the most and spend hours tinkering on my own with the existing tools, end up being part of the “core” CC within weeks. Wonder which of hundreds of persistient memory systems will emerge victorious.

Delivering slop faster than ever!

You can try dedicated skills for this in

Swarms coded

You schizos are yearning for an AI built in your schizo image

Ive been doing this manually

"you're not talking to an ai coder. you're talking to a team lead." this is the shift nobody saw coming. junior devs just got promoted.

We have this mode called --auto-mode --unrestricted on Autohand Code CLI

Does something exist in opencode @thdxr?

@thdxr It really requires async subagents. There’s a couple of issues on GitHub discussing it and a plugin (I contributed to) that prototypes it.

@thdxr

@thdxr

@thdxr Thanks for sharing Mike, I'll check it out!

@thdxr No sweat

Yes ser! That’s exactly how it works. Try adding trading logic system

the problem with this is you only have anthropic's models. everyone will do swarms better.

We are so ready for this

What kind of magic did you do to activate this? Maybe there's a hidden config that can turn it on, no? Did you go at the assembly or hex level do pull this off, lol?

nah the cli is just minified js - I just had to look through it and find the function that does the feature flag check (and patch it so it always returns true)

beautiful work, thanks

You’re welcome

swarms 👀

What has become your bottleneck now with this workflow? How do you find context switching between tasks? I’ve done something similar and the most painful part is now having so much more that needs my attention and decision making.

This “team lead + specialists” pattern is where agents start to feel real. The thing that determines whether it’s useful or chaos: • shared state (task board + artifacts) • budgets per worker (tokens/time/tools) • good synthesis + conflict resolution • provenance (who changed what, and why) Parallelism without traceability becomes un-debuggable fast.

so basically antigravity

Many people, including myself, have been using claude code like this since the subagent feature was released. I continue to strengthen the system with every new feature that comes along.

It reminds me of a watered down version of Gas Town, which is the best article I've read this year: by Steve Yegge But I've played around now with a few of these multi-agent systems and I keep on hitting the same bottleneck. The real complexity isn't in communication channels between agents, it's the lack of an efficient communication channel between the *human* and subagents. Currently, you can't visualize nor have any control at all really over the orchestration in real time. You feed it the plan, and accept or reject what comes out the other end. If you make a spec/plan that already has everything spelled out, this works great. The problem is, software engineering doesn't work like this. You need to adapt your plans as you learn more about the problem you are solving, as you realise that the abstraction can't easily be extended because it's coupled with 3 other services that would break. So what does the swarm do? Well it sticks to the plan! Turning your codebase architecture into playdoh. It will probably work the first time. Instead when an agent runs into this obstacle, we need it to be able to pause and bubble this information back up to you. The new Claude feature can auto-spawn subagents in tmux terminal panes which is a great step in this direction, but it can only take you so far before you have an unmanageable chaos of terminal panes. For this to work you are going to have agents blocking other agents, dependencies forming, plans getting reassigned... the best way to see what's happening is probably a graph. So I've been building my response to this, a spatial IDE for recursive multi-agent orchestration, These swarm features are cool, communication channels will help, but when it inevitably breaks, I need to be able to zoom into a subagent to figure out what's going wrong. I can't just repeat the whole workflow with a small prompt tweak only for it to fail again. I think we need graph structures to break through this scalability ceiling.

Not sure how this is any different to ‘agents’. You can literally just say ‘complete task with many agents’ and it spools up many coordinated agents.

Progression of the SWE role over the last few months. 1. Yay I got a new tool 2. Yay now I am the team lead 3. Yay now I am the dept manager 4. Yay now what am I????

You’re not x. You’re y. Y doesnt z - it a, b and cs. Anyway cool feature! I had fun having claude reverse engineer the claude binary and i learned a lot about the feature … even some special tags to includes in which supersedes other tags

Claude swarm mode isn't one coder anymore. It's a team lead that delegates to specialist workers who coordinate amongst themselves. This mirrors real engineering teams. The gap between managing AI teams and writing code yourself is 10x productivity. You found the cheat code.

You still can't trust AI agents, yet. Even with proper and config files and so on, it will constantly lie, gaslight, invent, hallucinate.

the team lead framing is exactly right. delegation is the unlock. most people still treat AI like a calculator when its actually a junior dev who can spawn more junior devs

This is exactly what Im going to try next week in work to solve working on 100's of micro-services, to see if it can crack working on a requirement and coding it a brown field way.

damn, this could build whole companies with enough compute

Will this make Jersey Mike’s cheaper?

@alberduris your worst fever dream is coming true

I have been creating this from scratch using open source models for a couple months now! It’s crazy how all of these platforms converged to the same solutions. New research is definitely underway which will mitigate a lot of these hacks that have been made to make this possible.

Did you reverse-ralph Claude Code?