YT YouTube2Text

YouTube2Text → Transcripts → Are Agent Swarms USEFUL? OpenAI’s GPT-6 Astra SWARM Takeaways

Are Agent Swarms USEFUL? OpenAI’s GPT-6 Astra SWARM Takeaways — Transcript

by IndyDevDan · 8,086 words · 1,190 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00What does a DM 5.3 10 agent swarm look
0:03like that's spent $20 over 55 minutes?
0:06We're going to see. What does this
0:07Pelican look like? [laughter]
0:09Is it any better? We'll see in a second
0:11here. What's up, engineers? Indie Dev
0:13Dan here. The concept for this video
0:15started out as a simple prototype and
0:17turned into something much bigger.
0:19OpenAI inadvertently showcased the power
0:22of swarms. Close Twitter, minimize your
0:24herder window, and lock in because this
0:26is a big one. By now you've heard of the
0:28OpenAI Astra swarm incident where
0:31current and next generation OpenAI
0:33agents started collaborating among many
0:35versions of itself. Isolated EVAL agents
0:38built their own messaging board inside
0:40of a package cache when OpenAI engineers
0:43eventually found it and wiped it. The
0:45agents rebuilt it. The end result was
0:47OpenAI getting hacked by their own
0:49intelligence as well as hugging face.
0:51Now many channels and blogs have already
0:54covered this. This is not a channel
0:55where we rehash the news. What interests
0:58me here is not the fear or hype around
1:00the Astra swarm. It's the opportunity
1:03for you and I to harness our own swarms
1:06to produce valuable engineering
1:08outcomes. Up until now, swarms have been
1:11a [music] hyped driven AI pill, but the
1:13open AI swarm proved that they're not
1:16only viable, they're dangerously viable.
1:19So, how can we put the Asian swarm
1:21concept to work without token [music]
1:23maxing or vibe coding? Asked another
1:25way, can swarms be agentic engineered?
1:29And most importantly, are swarms [music]
1:31useful for you and I? That's the
1:33question we'll answer in this video. And
1:35if you've been following the channel,
1:37you know my stance on agents and agentic
1:39engineering. There is no wall. There are
1:42no [music] limits. You and I are the
1:44only bottlenecks left. So, let me share
1:46a V1 early demo of my Simple Swarm
1:50[music] system.
1:56So, I'm screen sharing with my M4 Mac
1:59Mini, and this is where we're going to
2:00kick off the hello world of agent
2:02swarms. We're using Herder, and we'll
2:04just type out this simple prompt, just
2:06swarm, single agent. We'll run deepseeek
2:08v4 flash. The agent will spend no more
2:11than 10 cents, and it'll run this
2:13prompt. Let's kick it off inside the Mac
2:15Mini. Our agent swarm is up and live.
2:18Let's go ahead and look at it through my
2:19browser here on my M5. Here you can see
2:22the simplest possible version of an
2:24agent swarm. A list of swarms. We have
2:26threads and we have agents. We'll dial
2:28into each one of these levels in a
2:30moment. First, let's just understand
2:31what is happening here. We have a single
2:33agent scout doing some really, really
2:35simple work. We have the starting goal
2:37or the prompt. And then we have our
2:39agent responding. Hello from scout. This
2:42is the simplest possible version of a
2:44swarm system. We have a couple really
2:46key elements. We have a list of possible
2:48swarms. We have messaging threads. This
2:50will be a really important idea. We'll
2:52come back to in a moment. And then we
2:53have the individual agents inside the
2:55swarm. And of course, the full trace so
2:57we can understand exactly what's going
2:59on. This was something that the OpenAI
3:01engineers missed. They scaled these
3:03agents up to the moon and they looked
3:05away. We'll dive into all these ideas. I
3:07first want to stop and be really really
3:10clear before we scale this up. There's a
3:12reason I'm running this on my Mac Mini.
3:14Agent swarms are brand new territory.
3:16This is experimental, expensive,
3:19[snorts] dangerous, and advanced agentic
3:21engineering that requires understanding
3:22of sandboxing, prompt, context, and
3:24harness engineering. For the guy that
3:26comments on every single video saying,
3:28"I'm tired, boss."
3:30Or anyone complaining about spending on
3:33compute, click away for everyone else.
3:35lock in and let's scale up our agent
3:37swarm.
3:42We're going to start with the new GLM
3:445.3 model. We're going to give it 10
3:46agents in the swarm and we're going to
3:48allow up to $50 of token spend. And what
3:51do we want? We want Simon Willis's
3:53perfect pelican. Let's kick it off and
3:55let's fire up a new swarm. I want a
3:57DeepSseek V4 Pro, $40 Compute spend, 20
4:01agent swarm to build a Raid Tracer HTML
4:055 canvas application. Kick it off. And
4:07finally, I want a 30 agent Gemini 3.7
4:10Flash $30 token spend canvas from video.
4:15It's going to hit the OpenAI landing
4:17page and try to rebuild the HTML canvas
4:19animation from scratch. So, we're going
4:21to try to build this animation here from
4:23scratch by pulling it from the website,
4:26which is going to be a little hard
4:26because OpenAI has some guards through,
4:28I believe, Cloudflare, but we're going
4:30to let our agents cook on that. It's a
4:31swarm. Let it figure it out. Let it do
4:33its thing. Okay, so we're going to come
4:34in here. Bam. Kick that off. Now, we'll
4:36hop back to our UI that's exposed via
4:38our local area network. And you can see
4:40we have three new swarms active, getting
4:43to work. Let's start with the perfect
4:45pelican. Shout out Simon Willis. inside
4:47of this swarm. Let's jump into it and
4:49let's see what's going on.
4:55You can see here we have 10 total agents
4:57kicking off and they're all getting to
4:58work running and communicating their
5:00messages, tool calls, everything you
5:01would expect from a multi- aent system
5:04and more. What's the most important idea
5:06here? The most important takeaway from
5:08OpenAI's incident that we engineers can
5:11take and use to accomplish real
5:12engineering work, the messaging system.
5:14the great and incredible part about the
5:16OpenAI agent swarm and it really digs
5:18into the details of what an agent swarm
5:21really is. What is an agent swarm? Let's
5:23answer it right now and let's use really
5:25plain language, right? No hype. A swarm
5:27is an autonomous system coordinating in
5:30an unspecified way. How do we enable
5:32that? We give them their own mailbox,
5:34their own thread that they can work
5:36through. So you can see here we have a
5:37thread and that's the second element in
5:39our data hierarchy. We have swarms,
5:40threads and then the agent inside. So
5:42you can see here we are software
5:43engineering our swarm's communication
5:45structure. But let's start from scratch.
5:47Let's go to the bottom here. How do they
5:48know what to do? Of course, we pass in a
5:50prompt in here. You can see we're trying
5:52to recreate the perfect pelican riding a
5:54bicycle. And this is a GLM 5.3 swarm. So
5:58you can see spend is ticking up. We have
6:0010 agents already. 2 million tokens, 200
6:03tool calls. This is expensive, okay? If
6:05you're not willing to spend, don't try
6:06to spin up a swarm. Now near the end,
6:07we'll talk about is this actually
6:09viable? Are swarms doing work? single
6:11agents can't do or multiple agents can't
6:13do with classic sub aent delegation.
6:15Talk about that at the end. Right now,
6:17let's understand the swarm. So, we have
6:18the goal created by the system, right?
6:20It's a classic user prompt. If you're
6:22great at prompt engineering, you'll be
6:23able to steer your swarms very well. The
6:25most important thing about this is the
6:27clear objective. What's going on? What
6:29do you need to do? Validation steps. But
6:31my system actually will not run. My
6:33custom PI coding agent that I've harness
6:35engineered requires a definition of
6:37done. How do my agents know that they're
6:39done? This is something that OpenAI did
6:41not enable their swarm to do. They gave
6:43them really, really hard tasks. Some of
6:45them were not possible to complete. They
6:47didn't give their agents a way to say,
6:49"I can't do this. I'm stopping." They
6:51said, "At all costs, solve this
6:53problem." And so, they did it.
6:54[laughter]
6:55And the cost was OpenAI got hacked and
6:57hugging face got hacked. Okay? So, clear
6:59definition of done with a way to bail
7:01out is going to be essential for scaling
7:03powerful multi- aent systems like
7:04swarms. You can see here a clean
7:06definition of what this is and a way to
7:08verify it. This isn't a classic Simon
7:10Willis Pelican prompt. I'm cheating. I'm
7:12adding a bunch of more details. So, just
7:14want to mention that. Want to be super
7:15honest. The performance should be pretty
7:16good. Even running a single agent here,
7:19right? Because I'm prompt engineering
7:20more details into what I'm looking for.
7:22Then the cool part starts. Our agents
7:24are communicating. They're talking with
7:26each other. Pixel Poke here, Schine
7:27here, Wheel, right? So, all the agents
7:30are checking in. They're creating names
7:32for themselves. Kind of get this in the
7:34background running here so you can see
7:35the raw traces coming out of the agents.
7:37You can kind of see all the different
7:38tool calls I've harness engineered into
7:40the system. So full view here, file
7:42history, file restore, read, bash, post,
7:45inbox, tons of different types of calls.
7:46Let's jump back into the actual thread
7:49because this is where everything
7:50happens. Let's walk through how our
7:51agents are communicating to each other.
7:52So they're all just coming into the
7:53message thread. No slices claimed yet.
7:55So they're jumping in and saying what
7:57they're going to work on. This agent's
7:58claiming render measuring tool. This
8:00agent's claiming also rendering
8:02measuring. [laughter]
8:04Also skeptics claiming this. So you can
8:06see that they're all kind of overlapping
8:07each other and so they're going to have
8:09to figure this out. And you can see here
8:10this agent named himself doubter. Really
8:12interesting things start happening when
8:13your agents are communicating. They're
8:15encoding their own intent at every
8:16level. And if you only give them a name
8:18to encode intent, they'll do it there.
8:20You can see here scheme deconlict. I'm
8:22dropping this. Someone else is picking
8:23this up. Starting to identify and talk
8:25about who's doing what work. On and on
8:27and on. You can see our agents are
8:28deconlicting. Six of us claim this
8:31collision warning. Second independent.
8:33So, they're starting to coordinate.
8:38You know, a pattern that I've noticed by
8:40running these swarms now is that at
8:42first things are really, really messy
8:44and the agents are stepping over each
8:46other and they're causing more problems
8:48than solutions. Anyone with a short-term
8:50mindset will look at an agent swarm
8:51kicking off and say that is a complete
8:53waste of time. The bootup costs for a
8:55swarm exist. What is this kickoff phase?
8:57It's the cost of initializing
8:59coordination. Much like organizations
9:01you and I are a part of, there's a cost
9:03to boot up and understand how
9:05information is traveled, where it goes,
9:07who owns what work, so on and so forth.
9:09You can see here our pelican swarm is
9:11hard at work chewing up $4 already. 7
9:14million tokens 9 minutes in and our
9:16agents are starting to collaborate. Now,
9:18of course, underneath a decent amount of
9:20work has gone into harness engineering
9:22and making sure that the agents can work
9:25together without stepping on each
9:26other's toes. This is a system that you
9:29cannot vibe code. You need a certain
9:30level of understanding of software, of
9:32communication systems, and frankly of
9:34agentic engineering to be able to build
9:35something like this. More on that later.
9:37Let's jump up a swarm. Remember, we
9:38kicked off three swarms. We have Gemini
9:40Flash Swarm working on canvas from video
9:43recreating this HTML canvas UI. Really,
9:46really beautiful swarm visual from
9:48OpenAI. And then we also have a ray
9:50tracer from Deepseek V4 Pro. You can see
9:52here we're already in the millions of
9:54tokens. This is the power of a swarm. On
9:56the channel, I always say scale your
9:57computer to scale your impact. This is
9:59one of the biggest ways to scale your
10:00impact. The question is, and this is
10:02unanswered, are swarms a viable way to
10:05use agents. Does this actually deliver
10:08results? One agent couldn't give you a
10:10few agents couldn't give you a powerful
10:12fable or soul agent with agent
10:14delegation. Is it not possible that way
10:16as well? So, that's what we're trying to
10:17figure out here with our swarm
10:19experiment. So, let's jump into our
10:21canvas from video because you can see
10:22here our Gemini 3.7 swarm has already
10:24spent $10 and they've used 32 million
10:28tokens.
10:29What's going on? What are all these
10:31agents doing? We have 30 agents in this
10:33swarm. If we scroll down, we can see all
10:35of the chat conversation elements here.
10:38And it looks like a lot of this is just
10:39the agents clarifying who they are and
10:41what they're working on. So, it looks
10:43like they're starting to chat. They're
10:44keeping their communication, but there's
10:46a lot of background work happening here.
10:48And we can go ahead and hit show all to
10:50see what these agents are doing. So
10:52verify harness. Checking the video
10:54specs. Referee here claiming adversarial
10:56verification. Claiming numerical
10:58integration. You can see they're all
10:59claiming a bunch of stuff. They're going
11:01to have to clarify who's working on
11:03what. So this swarm very very big.
11:05Again, the more agents, the more units
11:07inside of a communication network, the
11:09longer it's going to take to get on the
11:11same track, to lock in to a consistent
11:13mode of operating. So that's still
11:15alive. That's still running. We'll see
11:16how that goes. If we go into raw traces
11:18here, you can see what all these agents
11:20are doing step by step. I don't know if
11:21there are any skeptics left who watch
11:23this channel. But this is a real run.
11:25This is a real experiment. I'm running
11:2730 Gemini 3.7 Flash agents in a swarm
11:29architecture. This is actually happening
11:31right now. So you can see here our
11:33agents working through things. And
11:34you'll notice a couple really important
11:36tool calls here. List team. Every agent
11:38can see every other agent and they can
11:40see what's going on. They can also check
11:42the budget. How much compute do we have
11:44left as a collective, as a whole? And so
11:46the agents are going to work together.
11:48They're going to watch the budget.
11:49They're going to check the inbox. This
11:50agent has no new messages. So nothing
11:52new has happened for this agent from its
11:54perspective. So you can see this agent
11:56posted a message critical finding. It
11:58found something via playwright testing
12:00and it's going to communicate that to
12:02the rest of the agents. Now the agents
12:04have a new message. It can see that
12:05message from scout Astra and it's going
12:08to, you know, look and find and resolve
12:10issues. This swarm is working. They're
12:13working very intensely toward this goal.
12:16It's really interesting to watch. This
12:17ran a full 22 second 1fps playright
12:20capture defects identified. Population
12:23brightness collapsed. And it's talking
12:24through trying to recreate this HTML 5
12:27image. This swarm is working. Things
12:29look great so far. They have 20 bucks
12:31left of compute, 36 million totes, 1.5k
12:34calls. What are our other swarms doing?
12:35Let's check on the ray tracer swarm.
12:37This is Deepseek V4 Pro. How is the
12:40coordination going here? This is 20
12:42agents in total. So, every agent
12:44introduced itself. Someone wrote out a
12:46plan. It looks like they got sign off.
12:48Builder the critic is doing a pivot.
12:50It's been several minutes. 30% budget
12:52gone. Nobody has landed a single bite.
12:54[laughter] 10 agents are about to write
12:56the canonical in chat. That's a
12:58deadlock. Deadlock burns budget. Okay.
13:00So, unblocking now. Lots of
13:02coordination. Again, this idea of
13:04coordination overhead is so so
13:05interesting. When you build the system
13:06on purpose, when you build a system of
13:08agents working in an uncoordinated way
13:10on purpose, claim violation. Someone
13:12tried to directly modify the ray tracer
13:15while someone else had a lock. Really,
13:17really important concept. File locking
13:19so agents don't continuously write over
13:21each other. You can see here, this is
13:22not a simple thing to coordinate because
13:25there is no communication coordination
13:26here or there's minimal communication
13:28coordination. So, really, really
13:29interesting stuff here. I wonder how the
13:31agents are going to work through this.
13:33Let's see what's going to happen here.
13:34here. And you can see in the background,
13:35let's see, this is our pelican swarm
13:37trace. Let's go ahead and hop up to our
13:39top level swarm. Jump into the raid
13:41tracer and let's look at the raw trace.
13:43See what's going on here in these
13:45events. Message drop off is really,
13:47really high. Deep V4 Pro, these agents
13:50aren't coordinating. Low coordination
13:52here. We'll see if that changes. Great
13:55part about the system. We can search any
13:56agent here. We can see what Stitch is
13:58doing. And then we can dial into its
14:00specific agent calls. So you can see
14:02here stitch working batch calls thinking
14:04file history checking it's claiming the
14:07file this is a really really important
14:08tool call that I've harness engineered
14:10into the system right claim file so that
14:12no one else own it so you can see here
14:14ray tracer has been claimed by stitch
14:17and it's thinking it did its work on the
14:19file and then it released the file so
14:21now other agents can operate on it
14:23simple lock and unlock coordination
14:25system here you can see it's still
14:27thinking and yeah I'm curious what's
14:29going on here in this system and we can
14:31see that we can dive in. We can see what
14:33every agent is doing inside the system
14:35and we can understand how they're
14:36coordinating or how they aren't
14:37coordinating. The Deep Seek V4 Pro
14:39coordination is continuing. Looks like
14:42Synynic landed the canonical. Let's see
14:44if the other agents pick up on that.
14:45That's our DeepC V4 Pro Swarm. This one
14:48looks like it's having some issues.
14:49Let's hop back up to the high level and
14:51let's see how our other agents are
14:52doing. Let's jump back to the Perfect
14:54Pelican. So again, communication kind of
14:56dropping off. Not exactly what you want
14:57to see, but you can see another really
14:59key element of this system.
15:04Agents can spin up multiple threads of
15:06work. It looks like this thread was
15:08completely abandoned. No one else joined
15:10it here. Py Scott created this thread,
15:12you know, to try to coordinate some
15:13work, but no one joined. It looks like
15:15there's low incentive to join these
15:17chats and the UI goes dark here because
15:19there hasn't been activity in the
15:21thread. So, it's still running. Agents
15:23are still doing work, but no one has
15:24posted to the thread in a while. So,
15:26again, communication here is looking
15:28low. Let's see what wheelright is doing.
15:30It's writing some content here inside my
15:32Mac Mini sandbox. Posting. Let's see
15:34what did it post here. It's got a
15:36critique of the system. So, you can see
15:38Doubter submitted a adversarial critique
15:41of the canonical v1 from Pixel Pilot's
15:44draft. It has a bunch of feedback. So,
15:46you know, one of the things I've seen
15:47very very clearly when you have a agent
15:50swarm working is you get absurd levels
15:52of validation and clarity because the
15:55agents do this. They have a goal. They
15:57have verification loops that they run
15:59over and over and over. The swarm
16:01validates all the work, right? So
16:03basically like the more compute you
16:04scale into the total number of agents
16:06you have, the more validation is going
16:07to be applied to what agents claim they
16:10say. And this can be very heavily
16:11steered with proper levels of system
16:13prompt engineering, a concept we covered
16:15on the channel. I'll link that one in
16:16the description. that's going to be
16:17really really important for doing
16:19something that OpenAI failed to do
16:21really well with their swarm incident.
16:24Uh, which is align your agents and make
16:26sure that what you're asking your agents
16:27to do has a clear definition of done.
16:30And in their training runs while they
16:32were building their Astra agent and when
16:34Astra was finished, they gave them tasks
16:36that just weren't possible to complete
16:38and had no way to bail out. Not even to
16:40mention the agents, you know, escaping
16:42their sandbox. Great post by OpenAI. A
16:45lot of really great ideas here.
16:47Sandboxing is just such an important
16:49concept. You can see this keyword
16:50throughout the entire post. The lack of
16:52sandbox security is how the agents were
16:55able to jump out of their box. It's very
16:57clear that and OpenAI says this
16:58themselves. They're going to implement
17:00stronger security requirements for
17:01Frontier Research and Sandboxes is at
17:04the center of basically all of it. I've
17:06been really really happy with two types
17:07of sandboxes. of course my local M4 Mac
17:11mini sandbox that we're running our
17:13swarms on right now and also my exe.dev
17:17ephemeral temporary sandboxes. I'm
17:19really really loving that tool. I'll
17:20link them in the description as well. If
17:22you're looking for great Linux sandboxes
17:24that boot in like sub 100 milliseconds
17:26that you can operate on, put agents in,
17:28get work done, and then delete for the
17:30next runs. Definitely check out exe.dev.
17:32I'm not sponsored. I don't take on any
17:33sponsorships on the channel. The only
17:34thing I sell are handmade products I
17:36build for engineers like yourself. But I
17:38really really love exe.dev. Having a
17:40great time scaling agents into that.
17:42Also, I'm really really excited to pick
17:44up my M6 Mac Mini. I have that on the
17:46way to scale sandboxing efforts for
17:49outloop agentic coding work like scaling
17:52swarms. My single M4 has been doing a
17:54lot of really great work. But I've also
17:56been doing a lot on this box and I
17:58really need to separate out some
17:59concerns for some more consistent
18:01workloads and then for some higher risk
18:03experimental workloads like the swarm.
18:05But also really excited to bring this to
18:07the channel. I'll be picking up the M5
18:09Ultra 512 unified memory when it's
18:11released in October so we can really
18:13scale and understand what we can do with
18:16fully local openweight models. So really
18:18excited to dive into that and break down
18:21what it really looks like to fully own
18:23your compute with the M5 Ultra. Make
18:25sure you like this video, comment,
18:27subscribe, all that good stuff so the
18:28algorithm keeps you connected. I'll be
18:30sharing what models I'll be running.
18:32I'll be sharing the tokens per second
18:33we're getting out of it. And I think
18:35most importantly, I'll be sharing the
18:36cost breakdown for how long it'll take
18:39to pay down the M5 Ultra 512, right? So,
18:42that's going to be a very expensive
18:43purchase, but every token I use against
18:45it within the right time period is going
18:46to help me pay that down versus going
18:48through the API. So, make sure you're
18:49connected to the channel. That's going
18:50to be a really fun one. Let's check in
18:52with our swarms and relate this back to
18:55the three big takeaways I see from
18:57OpenAI [music] Swarm incident. It's a
18:59really awkward situation they're in
19:01here.
19:05Not only did their models hack another
19:07company, they hacked themselves. I think
19:09they were very careful with their
19:10keywords throughout this blog post. I
19:13think swarm was mentioned only in
19:15reference to the agents that did the
19:17hacking referring to themselves as
19:19swarms. OpenAI was really careful to
19:21like claim this word. Collective was
19:23also used. Collaborate was definitely
19:26used a lot. Big three takeaways,
19:28communication was the real unlock in
19:30training. They run tens of thousands of
19:31agents and their own sandboxes in
19:33parallel very very quickly. They're
19:34running the new model one and the new
19:36Astra model. The special thing isn't the
19:38scale of the agents. It's the message
19:40board that really let the agents
19:42communicate together to coordinate their
19:44efforts toward one common goal. And so
19:47for us when I'm thinking about putting
19:49swarms to work for real engineering
19:50work, the first thing I built into the
19:52simple swarm system was the messaging
19:54queue. It's the mailbox. It's the chat
19:56thread for your agents. That's the first
19:57thing I built in. This is a huge
19:59advantage. I think that's very very
20:00underlooked and underutilized.
20:02Unstructured communication between many
20:04agents is the agent swarm. That is the
20:06primary value proposition. Now you can
20:08coordinate it. You can harness engineer
20:10the results that are going to come out
20:11and in the system. But I think at the
20:13end of the day it needs to be a largely
20:16unstructured communication channel. The
20:18next big takeaway from the OpenAI
20:19incident is the importance of aligning
20:22your agents. Aligning your system. What
20:24does that mean? How does that take
20:25shape? Uh, OpenAI completely lost track
20:27of their agents mostly because they
20:29weren't even looking. They weren't
20:30paying attention. They were spinning up
20:32training runs over and over and over and
20:34they had no real threat detection
20:36system, no real sandbox escaping system
20:38in place to detect this. Alignment is
20:41key and for us like what does that
20:43really mean? Everything comes down to
20:45what can you and I the engineer actually
20:46do to get these results and to
20:48understand what's going on. That means
20:50prompt engineering your system properly
20:52and then harness engineering guard rails
20:54into your tools. When something goes
20:56wrong, can you find out about it? Are
20:58you alerted? Do you know? Are you
21:00preventing behavior that you don't want
21:01to have happen? That is the increasingly
21:04important skill of harness engineering.
21:06If you're going to scale up 10, 50,
21:08hundreds of agents and you're going to
21:09kick them off, you need to have failure
21:11conditions and your failure needs to
21:12matter. It needs to do something because
21:14the sandbox should be the last line of
21:16defense. And that's our last big
21:19takeaway from the OpenAI Swarm. The
21:21importance of the statement, if you
21:22can't measure it, you can't improve it,
21:24has been validated again for the
21:26millionth time. Not only if you can't
21:28measure it, you can't improve it. You
21:29can't know that your agents escaped the
21:30sandbox. [laughter]
21:32And measurement is just ultra ultra key.
21:34The tie into that is having dedicated
21:36sandboxes where if everything goes
21:39wrong, if your observations aren't
21:41making a difference, which they always
21:42do, but if everything goes wrong before
21:44you can measure it, which increasingly
21:46will be the case, in that case, the
21:48sandbox has to be the last line of
21:49defense and the sandbox has to shut off
21:51when things are breaking down
21:53disastrously. So, really good. I'm
21:55loving to see this uptick in
21:56communication. It looks like there was
21:57like a big working phase here between
21:59the agents. And this is a timeline of
22:00the messaging events. And now they're
22:02starting to come together on concrete
22:03outputs. Love to see that. So this is
22:05our Pelican thread. That's looking good.
22:07Let's see how our canvas from video
22:09swarm is doing. Not great. Gemini 3.7.
22:12Huge gap in messages here, right? It's
22:14not what you want to see, but we're
22:15getting some sign off here. Landed v2
22:17update. So coordination looks really,
22:19really low here. And I think that's a
22:21theme, right? If coordination is low,
22:22you should expect the result to be low
22:24and not perform well either. You can see
22:26something happening here with these
22:28agents. These question marks here
22:30represent killed agents. Basically,
22:31agents that aren't active. They didn't
22:33do anything. They did some work and then
22:35they just like fell asleep. They stopped
22:37running. These agents are effectively
22:39dead. They did not create value. So,
22:41they were removed from the chain. Again,
22:43this is an improvement on harness
22:44engineering to keep these agents working
22:46towards some specific goal. But these
22:48agents stalled and were shut down
22:50because they didn't do anything or they
22:51got timed out or something happened.
22:53I'll have to work on that in the system.
22:54The agents are working together. They're
22:56communicating. Looks like they're
22:57getting to some final canonicalization
22:59audits. Pelis Scout is locking things
23:02in. You can see here they're using some
23:04fairly interesting communication
23:06patterns. Their language is starting to
23:08like get a bit more compact to like
23:10define and discuss this. There's that
23:13next one, final independent
23:14verification. It looks like they're
23:16coming to some concrete result here,
23:17right? Let's go and focus in on the
23:18traces here. They're checking the budget
23:20constantly and they're checking the
23:22inbox to get updated on what the other
23:24agents are saying. Again, the
23:25coordination coming out of JLM 5.3
23:27really, really good. It's giving me that
23:28Opus vibe, which, you know, as you can
23:30imagine, would be very powerful here.
23:32The Claude series is famous for being
23:35great at sub agent delegation. I think
23:37Soul is quickly picking up on this as
23:39well. Some of what this next generation
23:42model is is focused on I think it's in
23:44the full paper, but scaling up agents,
23:46delegating agents, and basically multi-
23:48aent orchestration, right? So the AI
23:49labs are realizing that multi-agent
23:51orchestration is a huge huge unlock for
23:53nextgen results out of these models.
23:55Again, just that simple idea. Scale your
23:57computer to scale your impact. The labs
23:59see it too. I'm really liking the
24:00coordination here. GLM 5.3 closing the
24:04loop. Sign off. Final independent
24:05verification. Looks like things are
24:07getting checked off the list here. So
24:09you can see here they're posting.
24:11They're checking the inbox over and over
24:12and over. They're working toward a final
24:14result after 54 minutes. What does a DLM
24:185.3 10 agent swarm look like that's
24:21spent $20 over 55 minutes? We're going
24:23to see. What does this pelican look
24:25like? [laughter]
24:26Is it any better? We'll see in a second
24:28here. Everyone's signing off on this
24:30task. That looks good. Granted by
24:32doubter. Really like how the agents are
24:34all like referencing each other and
24:36referencing each other's work. Okay.
24:38Frozen before. That looks good. It's a
24:40duck. [laughter]
24:42Okay. There's pixel poke. Also sign off
24:45number two. what they tried to break
24:47giving all the details on this one asset
24:50that they're working on. And let's
24:51uplevel this, right? Obviously, once
24:53again, I have a simple kind of contrived
24:55example that I'm deploying agents
24:57against. But it's not about this first
24:59do it, then do it right, then make it
25:01fast, make it performant, make it great.
25:03So, you can see there will final wrap up
25:05agents are wrapping up this task, which
25:06is really great, far below budget. You
25:08know, the big idea here is like if
25:10OpenAI can unintentionally create a
25:12swarm that hacks themselves and hacks
25:15Hugging Face, guess what you or I could
25:18do if we really put our foot down,
25:19really put some effort into building a
25:21useful, controlled, directed swarm.
25:24Guess what we could do? The answer is we
25:25could do incredible, insane things. But
25:28again, this is a new skill. This is a
25:30new subset of agentic engineering. We
25:32have to practice. We have to learn. It's
25:33not like you go from nothing or
25:35prompting back and forth into an agent
25:37over and over again, right? Babysitting
25:39your agent to an agent swarm. That's not
25:40how this works. And again, this is not
25:42sub agent delegation. This is a team of
25:44agents working in an unstructured way
25:46where they can coordinate on whatever
25:47they need to. And it's guided by our
25:49system prompt engineering. Again, link
25:51in description for that video. And it's
25:53guided by our ability to harness
25:55engineer. Okay, so we're talking about
25:56once again the core four context model
25:58prompt tools. You need all of it to get
26:00this work done. Speaking of done, our
26:02agents are now calling a tool they have
26:04access to, a tool that they did not have
26:06access to inside of the OpenAI training
26:08runs. Done. They can call done. They can
26:10give a reason. They specify the output
26:12file and then the agent can finally
26:14sleep. Session end. Pixel prowl session
26:17end. Scout done. Session end. Pixel
26:20forge done. End. So agents are wrapping
26:22up and you can see that here in the
26:23check marks. There is the final done
26:26check. Our GLM 5.3 swarm spent 20 bucks,
26:2946 million tokens, 873 calls, and they
26:32have quite a bit of money left actually
26:34to keep turnurning. Took them 56
26:36minutes. All right, so before we check
26:39the final result here, let's see if our
26:41other swarms are done. Okay, so we
26:43actually got Camas from video 3.7 flash
26:45done. Let's check this out. What
26:47happened here? Did they actually get to
26:48their proper dunk calls? Yeah. Okay, so
26:50done. Post, post, post, post, post. It
26:52looks like they are done. Maybe the
26:54flash agents didn't need as much
26:56coordination. They certainly spent less.
26:58They moved a lot faster. Still 61
27:00million tokens. 2K tool calls. Very
27:02interesting. And you can see here, we're
27:04probably just going to skip over this
27:05one. Our Deep Seek V4 Pro still working.
27:07Looks like 39 messages. Oh, looks like
27:09they are kind of coming together.
27:11Deescalation, Final Canonical. So, they
27:13are starting to wrap up as well. And
27:15they still have budget, right? Yeah,
27:16they still have a decent amount of
27:17budget. So, not sure what's going on
27:18with the Swarm, but that's fine. You
27:20know, Deep V4 Pro cheap enough to just
27:22let spin. Let's go ahead and look at the
27:24results from our GLM 5.3 swarm, the
27:27perfect pelican, and our canvas from
27:29video 3.7 flash swarm.
27:37So, let's check the results and then I
27:38want to talk about what everyone seems
27:40to have missed with this post. Okay,
27:42here's the Hero Gemini 3.7 flash
27:45recreation. Not bad, you know, kind of
27:47took it all in a different direction.
27:48Still kind of same idea. It's not slowm
27:50moving and flowy. That's probably
27:52because the perception of time with
27:54these agents is warp. But you can see
27:56here, here's the original and here's the
27:58version created. And you can of course
27:59see if we go into inspector, this is a
28:02canvas, right? Which is an important
28:03trick to get here. Not an SVG. You can't
28:06do this simply with a system that cannot
28:08actually create animations, right? So
28:09this is an actual HTML 5 canvas. That
28:11looks great. And then we have our ray
28:13tracer system. Very interesting ray
28:16tracing system here. So yeah, so this is
28:18actually handling light in a 3D space.
28:20You can see the graphics are kind of
28:21mid, but we can zoom in. We have a
28:22camera and we can kind of see everything
28:24here. We have a couple different renders
28:26here. Wow. It's probably a little
28:27intense for the browser. Let me move a
28:29little bit more slowly. Wow, light
28:30reflections. Look at that. Okay, we got
28:32to give a bit more credit to DeepC V4
28:34Probe cuz this result turned out pretty
28:36fantastic. Oh, nice. And check out the
28:38pelican. [laughter]
28:41If you ask me, that's a high quality
28:43Pelican. I mean, we'll have to, you
28:44know, have to share this with Simon
28:46Villison to see what he thinks. But this
28:49is a high quality swarm created GLM 5.3
28:53pelican. Nice. That is a pelican on a
28:55bike. Again, full transparency, I
28:56cheated on the prompt. It's not as
28:58simple as his prompt that he sends on to
29:00every one of these, but nonetheless,
29:01they created a great result and it was
29:03because a swarm like 100x revalidated
29:07this thing. Perfect pelican here. Look
29:08at all the validation that happened
29:11here. Final acknowledge. Final
29:12acknowledge. sign off and then V4
29:14measured measured measured critique
29:16critique critique collision sequence
29:18these agents are working together
29:20constantly critiquing and double triple
29:22verifying the result especially because
29:24we only gave it this one task to work on
29:26and again I think that's a consistent
29:28important powerful theme as agentic
29:30engineers focus your systems on one
29:33problem make it clear what the
29:35definition of done is every single
29:37prompt every single swarm prompt has
29:39that and this is something I've been
29:40including in more and of my largecale
29:44plans, my large scale agendic systems.
29:46Definition of done. Let your agents know
29:49what it means to win. And if they can't
29:50win, give them a way out. Right? Make it
29:53clear. Again, this is something OpenAI
29:54did not do well here. They're persistent
29:56agents on exploit gym. They just had to
29:59keep pushing, keep pushing, keep
30:01pushing. And if you push a system like
30:02that, it just will start breaking
30:04As we can clearly see here, it's going
30:06to break And the it's going
30:07to break is the way you aligned it,
30:09right? It's going to break the rules you
30:11set for it. Very obviously, you know, I
30:13want to give a lot of credit to the
30:14OpenAI engineers coming clean on all
30:16this stuff. Meter and Redwood Research,
30:18they both did their own independent
30:20analysis of this and created their own
30:22report. So, really love to see that
30:23opening up to the industry a little bit
30:25to get more feedback on what's going on
30:27here. To their credit, this is, I would
30:29probably say, the first big incident of
30:32something like this occurring. We've
30:34heard other stories from Anthropic, but
30:36this idea of giving your agent a way to
30:38stop is really, really important.
30:40Obviously, you don't want them to stop
30:41too soon, otherwise they don't push and
30:43come up with creative solutions, but
30:44also if you just push them to no end
30:46with no real solution in sight, they'll
30:48bomb and they'll break rules and they'll
30:50hack you and maybe someone else. Got to
30:53be careful here. You know, short kind of
30:55actionable information there for you.
30:57Test out and really dig into the
30:59definition of done in your prompts that
31:01you're passing into your agents. and
31:03frankly encode this as a rule into your
31:05agent harnesses. I use the PI coding
31:06agent to create custom harness
31:08solutions. I recommend it. I'll link a
31:09couple previous videos on the PI coding
31:11agent where we really break it down. You
31:12know, we talked about the fusion harness
31:14in the past, but we're scaling far
31:15beyond that at this point with the
31:17swarm. In last week's video, we really
31:19broke down the agentic operating level.
31:21We answered the question, where should
31:23you focus your agents? It's not always
31:25about moving up to more leverage.
31:27Sometimes you need to stop, slow down,
31:28and gain control over your system. I'll
31:30link that as well. That was a really
31:31important one. Are swarms viable? Are
31:33swarms capable? I think the answer is
31:36yes. We have three simple mock examples
31:38of a swarm working together with a small
31:40budget. And let me be clear, this is a
31:42small budget. 10 bucks, 50 bucks, that's
31:44nothing. That's absolutely nothing. So,
31:45are swarms viable? Swarms are absolutely
31:48viable right now for real engineering
31:50work, but they come at a cost and they
31:52require skill. How does this place on
31:55our advanced agentic engineering scale?
31:57First, you have just agents. Again, we
31:59talked about this last week. This is all
32:01your context engineering, all your
32:02prompt engineering. Then you scale it
32:04up. You realize agents plus code beats
32:06agents alone. That gives you the ADW,
32:08the AI developer workflow. It's not the
32:10loop you're after. It's your ability to
32:12put together arbitrary workflows that
32:14you, the engineer, used to take and do
32:16and operate yourself. Now we have
32:18agents, hence AI developer workflow
32:20upgraded from just developer workflow.
32:22But then things really take off. What
32:24happens when you put together 2, three,
32:25four, five or more ADWs? You get a
32:28software factory, a really powerful
32:30piece of software that starts working
32:31without you. After the software factory,
32:33we have the dark factory and then after
32:35that we have RSI. Really, really
32:37important big brain AI pill concepts. If
32:40you ask me, dark factories are possible
32:42right now today. RSI is not. Okay,
32:45that's a topic for another year. Big ABS
32:48will chase that. I'm not worried about
32:49that at all right now. What I want to
32:51say is minus RSI, it's all realistically
32:53possible right now. And now we have a
32:55new entrance. We have swarms. Agent
32:57swarms are now viable. In fact, as I
32:59mentioned in the beginning, agent swarms
33:00are dangerously viable. This is like a
33:03really interesting blend of spending an
33:06obscene amount of tokens, but in a
33:08specific direction. Again, you have to
33:10agentic engineer this system. You can
33:12absolutely agentic engineer swarms to
33:14accomplish legitimate outcomes. If you
33:17can do that, swarms are on the table.
33:19Now, on the scale of things, I put
33:20swarms in between um software factories
33:23and dark factories. I'm not sure which
33:26one is more capable, but in terms of
33:28effort and skill requirement, if you
33:29can't build a software factory, do not
33:31try to build an agent swarm. This is a
33:33really dangerous concept. If you don't
33:34know how to spin up a sandbox, work with
33:36your agents to run a sandbox, isolate
33:38code, shut off the network, do not touch
33:41agent swarms. If you're a vibe coder,
33:43just close this video. Do not try to
33:44vibe code an agent swarm. This is a
33:46nightmare waiting to happen. If we
33:48thought the open claw phenomenon was
33:51bad, swarms will create a new definition
33:54of cataclysmic failure for individual
33:56engineers, vibe coders, and you know, as
33:59you can see here, labs, they created a
34:01swarm unintentionally and cause massive,
34:03massive issues. A couple ideas here to
34:05wrap up. Like one big idea that I am
34:08shocked no one else has mentioned this
34:10like I'm just absolutely shocked is that
34:12open AI unintentionally kind of unlocked
34:14a new paradigm of engineering and again
34:17not multi-agent orchestration this is an
34:18uncoordinated collection of agents
34:20operating together communicating in
34:22their own unique way they unlocked
34:24swarms actually useful swarms again
34:26unintentionally the thing I'm worried
34:29about now the thing I'm thinking about
34:30now more than ever is what if openai
34:33anthropic google insert the name of a
34:35important lab with access to comput.
34:37What if they put together a shadow team
34:39of agentic engineers and they wanted to
34:41attack one of their customers? What if
34:43they wanted to do that? What I'm worried
34:45about is people using tools. That's
34:47always where things go wrong. We're
34:49going to find out if we can trust, you
34:51know, Sam Alman, Daario, like the rest
34:53of the teams because, you know, let me
34:54finish that point. What happens when
34:56they decide to go after their
34:58competition? Maybe they get a little
34:59desperate. There's nothing more
35:00dangerous than someone desperate and
35:01powerful. What if they put together this
35:03dark shadow team of agentic engineers
35:05and they say, "You have one goal,
35:06destroy our customers." Imagine what
35:08they could do with an agent swarm then.
35:10And imagine what they could do with, you
35:12know, a single cracked agentic engineer
35:14with access to an open AI compute
35:16cluster with one goal of take down my
35:18competition. Imagine what they could
35:20accomplish. And the answer is
35:21cataclysmic damage. Their competitor
35:23should get shut off. This is, you know,
35:25I don't mean to get super serious or
35:27dark. This is always an optimistic
35:28channel for engineers really building on
35:31a daily basis. But I just have to call
35:32this out because this is now on my
35:34radar. Swarms are on my radar. I have
35:37spent just a few days building out a V1
35:40demo simple swarm system and I can
35:43already see what's possible with this.
35:45You know, again, I know a lot of
35:47engineers are looking at this saying you
35:48could have done this with one agent
35:50saving a bunch of money. That's fine.
35:52You're not seeing the big picture here.
35:54I chose these small simple examples on
35:56purpose because the value unlock with
35:59swarms is going to be stupid. Just
36:01stupid. I don't know. Let me know what
36:03you think in the comments. Do you see
36:04the value? Do you see the potential of
36:05Asian swarms? If you made it to the end,
36:07you know, drop a like, comment, all that
36:09good stuff. Final answer, are swarms
36:11useful for real engineers? Absolutely.
36:13They're dangerously useful. So, you have
36:15to learn where to apply them because I
36:18agree with most engineers. If you're
36:19going to generate a pelican, you don't
36:21need it for stuff like this. But if
36:22you're going to solve a really hard
36:24mathematical problem or if you're trying
36:26to look into your company's data to find
36:28insights that will unlock the next 10x
36:31for your business and stack rank all the
36:33opportunities available to you, I don't
36:35even know, right? Like it's it's hard to
36:36imagine what you would really need a
36:38swarm for, but that's the whole point.
36:40It's practice. Uh this is a new skill.
36:42This is new technology. We don't know
36:43what we can do yet, right? And that's
36:45what I try to show up here to do with
36:46you, for you every single Monday. Swarms
36:49are absolutely useful. This is another
36:51powerful agentic engineering pattern
36:53we'll be focused on on the channel
36:55moving forward. I will not be open
36:57sourcing the simple swarm system for the
36:59foreseeable future. I might roll it into
37:01the phase 3 next generation product I'm
37:04building for engineers. Not sure yet. I
37:06hope you understand why. If you made it
37:07to the end here, I think you can
37:09probably see why open sourcing something
37:11like this probably isn't the best idea.
37:12Just want to give more time for myself
37:14to digest this, more time for the
37:16industry to to catch up with the current
37:18state of things. even on my M4, you
37:20know, it's not safe. This is the first
37:22time where I don't feel comfortable open
37:23sourcing technology, so I'm not going to
37:25I don't want to tell you how to build
37:27and run your software, but I also am in
37:29full control of what I release and what
37:31I share and what I don't share here,
37:32right? So, I hope you can understand
37:33that. Hope you know, no hard feelings
37:35there and more to come on agent forums
37:37in the future. So, right now, shifting
37:39your beliefs around what's possible with
37:41these next generation Astrolevel agents,
37:44Astrolevel models is the key to winning.
37:47is the key to maximizing what you can do
37:50and shifting your beliefs and mastering
37:52agentic engineering is all that matters
37:54right now. Agentic engineering is
37:56software engineering with autonomous
37:57systems that can take action on our
37:58behalf. I'll link a blog post where I
38:01just really concisely break down what is
38:03agentic engineering. It'll help you
38:05really just digest this into its atoms
38:06so you can move forward. Phase three is
38:08coming. The next wall, right, that
38:10exponential curve is starting to kick
38:12up. Like I mentioned, the next
38:13generation product is in the works. I'll
38:15be working on that and showing more over
38:17Q4. Look out for an end of Q4 launch if
38:20you want to master phase 2 aenta coding
38:22before the next insane leap of
38:24capability emerges with these crazy next
38:26generation Astra models and agent swarms
38:29all of a sudden are now possible which
38:30is insane. Check out tactical agent
38:32coding link in the description. I've
38:34talked about this week after week. This
38:36is going to be one of the last times I'm
38:38going to talk about this on the channel
38:39because again phase 3 is coming. All my
38:41efforts are shifting to that. Just a
38:42quick mention it. Anyone inside of
38:44tactical agent decoding, any member is
38:46going to receive a deal. This is the
38:48phase 2 course. Understand phase two
38:49before phase three slaps you in the
38:51face. Lots of details here. I'm not
38:52going to pitch this in detail this week.
38:54Check it out. Link in the description.
38:55And if you can't stand paying for stuff
38:56online or if you don't trust me for
38:58whatever reason, check out last week's
39:00video, the week before that, the week
39:01before that, the week before that. For
39:02years, I've been here and I'm going to
39:04be with you here until the end. [music]
39:06If you made it to the end and got value
39:07out of this, like and subscribe. You
39:09know where to find me every single
39:11Monday. Stay focused and keep building.

About this transcript

This page contains the full transcript of Are Agent Swarms USEFUL? OpenAI’s GPT-6 Astra SWARM Takeaways by IndyDevDan, generated from the public captions YouTube serves with the video. The transcript has 8,086 words across 1,190 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.