Subagents vs Agent Teams? 🧠Hermes Bots, Goal Loops & Kanban Graphs — Transcript
Full transcript
- 0:00That's just a really powerful way for
- 0:01you to significantly reduce the cost.
- 0:04There we go. It just dropped from 45,000
- 0:06tokens down to 18,000. One agent can
- 0:08already delegate to sub agents. So, what
- 0:10does making an agent team actually add?
- 0:12This is the question I get asked most
- 0:14often about multi- aent workflows. Why
- 0:16build a team if one capable agent can
- 0:18actually get the job done? And honestly,
- 0:20sometimes you shouldn't. One powerful
- 0:22agent with sub agents can often be
- 0:24enough. But other times, a more complex
- 0:26workflow can improve the quality and the
- 0:28efficiency. Hi, my name is Callum, also
- 0:30known as Waterloots, and welcome to
- 0:31today's video on agents, loops, and
- 0:33graphs. When are multi-agent teams worth
- 0:35it? This process also works with agents
- 0:37outside of Hermes as well. In today's
- 0:39video, we'll explore the different
- 0:40levels of agentic workflows. One agent
- 0:42with temporary helpers, aka sub agents,
- 0:44goal loops that check whether the work
- 0:46is actually done, adding specialists
- 0:48with their own tools, skills, and
- 0:49memories, aka bot mode, and then conbon,
- 0:52a way to manage complex agentic tasks.
- 0:54Along the way, we'll check what does
- 0:56each level actually need and when does
- 0:58it make sense for a specific task to add
- 1:00more agents or tooling, including a test
- 1:02at the end where I give the same task to
- 1:04each level and see how it does. Now,
- 1:06let's take a look at agents, graphs, and
- 1:08loops.
- 1:10So, there are three separate questions
- 1:11that we're going to ask here. Who does
- 1:13the work? How do they check it? And what
- 1:15do they do next? So, today I want to go
- 1:17through an example scenario that applies
- 1:18to almost every type of task working
- 1:20with an agent. If information comes in,
- 1:23what actions should I take? How should I
- 1:25take them? And what does done look like
- 1:27for that particular task? For example,
- 1:29an email comes in or I take notes on a
- 1:31new article and I want to add it to my
- 1:33LLM wiki. How does the agent process
- 1:35that information in a consistent
- 1:37repeatable way so that it actually meets
- 1:39the satisfaction that I want for that
- 1:41particular task? But first, before we
- 1:42get into automations, triggers, task
- 1:44graphs, and conbon, let's start with
- 1:46just a single agent to see how it works
- 1:47and orchestrates with sub aents. will
- 1:49build up in complexity until we get to a
- 1:51full graph system that lets you
- 1:52orchestrate your tasks. If you find this
- 1:54video helpful, please like, hype, and
- 1:56subscribe as I really appreciate your
- 1:57support a lot. If you're looking for
- 1:59more ways to support me, please consider
- 2:00joining my YouTube or Patreon
- 2:01memberships. Members get access to
- 2:03insights, tips, and kits for agentic and
- 2:05knowledge workflows. I've also put
- 2:07together a free article that I'll link
- 2:08in the top comment that goes through
- 2:10agents, loops, and graphs in a little
- 2:11bit more detail for beginners as a
- 2:13guide. I'll also include the results of
- 2:15the test that I ran so you can go
- 2:16through it in a little bit more depth
- 2:17and hopefully see how this can help you
- 2:19improve the quality of your own
- 2:20workflow.
- 2:25All right, so the first example that
- 2:26we're going to go through is using a
- 2:28single agent here, which you're probably
- 2:30already familiar with. This would be
- 2:32just any type of chatbot, but we're
- 2:33going to give this agent the ability to
- 2:36have sub agents. So, we can see in the
- 2:37bottom left here, we have this option
- 2:39for open agents. And we can see that
- 2:41right now at the moment we have no live
- 2:43sub agents. So when we're working with
- 2:44this first example of a single
- 2:46specialized agent, we can think of this
- 2:47as a parent agent that has the ability
- 2:50to create multiple sub aents or children
- 2:53agents. So if we go over to capabilities
- 2:55on the left here and go over to tools,
- 2:57we can search for delegation. And we can
- 2:59see that right now task delegation is
- 3:01turned off. So I'm going to enable this
- 3:03tool right here. And this will enable
- 3:05the parent agent to create a series of
- 3:08sub aents with specific capabilities. So
- 3:10let's get this started.
- 3:12It's going to be able to delegate to
- 3:14solve our particular problem, which is
- 3:16how do I turn incoming information into
- 3:18something useful, an action I can take
- 3:20or knowledge I can reuse, and what is
- 3:22the best strategy for that action
- 3:24system? Does it make sense to use a
- 3:26single agent with delegation
- 3:27capabilities or a multi- aent team with
- 3:29different specialized agents? And the
- 3:31idea here is that if we can have one
- 3:33capable agent that's able to meet my
- 3:35standards, that's a complete solution on
- 3:37its own. So right now we can see that
- 3:39the agent was able to create all of
- 3:41these sub aents that are now running in
- 3:42parallel. We have three of them. We can
- 3:44see on the bottom here that we have
- 3:45three different workers active at the
- 3:47moment. And what's cool, this is a new
- 3:49update. If we click on the three sub
- 3:51aents here and click on a specific
- 3:52agent, we're able to give instructions
- 3:54to this sub agent and steer it. So I
- 3:56could get feedback saying, make sure to
- 3:59please include citations. And I would be
- 4:02able to now steer this agent. And that
- 4:05just sent off specific instructions to
- 4:07this particular agent that's looking at
- 4:09concrete endto-end workflows for inbox
- 4:12information. And I could do that for
- 4:13each of the different sub agents. And
- 4:14now we can see, for example, this
- 4:16particular agent, the one that I just
- 4:18steered, is now using the research
- 4:20grounded citations skill. So I was able
- 4:22to give some instruction to the agent as
- 4:25it's running to help control the
- 4:26direction that it's going in. You can
- 4:28click on it here and you can go and see
- 4:30how it's thinking. Oh, we just saw this
- 4:31one finish right now. Now we have two
- 4:33agents instead of three. And we can see
- 4:35that one has completed right here and
- 4:36the other two are running. So now the
- 4:38main agent, the parent agent is waiting
- 4:41for the sub agents to complete its work.
- 4:43And then it'll synthesize a concrete
- 4:44recommendation when they return. Okay,
- 4:46here we go. Looks like all three of
- 4:47those just finished. So now the main
- 4:49agent has gone through and it validated
- 4:50a few of the sources and now it is
- 4:52creating a report right here. Okay, so
- 4:54this gave what looks like a pretty
- 4:56comprehensive answer. We can see if I
- 4:57scroll all the way to the bottom,
- 4:58there's a lot of information here. So
- 5:00I'd have to go through that a little bit
- 5:01more in depth. And what's nice is if we
- 5:02take a look at the bottom here, this
- 5:04only used up 36,000 tokens. And the
- 5:06reason for that is because the parent
- 5:08agent delegated to sub agents and only
- 5:11had to give definitions for them to go
- 5:13off and run. So the sub agents
- 5:14themselves then used up their own amount
- 5:16of context. And that's one of the major
- 5:18benefits of using a delegation system
- 5:20like this is I didn't have to have this
- 5:23main parent agent blow through its
- 5:24context window. Instead, it could
- 5:26delegate to sub aents of lower
- 5:28intelligence and then take the
- 5:29synthesized reports rather than reading
- 5:31all of the pages itself. So, the overall
- 5:33idea here is that we're delegating the
- 5:35work but not the judgment. And just to
- 5:36see how this compares, I'm going to give
- 5:38the same prompt asking it to do research
- 5:40but do not delegate to sub agent.
- 5:43So, the approach where I just used a
- 5:44single agent and told it not to delegate
- 5:46to sub agents. We can see that used
- 5:48102,000 tokens whereas the one that
- 5:50delegated to sub agents only used 37,000
- 5:53tokens. So keep in mind this is not
- 5:55taking into account the sub agent token
- 5:57usage. So the overall tokens was larger.
- 6:00There was more context used. But that
- 6:02context that made it back into the main
- 6:04higher intelligence agent was
- 6:06significantly compressed relative to the
- 6:08agent that just did it all itself and
- 6:10had 102,000. If I ran this turn one more
- 6:12time, I might have to compress the
- 6:14context here and then you lose some
- 6:15quality. So that's the first comparison,
- 6:17just using a single agent versus using a
- 6:19single agent with multiple sub aents. So
- 6:21the biggest difference is that one uses
- 6:23up a lot more context. But this was also
- 6:25a very basic example and the results of
- 6:27both of these are basically the same.
- 6:29Build an accountable action steward with
- 6:31delegation capabilities, not a standing
- 6:33team of specialized agents. A permanent
- 6:35multi-agent team adds coordination,
- 6:36cost, latency, and evaluation problems
- 6:38before it has proved its value.
- 6:40Multi-agent designs work well when the
- 6:42task is genuinely decomposable and
- 6:44parallel. And this is a very similar
- 6:45answer to what we got with the
- 6:47delegation system. Do not begin with a
- 6:49peer team of autonomous agents. Delegate
- 6:52bounded readonly work to specialists
- 6:53when that work is genuinely independent.
- 6:55So both of our researchers found
- 6:57effectively the same thing that we
- 6:58should only delegate specialist work
- 7:00when it actually makes sense to do so
- 7:02when the complexity needs it. But all of
- 7:04this is relative. This is specifically
- 7:05for a one-off research task that we just
- 7:08did here. As the system starts to scale
- 7:09in complexity, we need to start thinking
- 7:11about other ways of orchestrating. For
- 7:13example, using all the different bots
- 7:15like we've set up in previous videos.
- 7:17And one thing I want to mention too is
- 7:18that when we're delegating to sub
- 7:20agents, sub agents know nothing. They
- 7:22start with completely fresh
- 7:23conversations. So they have zero
- 7:25knowledge of the parents conversation
- 7:26history, tool calls, or anything
- 7:28discussed before they were created for
- 7:30the delegation. The sub agents only
- 7:32context comes from the goal and the
- 7:33context field that the parent agent
- 7:35populates when it calls delegate task.
- 7:37Delegate task is this tool that we
- 7:39enabled at the beginning here. And the
- 7:40context is how much information goes
- 7:42into all of this. But before we get into
- 7:44an actual situation where it makes sense
- 7:46to have multi- aent workflows, there's
- 7:48one more thing I want to quickly talk
- 7:49about, which is a way that we can
- 7:51enhance the quality of the output of the
- 7:54single agent, whether it's a parent
- 7:55agent with delegated sub aents or
- 7:57all-in-one. And that actually brings me
- 8:00back to the warning of the sub aent
- 8:02system, which is that the context comes
- 8:04from the goal. So what is a goal?
- 8:10So to bring up goal, we can type in
- 8:12slash and goal. And this brings up the
- 8:14goal command, which is a way that we can
- 8:16set a standing goal that Hermes works
- 8:18across all turns until it's achieved.
- 8:20And basically what that means is before
- 8:22we get into the complexity of setting up
- 8:24all of these specialist agents and
- 8:25figuring out how to coordinate them,
- 8:27there's one more step that you should
- 8:28try first, which is to enable a goal. A
- 8:30goal effectively allows you to link
- 8:32multiple prompts together into a bigger
- 8:34picture, a broader task than just one
- 8:37specific research task. For example,
- 8:39instead of managing every step, I hand
- 8:41over a bounded outcome. What success
- 8:43means, how to verify it, and when to ask
- 8:45me. The main agent acts as a judge that
- 8:47checks the progress, and the session can
- 8:49continue within its own budget. And the
- 8:51goal isn't endless research. The
- 8:53evidence matters. So before we get into
- 8:55setting up a complex system to see if we
- 8:58can get more out of our agent, we can
- 9:00try using this goal command. So let's
- 9:01give our multi- aent a goal here.
- 9:05So we can see by using / goal, I now
- 9:08have turned this goal active. I've added
- 9:10a little bit more detail than just
- 9:12saying, hey, can you go research this
- 9:13thing? I've said specifically, I want
- 9:15different streams of information. Please
- 9:17use delegated sub aents of lower
- 9:19intelligence to do the research. So each
- 9:21one of these should be using at least a
- 9:23terra medium instead of terra high. I'll
- 9:25talk about model routing in a moment.
- 9:26But then I've also said please prepare a
- 9:28synthesized report and then once you are
- 9:31done that corroborate the report against
- 9:32practical workflows from community best
- 9:34practices in Hermes. You also must make
- 9:37sure the report is less than 500 words
- 9:38and has clear citations. We can see that
- 9:40the sub agents are all running right
- 9:41now. So what I've effectively done here
- 9:43is I've told the agent what done looks
- 9:46like. So it's taken all of these
- 9:48criteria and it will just keep running.
- 9:50We can see turn one of 20. The default
- 9:52limit is 20 turns. The agent is able to
- 9:54loop itself 20 times, checking to make
- 9:57sure that the information and the
- 9:58research and the output meet the quality
- 10:01standard that I've requested. So, this
- 10:02is a really great way for you to
- 10:04increase the quality of your work
- 10:05without necessarily introducing a lot of
- 10:07complexity. I honestly use this all the
- 10:09time, especially for coding. So, I can
- 10:11also add criteria on here. For example,
- 10:13we must have at least five peer-reviewed
- 10:16sources. And I can add that information
- 10:18to the criteria as the agent continues
- 10:21running. And that now becomes a new
- 10:23definition of what done looks like. So
- 10:25we can see here it took my criteria into
- 10:28account because now the criteria is we
- 10:30must have at least five peer-reviewed
- 10:31sources. And if we look here, it only
- 10:33produced eight sources and it doesn't
- 10:35look like they're peer- reviewviewed. So
- 10:36now the agent has started up its next
- 10:38task on turn two and turn three and it's
- 10:41delegated to another series of sub aents
- 10:43to now cross-reference the output
- 10:45against peer-reviewed academic sources.
- 10:48So it says it's now added an independent
- 10:50organizational coordination and team
- 10:51cognition literature to the evidence set
- 10:53and it's awaiting the peer review before
- 10:55it will work again. As this is working,
- 10:57I can think of more criteria and I can
- 10:58add this here and the agent will just
- 11:00keep looping. The more specific you are
- 11:02on what done looks like at the
- 11:04beginning, what the actual goal is, the
- 11:06better this process will work. Depending
- 11:07on the type of task, depending on the
- 11:09type of budget you have, depending on
- 11:10your goals, you're going to have
- 11:12different ways of doing this. So, it's
- 11:13worth experimenting to see what actually
- 11:16makes the most sense for your particular
- 11:17situation. So, it's kind of a handsoff
- 11:19method of operating. If you've
- 11:21established a good enough goal at the
- 11:23beginning, the agent can run on its own.
- 11:24In some systems, I've had my coding
- 11:26agents run for five or six hours
- 11:28straight, working on a coding system,
- 11:30delegating to lower intelligence sub
- 11:32aents, and it keeps automatically
- 11:34testing the code to make sure it works
- 11:36before it presents it back to me for
- 11:37approval. And that brings me to an
- 11:39important point because if you're
- 11:41running a goal here and it runs for
- 11:42hours and you have this set to Astra for
- 11:45example or to Fable or whatever your
- 11:47Frontier model is, it's possible that a
- 11:49goal could just completely blow through
- 11:51your quota in a very short period of
- 11:53time, especially if you're not sitting
- 11:55there monitoring it. So this brings me
- 11:56to an important question on who should
- 11:58actually be doing the work here.
- 12:01So what we can see is the sub agents
- 12:03here. It just says GPT 5.6 Terra. So I
- 12:06can't actually see at the moment if it
- 12:07is medium or lower. So as part of the
- 12:09goal here, I could have specified rather
- 12:11than just please use delegated sub aents
- 12:13of lower intelligence. I could have said
- 12:15please use a local model or please use
- 12:18Luna only for the research and then you
- 12:20as the higher intelligence model can
- 12:22synthesize it. So this is where you can
- 12:24start being more specific with your
- 12:25prompting and specific with your
- 12:27orchestrating through a single agent
- 12:29delegating to lower intelligence sub
- 12:31agents to significantly preserve your
- 12:32quota. makes a massive difference
- 12:34because keeping an agent working isn't
- 12:36the same thing as using its
- 12:38intelligence. Well, I want the
- 12:39orchestrator agent, the main agent to
- 12:42make the judgments, not to carry every
- 12:44source detail or do every little action
- 12:46itself. So, we can use these lightweight
- 12:48helpers for bounded extractions with
- 12:51limited actions. And what I mean by that
- 12:53is we can be specific about what type of
- 12:55model is used in which type of
- 12:57situation. So, this can apply to the
- 12:58original goal that I just gave here. I
- 13:00can be specific like I mentioned of what
- 13:02type of model I want to be used. I can
- 13:04bring in the agents.mmd file where for
- 13:07this particular profile this particular
- 13:09bot or Hermes agent I can specify inside
- 13:12of the agents.mmd or inside of for
- 13:14example the soul.MD I can say when using
- 13:18sub agent delegation always use lower
- 13:21intelligence models. By including it
- 13:23here, it means that every single time
- 13:25this particular bot, this particular
- 13:27agent wants to run a task that involves
- 13:30some sub aent delegation, it will always
- 13:32know to use lower intelligence models.
- 13:34And I can go even a step further by
- 13:36going under settings and model and I can
- 13:38choose the auxiliary model for different
- 13:40types of tasks where for example maybe
- 13:42for image analysis I don't want to use
- 13:44my main model. I can change this and use
- 13:46a local model or I could use a cheaper
- 13:48model. So you can go in and you can
- 13:50start limiting the specific actions to
- 13:52specific models to help conserve the
- 13:54quota and intelligence of the main agent
- 13:57for when it actually needs it.
- 14:00And honestly, this did a really good
- 14:01job. It was able to specifically limit
- 14:03the report to just a couple hundred
- 14:05words instead of the original thousands
- 14:07and thousands of words it gave me off of
- 14:09the first one. So it wasn't just about
- 14:11adding that limitation at the beginning.
- 14:12It was framing the goal that I wanted it
- 14:15to go in a particular order for cross
- 14:17referencing and corroborating the report
- 14:19and then make sure that it was 500
- 14:21words. But honestly, this example here
- 14:23is kind of disconnected from my actual
- 14:26workflow. This might be the generic best
- 14:29answer of when delegation beats a
- 14:31specialist team where we want to have an
- 14:32orchestration and delegation for a
- 14:35single evolving state, sequential or
- 14:37predictable work. And in contrast, you
- 14:38might want a multi- aent team for
- 14:40breadth first research, different types
- 14:42of due diligence, pipelines with
- 14:44different specialist identities. So this
- 14:46all makes sense, but everything I've
- 14:47just said here is not very specific to
- 14:49me. It doesn't know who I am or what I
- 14:51want. And that brings me back to Hermes
- 14:54corroboration where delegate task brings
- 14:56up a fresh context fork join primitive
- 14:59whose children return summaries. So, it
- 15:01fits bounded research, review, and
- 15:03repair work, but it doesn't necessarily
- 15:05make sense for other types of situations
- 15:07that require more specialization and
- 15:10more context and more knowledge because
- 15:12like I mentioned, sub agents have zero
- 15:14knowledge from the parents conversation
- 15:15history. They only have what comes from
- 15:17the goal and the context that the parent
- 15:19gives them. But what if we start getting
- 15:21into more specific context or more
- 15:23custom situations that involve other
- 15:25types of context outside of what the
- 15:27parent even knows? We can see here the
- 15:28decision test that the answer says is
- 15:30add a specialist if it is independent
- 15:32needs different context tools and policy
- 15:34and beats the single agent baseline on
- 15:36quality coverage latency and total
- 15:38review cost. So in other words the
- 15:40answer is that we should add specialists
- 15:42if we want it to keep its own working
- 15:44knowledge and have access to different
- 15:45context tools and policies perhaps have
- 15:48a different memory system rather than
- 15:50being spawned as a brand new agent every
- 15:52single time. And I note that the Hermes
- 15:54corroboration here mentions Kambban or
- 15:56Conbon depending on how you want to
- 15:58pronounce it. But before we get into
- 15:59conbon, I thought that we could take a
- 16:01quick look at Hermes bot mode actually
- 16:03sets you up for success when you start
- 16:05using conbon because it helps you
- 16:07prepare the specialist profiles. Like we
- 16:09can see down here I have orchestrator,
- 16:11researcher, and librarian. So let's take
- 16:12a quick look at bot mode.
- 16:18So now we can go from a single agent
- 16:20operating in a loop with delegated sub
- 16:22aents to a graph. That's where profiles
- 16:24come in. Okay. So this is bot mode. So
- 16:26we can see here a bot is just a profile.
- 16:29It's the same list of profiles that I
- 16:30have along the bottom here. A bot or a
- 16:33profile can retain its own skills,
- 16:35memory, and working context with a model
- 16:37suited to its role. Each of these
- 16:39different bots here can have a default
- 16:41model that's different. For example,
- 16:43maybe my orchestrator has one of the
- 16:44most powerful models available, a
- 16:46frontier model, but maybe the researcher
- 16:48needs a much less powerful model. And
- 16:50then I can use a feature like the group
- 16:51chat to coordinate how they work
- 16:53together. So rather than a sub agent
- 16:55starting with zero knowledge, we can
- 16:57configure what type of knowledge and
- 16:58skills and memory we want available for
- 17:00each specialist. And that knowledge and
- 17:02all of that context and capabilities
- 17:04survives the chat conversation. It
- 17:07maintains it over time. And since Hermes
- 17:09is a self-learning system, it can also
- 17:11learn more skills as well, getting
- 17:13better at its particular specialized
- 17:14task. And we can take a quick look at a
- 17:16group chat here where we can see, for
- 17:17example, I have the librarian, the
- 17:19orchestrator, and the researcher, and
- 17:20they're all working together to solve
- 17:22the original task that I put out. So,
- 17:24you can think of this as a communication
- 17:25graph where we've set up a group chat
- 17:27here, and the group chat has particular
- 17:29members, and they work together,
- 17:30communicating back and forth with one
- 17:32another to solve a particular problem.
- 17:34So, this is where we go from not just
- 17:35having a loop, but going from a loop to
- 17:38a graph. Now, I've already talked a lot
- 17:39about this in the last two videos. In
- 17:41the first video, I gave an overview on
- 17:43what bot mode is, how to get it set up,
- 17:44and how to customize each of these
- 17:46individual profiles. So, I'm not going
- 17:48to touch on that today. And then in the
- 17:50second video, we did a specific research
- 17:52upgrade where I updated the capabilities
- 17:53of the researcher to be a much more
- 17:55powerful tool. The main skill that I
- 17:56gave the researcher as an upgrade
- 17:58allowed it to check both academic
- 17:59sources and state-of-the-art sources and
- 18:01then corroborate the two of them. I just
- 18:03wanted to quickly show you this because
- 18:04it is a form of graph in the sense that
- 18:06the orchestrator is able to communicate
- 18:08and message back and forth with the
- 18:10different sub aents, but it's not the
- 18:12same as a full task graph like we can
- 18:14get into with Conbon. All you need to
- 18:16know at this point is that the
- 18:17orchestrator is the one that I message.
- 18:19It's my human proxy, the one that
- 18:20controls the other agents. The
- 18:22researcher is able to investigate. So,
- 18:24in the example of information coming in,
- 18:26the orchestrator would create the task
- 18:28and then give it to the researcher to go
- 18:30investigate. And then the librarian
- 18:31works with my existing LLM wiki to take
- 18:34the output research that I've approved
- 18:35as a human and file it into my LLM wiki
- 18:38or my knowledge base in Obsidian. So in
- 18:40a graph, each node can be a single agent
- 18:42or action or a bundle of actions. For
- 18:45example, like an agent loop built into
- 18:47the group as part of a bigger macro
- 18:49loop. So in group chats, one of the key
- 18:51limitations is that they only have the
- 18:53ability to go back and forth three times
- 18:55before they have to stop and check what
- 18:57you actually want.
- 18:59So before we actually get into running
- 19:01these full control graphs, I just wanted
- 19:02to quickly talk about a couple examples
- 19:04on how this fits together so that you
- 19:06can see what the graph might look like
- 19:08before we get into how to set it up just
- 19:10so it makes a little bit more practical
- 19:11sense. So imagine you have an email come
- 19:14in and you want to have a decision.
- 19:16Maybe you want to have a draft created,
- 19:17maybe you want to have some research
- 19:19done, maybe both. So the email can come
- 19:21in and it can trigger an agent like the
- 19:23researcher agent to pull in the relevant
- 19:25context and the evidence by doing some
- 19:27research. Once it's done, it can then
- 19:29create a brief like a research brief and
- 19:31draft a reply and then hand it off to
- 19:33you for review. If you don't think it's
- 19:34good enough quality or you think it's
- 19:36missing something, you can provide some
- 19:37more context, some more commentary, or
- 19:39steer it, and you can have it go back
- 19:41and loop again. So this brings in a
- 19:43loop, but it's a human in the loop. Then
- 19:44if it meets your approval, you can have
- 19:46it create the draft or even potentially
- 19:48send it right away if you've already
- 19:50reviewed the final result. It's up to
- 19:52you if you want to have the send
- 19:54capability given to the agent or if you
- 19:55want to click the button. As another
- 19:57example, let's say you've come across a
- 19:59great article or a YouTube video or some
- 20:02other resource and you've taken some
- 20:04notes on it. You can drop in the raw
- 20:05source and your notes and you can send
- 20:07it off to the librarian. The librarian
- 20:09agent can try and find the fit. How does
- 20:11this fit into your existing knowledge
- 20:13base? It'll check the context
- 20:14connections and draft an entry for you
- 20:17for your review to see is this good
- 20:19enough for it to make it into your
- 20:21knowledge base into your curated
- 20:23library. If it's not good enough, you
- 20:25can suggest revisions and the librarian
- 20:27will update the draft entry and then
- 20:28pass it back to you for review. Once you
- 20:30approve it, the librarian can then file
- 20:32it into the library and connect it to
- 20:34the rest of your research. And as a more
- 20:35complex system, we can actually start
- 20:37linking these loops together. For
- 20:38example, you can propose a question or a
- 20:40topic to the researcher. The researcher
- 20:42can go through a research loop checking
- 20:44sources, checking it against the quality
- 20:46that you've given. This could be a goal
- 20:48loop. And then when it's done all of its
- 20:49research, it can pass it off to you as
- 20:51the human to validate that the
- 20:54information is good enough. You can add
- 20:55your own notes, connect it to that cited
- 20:57source and report and then hand it off
- 20:59to the librarian. The librarian can then
- 21:01see how that fits into your existing
- 21:03knowledge base and prepare a draft for
- 21:05your review on whether or not it should
- 21:06make it into the library. Again, you can
- 21:08go through a curation loop, but this one
- 21:10has a human in the loop as part of the
- 21:12core loop itself. Once you've approved
- 21:14it, the librarian can then go and file
- 21:15this into the library. And then, as a
- 21:17coding example, let's say you're
- 21:18building an app and you want to add the
- 21:20ability to export to Markdown. You can
- 21:22hand this off to your orchestrator and
- 21:24explain what you're looking for. And the
- 21:25orchestrator can understand it and then
- 21:27delegate it to the implement. The
- 21:29implementer can then go through a goal
- 21:30loop where it builds it, checks to see
- 21:33if it works, and if it doesn't, then it
- 21:34repairs it and then it checks it again.
- 21:36So it can loop as many times as you want
- 21:38until the task is actually done. Once
- 21:40it's done, you can pass it off to a
- 21:41reviewer for an independent review. Kind
- 21:43of like a second version of the
- 21:44implementer, but specifically for
- 21:46quality assurance, who can then pass it
- 21:47off to the orchestrator and check to
- 21:49make sure it matches the original goal.
- 21:51If it does, then it can hand it off to
- 21:52you for either a pull request or for you
- 21:54to do something with that particular
- 21:56output. In the original research, the
- 21:58Hermes cooperation actually surfaced
- 22:00that conbon is Hermes durable
- 22:02alternative with name profiles, shared
- 22:04state, dependencies, retries, and work
- 22:06that survives the lead session. So, what
- 22:08that means is it's a lot easier to start
- 22:10and stop and add more tasks and modify
- 22:12and just it gives you a lot more control
- 22:15on the actual task system that's
- 22:17happening here and the way the different
- 22:18agents fit into it. That's why it's
- 22:20called a task graph. But you might be
- 22:21wondering, isn't that kind of similar to
- 22:22what I already showed you where we have
- 22:24the orchestrator or the main agent
- 22:26delegating to sub agents?
- 22:31So the Hermes docs has a good breakdown
- 22:33here of what the difference is because
- 22:35they are actually quite different
- 22:37systems. In delegate task, the parent is
- 22:39blocked from doing things until the sub
- 22:41agent actually returns. Whereas in
- 22:43Conbon, the orchestrator can just set
- 22:45the agent off, can assign the task, and
- 22:47it can just go and do its own thing, and
- 22:49you don't have to have anything make it
- 22:50back to the orchestrator unless you want
- 22:52it to. Rather than having some random
- 22:54anonymous sub agent that starts from
- 22:56scratch, you have a named profile with
- 22:58persistent memory. So that's a pretty
- 22:59important element. Also, for
- 23:01resumability, if the sub agent fails to
- 23:03do its task, it's just done. It just
- 23:05comes back and says incomplete. Whereas
- 23:07in conbon, you can set different types
- 23:09of restoration processes. So it can be
- 23:12blocked and unblocked and then rerun
- 23:13again from where it left off. So this is
- 23:15what I mean when I say it's more
- 23:17durable. It has the ability to survive
- 23:19errors and keep going. With sub agents,
- 23:21you can steer, you can add some
- 23:23feedback, but it's not necessarily
- 23:25actually adding a human in the loop. But
- 23:27in conbon, we can have specific actions
- 23:29or task actually block from happening
- 23:32until the human comes in and says go.
- 23:34And with delegation, the audit trail,
- 23:36all of the context can be lost when the
- 23:39system actually compresses. This is what
- 23:41I was talking about with the context
- 23:42window on the bottom here. If this gets
- 23:43compressed, then if there was a sub
- 23:45agent within that compression, you can
- 23:47lose the context associated with it.
- 23:49Whereas in conbon, it's stored in a
- 23:51SQLite database. So you get access to
- 23:53that forever. You can go back and take a
- 23:54look. So a good summary here is that
- 23:56delegate task is a tool call. It's just
- 23:58one function. Whereas conbon is a work Q
- 24:01where every handoff is a row in a
- 24:02database that any profile or human can
- 24:05see and edit. So there's a lot more
- 24:06transparency that happens here, which is
- 24:08why it starts to get into being a proper
- 24:10control graph or task graph. Thankfully,
- 24:12Hermes has a built-in feature called
- 24:13Conbon. So let's take a look at that.
- 24:17So the first thing we need to do for
- 24:18conbon is you may not have this
- 24:20appearing on the side here. So we can go
- 24:21up to capabilities and then go over to
- 24:23plugins. And we can see that we have
- 24:24three built-in plugins that come with
- 24:26Hermes. The first is bot mode that comes
- 24:28turned on like we've already looked at
- 24:30and the second is the conbon. So make
- 24:31sure this is turned on here. And then
- 24:33you should see this appear on the lefth
- 24:35hand side. So if we go over to conbon
- 24:36here, we are not going to be the ones
- 24:38running things. The agent is. All we
- 24:40need to do is put a card into the ready
- 24:42section, assign it to a particular
- 24:43agent, and the agent will pick it up in
- 24:45a minute. And there's even a triage
- 24:47section. So this is where if you're not
- 24:49quite sure exactly what the task is, you
- 24:51can have an agent rewrite the idea into
- 24:53a proper task first. So that's actually
- 24:55a really important part of it, and I'll
- 24:57show you how we can change the settings
- 24:58for that in a moment. So triage is for
- 25:00raw ideas where that the specifier is
- 25:02going to flush out the spec and then it
- 25:04will move it through the system. To-do
- 25:06means it's waiting on dependencies or
- 25:08unassigned. So we can create task and
- 25:10not assign it and that means the
- 25:11dispatcher won't send it off to go run.
- 25:14We can schedule which is we want a task
- 25:16to run at a particular time. So it could
- 25:18be for example check the latest series
- 25:20of emails and see if something has come
- 25:23in that I've been waiting for. If so
- 25:24then execute the next task. Ready means
- 25:27that the dependencies are satisfied.
- 25:28it's been assigned to a profile and the
- 25:30dispatcher runs it. Running means it's
- 25:31claimed by a worker and an agent's
- 25:33actually working on it. Block means it's
- 25:34waiting for human input. So, this brings
- 25:36that human in the loop. And then review
- 25:38means that there's a review agent
- 25:39specifically checking out the work. So,
- 25:41you can establish which agent you want
- 25:42to operate as the reviewer. And this is
- 25:44the completed section. But with all that
- 25:46said, why don't we run a quick test
- 25:47task?
- 25:50So, I'm going to leave auto decompose
- 25:51triage task turned on. And I'm going to
- 25:53click new task. I'm just going to call
- 25:54this test task. I'm going to leave this
- 25:56assigned to the Wanderloots tutorials
- 25:59assigne and click create task. So what
- 26:01we should see now is we've added this
- 26:04card to triage and the dispatcher is
- 26:06going to recognize this and hand it over
- 26:08to the auto decomposer within a minute.
- 26:10And I'll explain all of that in a
- 26:11moment. So triage is a place for raw
- 26:13ideas where the specifier will flesh it
- 26:15out. So we just saw that it went from
- 26:16this raw idea into running. But this
- 26:19task here is clarify the scope because
- 26:21it sounds like a test. So that's where
- 26:23putting something in triage will
- 26:24automatically assign it to the default
- 26:26that we have set up and it will run over
- 26:28here. So this should get blocked because
- 26:30this was a task that had no clear
- 26:32outcome. So this is where the human in
- 26:34the loop starts to come in because it
- 26:36basically said there's no body. There's
- 26:37no information here. We don't know what
- 26:39they want.
- 26:41So the dispatcher basically runs inside
- 26:43of their Hermes gateway inside of the
- 26:45back end. And you don't have to install
- 26:47anything. It just checks every 60cond
- 26:49has there been a new card created? If
- 26:51so, let's move through the conbon loop.
- 26:53Let's go through the graph. The idea is
- 26:55that once this task gets created as a
- 26:57card, the dispatcher will see, oh,
- 26:59there's a new card. Let me run the
- 27:00system for you. But if we go back to my
- 27:02task for a second, we can see here that
- 27:04we have a rough idea. The specifier will
- 27:06flesh it out. So, we can also see that
- 27:08we have auto decomposed the triage
- 27:10tasks. So, this is where if we go over
- 27:12to settings again, and inside of models,
- 27:14we go down to auxiliary models. We can
- 27:17see here that we have two different
- 27:19models set, two different auxiliary
- 27:20models that we can control here. The
- 27:22first is the triage specifier and this
- 27:24is the one that will take the idea, the
- 27:26goal that you have and frame it as a
- 27:28better task, which will then get passed
- 27:29on to the conbon decomposer to break
- 27:32that task into a task graph. So you can
- 27:35control what you want these models to be
- 27:36here. Perhaps the specifier is a very
- 27:38lightweight model because you're
- 27:39basically just using text to explain
- 27:42text a little bit better. But for the
- 27:43decomposer, you probably want a much
- 27:45more powerful model. And Hermes docs
- 27:48actually has a strategy for this where
- 27:49they say decomposing a project, breaking
- 27:52it into well scoped cards takes frontier
- 27:54level judgment using the most
- 27:56intelligence that you have. But
- 27:58executing a card that has a clear goal,
- 28:00context, and handoff doesn't really need
- 28:02that same level of intelligence,
- 28:03especially if it's running in a loop.
- 28:05Workers are where the vast majority of
- 28:06tokens are spent. So that's typically
- 28:08where the cost is. So that's what I'm
- 28:10getting at when I talk about this
- 28:11decomposer here. We can set this model
- 28:13to whatever we want. I could set this
- 28:15for example to GPT6 Astra if I wanted
- 28:17to. And what would happen is now the
- 28:19conbon decomposer, this decomposer
- 28:21setting that we have here would be using
- 28:23Astra to convert whatever task I put
- 28:26inside of this task card into a series
- 28:28of subtasks that then get assigned to
- 28:30the worker profile, which is wonder
- 28:32tutorials that I currently have set at
- 28:34Terra. So that's just a really powerful
- 28:36way for you to significantly reduce the
- 28:39cost of your operations by having a
- 28:42powerful planning model and a less
- 28:44powerful execution model or implement or
- 28:47worker agent.
- 28:49And we can see up at the top here that
- 28:51we have a default board. So what we can
- 28:53do is we can click on the default. We
- 28:54can rename that board if we want to or
- 28:56create a new one. So I can for example
- 28:58create a new board called test create
- 29:00board. And now when I click on this I
- 29:01can switch between different boards. And
- 29:04what's cool too is within that test
- 29:06board, you can assign it to a specific
- 29:07project. So what that means is you can
- 29:09have different tasks and different
- 29:10graphs and different configurations and
- 29:12settings and operations that you want
- 29:14for particular boards and all of that
- 29:16can be controlled at the project level.
- 29:18So you can create a new project like for
- 29:20example maybe one is your admin project
- 29:22and it deals with everything related to
- 29:23email. Maybe another one is a research
- 29:25project and it deals with all of your
- 29:26research that you're bringing in. Maybe
- 29:28another is for a particular coding
- 29:30project or app that you're working on
- 29:31and all of that can maintain the context
- 29:33within this particular project and then
- 29:35you can assign a particular board
- 29:37associated with that project to run
- 29:39these tasks.
- 29:41So we can open up the orchestration
- 29:43settings here and what that does is it
- 29:44brings up a list of all of the profiles.
- 29:46It brings up all of the different bots
- 29:48or agents that we have available with
- 29:50all of the particular settings and
- 29:52skills and memory and context that we
- 29:55were talking about earlier. Each of
- 29:56these operates as a different
- 29:58specialized agent. So there's a few key
- 30:01settings we need to take a look at. The
- 30:02first is the orchestrator profile. So
- 30:04right now it's defaulting to default.
- 30:06You can change which agent you want to
- 30:08operate as your orchestrator. This is
- 30:10the orchestrating agent that will decide
- 30:12which agent gets which task. And those
- 30:14tasks get assigned to the assigne which
- 30:16you can set which one you want to be the
- 30:18default. Maybe I want to create an
- 30:19implement profile whose sole job is to
- 30:21execute on things. in a similar way that
- 30:23the researcher is the one that
- 30:24researches things and the librarian is
- 30:26the one that files things in my LLM
- 30:28wiki.
- 30:33So for this one I'm going to leave on
- 30:35auto decompose just so you can see how
- 30:36this works. I'm going to click new task.
- 30:38I'm going to call it multi- aent
- 30:40research and I'm going to include the
- 30:41description of the same prompt that I
- 30:43gave previously. So here we can set the
- 30:45priority. This basically just controls
- 30:46the order if you have multiple tasks
- 30:48going in there at once. And then we can
- 30:49have the workspace that we want it to
- 30:51run in. I'm going to leave the current
- 30:53assigne as the waterlude tutorials as
- 30:55the default even though I'm asking for
- 30:57research. So this is where the task
- 30:59decomposer should be able to recognize
- 31:02that this is actually a research task,
- 31:03not an implementation task for the
- 31:05tutorials agent. I can list specific
- 31:07skills if I want. I can change the model
- 31:09that I want this to run at or just have
- 31:11it run at the profile default. And
- 31:13importantly, I can have this run on goal
- 31:15mode. So by default, each worker agent
- 31:17gets one shot at its card to do the
- 31:19work. But turning goal mode into true
- 31:21for that particular task lets that
- 31:23worker run in a goal loop like I've
- 31:24already shown you. And this is its own
- 31:26self-contained goal loop. It doesn't
- 31:28connect to the existing goal that we
- 31:29have elsewhere. And what's cool too is
- 31:31we can also estimate the cost of what
- 31:33this task is going to be. So I can click
- 31:34estimate and then it gives me a list of
- 31:36the tokens that it thinks it's going to
- 31:37cost for this particular prompt here. So
- 31:39it took this task and it analyzed it to
- 31:42give you an estimate. So it says it's
- 31:43going to be a broad ambiguous research
- 31:45task requiring extensive source review,
- 31:47synthesis, architecture comparison, and
- 31:49likely iterative documentation or
- 31:51prototyping. So now, for example, I can
- 31:53include a limitation here of please
- 31:54limit your search to five sources and
- 31:55the output document to 500 words or
- 31:57less. And then I can reestimate it.
- 31:59There we go. It just dropped from 45,000
- 32:01tokens down to 18,000. There's a rough
- 32:03estimate researching up to five sources,
- 32:05comparing this particular task, and then
- 32:06a synthesis under 500 words. And that
- 32:08dropped the complexity of this task down
- 32:11to medium. That's a cool way for you to
- 32:12do a lightweight check ahead of time to
- 32:14make sure that your task isn't going to
- 32:15blow through your whole quota. So now
- 32:16let's click create task. And this brings
- 32:18up the board that I was talking about.
- 32:21The triage section is where raw ideas.
- 32:24We have a specifier that's going to
- 32:25flesh out the spec. So it's going to be
- 32:27converted from this into a different
- 32:29card. And this is using that auxiliary
- 32:31model that I was talking about. Okay,
- 32:32here we go. So it just started. So that
- 32:34triage using the auto decomposer, the
- 32:36dispatcher checked. Oh, it's been a
- 32:38minute. There's something here. Let's
- 32:39break it into two different tasks. So
- 32:41the task decomposer broke it up and
- 32:43assigned it to these particular sub
- 32:44aents where each one is now running on
- 32:47its own. And we can click into this and
- 32:48we can see the specific prompt that was
- 32:50given to it created by the auto
- 32:52decomposer using the default model. We
- 32:54can estimate the effort of this
- 32:55particular task like I was just showing
- 32:56you. And we can comment. So as these
- 32:58tasks are currently running, we can
- 33:00actually send messages to the worker and
- 33:02if there's a big enough change, we can
- 33:03even send a message and then reue it and
- 33:05have it start that task over again. So
- 33:07we get a chance to go through and see
- 33:09how all of this is working, what it's
- 33:10actually doing, how it's analyzing it.
- 33:12And we can see this for each card that's
- 33:14running here. So you get a lot of
- 33:15flexibility for controlling these cards
- 33:17here. And what's cool, too, is for
- 33:19example, I can go back to the to-do
- 33:21section, which are the currently blocked
- 33:22tasks. So these ones are waiting for the
- 33:25researcher to finish before they run.
- 33:27And we can see this one was actually
- 33:28assigned to default instead of
- 33:30orchestrator. So I'm going to change the
- 33:31assigne from default here back to
- 33:33orchestrator. And now we can see that
- 33:34changed the card over here as well. So,
- 33:36I think it's just such a cool way for us
- 33:38to be able to take a look at how all of
- 33:40the tasks are broken up into their
- 33:42individual actions and see how they move
- 33:44through the conbon and you can kind of
- 33:46just get a sense on how all of the
- 33:48project is working together. And that's
- 33:50just for one card. I can now add a
- 33:52second card and it can start running
- 33:53itself and keep going from here. So, you
- 33:55can really start to plan out maybe you
- 33:57have five or six or 10 or 20 tasks that
- 33:59you want to run. You can put them all in
- 34:01here. You can schedule them. You can let
- 34:02the agent know that some are waiting on
- 34:04others. There's a lot that you can do
- 34:06here and it just takes a lot of that sub
- 34:08agent delegation that we were talking
- 34:10about in the first couple examples and
- 34:12makes it a lot more transparent and
- 34:14controllable and that's why it's called
- 34:15a control graph or a task graph because
- 34:17we can actually see the graph of how
- 34:19this is operating. What needs to be done
- 34:21first before the next task can be
- 34:23accomplished. So this one is still
- 34:25running here but we can see this one
- 34:26finished. We can go through and see the
- 34:28full activity. So we can see that it was
- 34:30created and then promoted to ready to
- 34:31run and then it was claimed by a worker
- 34:33which is this researcher agent. It ran
- 34:35through completed it and it created a
- 34:37briefing doc that was saved right here.
- 34:39It only reviewed two sources because it
- 34:41was given a two source limit and it
- 34:44maintained everything. Okay. And it
- 34:45looks like the second one just finished
- 34:46as well. And now we can see that the
- 34:48orchestrator task just moved from to-do
- 34:51to ready. So once it's going from ready,
- 34:53once the dispatcher ticks in 60 seconds
- 34:56or so, it should get put over to
- 34:58running. And there we go. So basically
- 35:00we had those two research tasks and once
- 35:02they were finished the to-do of
- 35:03delivering the report was unblocked
- 35:06because the previous tasks were
- 35:07completed and then once that was
- 35:09unblocked the dispatcher running in the
- 35:11background moved it over to ready. And
- 35:13then once it was ready it shifted it
- 35:15into running. And again we can see all
- 35:16of this was done by the auto decomposer.
- 35:18And here's the specific prompt. So it's
- 35:20pretty complex here. This is where it's
- 35:22important to be really strategic with
- 35:24the information and the tools and the
- 35:26memory and the context, the skills and
- 35:28everything that you're giving to your
- 35:29specialized agents because you don't
- 35:30want to accidentally have them blow
- 35:33through your entire quota because you
- 35:34gave them more than they needed. So
- 35:35that's one of the dangers of running all
- 35:37of this autonomously is that you might
- 35:38be giving these agents more than they
- 35:40need. So it's up to you to go through
- 35:42and experiment and test and just make
- 35:44sure that you're able to be more
- 35:46specific and strategic with how you want
- 35:48to set up these task graphs and how you
- 35:50want to run them. So that task just
- 35:51completed right here and now we have
- 35:53multi-agent research ready. So we had
- 35:54the researcher run create its research
- 35:57report pass it off to the orchestrator
- 35:59who then constructed a 500word or less
- 36:02recommendation and then pass it back to
- 36:04the original prompt that I had put in
- 36:06here called multi- aent research. And
- 36:08now this should be answered by it
- 36:10passing along the document that was
- 36:12created. Great. There we go. So now the
- 36:13dispatcher is running again. The multi-
- 36:15aent research my original question that
- 36:17was created by me. And now it's going to
- 36:19give me the report.
- 36:21Great. And everything is now done. And
- 36:23this is the report that it created from
- 36:25incoming information to action and
- 36:27reusable knowledge which is the theme
- 36:28that we've been working with today. So
- 36:30you can see it's 484 words. It is
- 36:32limited to five sources and it gave a
- 36:34pretty solid recommendation. Have a
- 36:36single accountable lead agent with
- 36:37bounded delegation is the best default.
- 36:39Use a manager style orchestration to
- 36:41keep one owner for state and a final
- 36:43output while allowing scoped
- 36:45specialists. Use a persistent team only
- 36:47when measurement shows sustained
- 36:48independent parallel work. So again,
- 36:50this is basically the same answer as
- 36:52what we had before. So now let's quickly
- 36:54break down what just happened here
- 36:55before I explain the alternative option.
- 36:57So this is the original prompt that I
- 36:59gave and what happened is you can see
- 37:01this was created by dashboard. So this
- 37:03was created by me. I assigned it to the
- 37:05orchestrator and I gave it this
- 37:07particular prompt. Then we can see that
- 37:08the auto decomposer commented and said
- 37:10hey I decomposed I broke up this task
- 37:13into these three subtasks. So these were
- 37:15the two research tasks and then the
- 37:17writing of the article task. The root
- 37:19this question here this task will wake
- 37:22once all the children complete. So it
- 37:23took that description it broke it into
- 37:25those three subtasks. It went through
- 37:27and ran the researcher went into running
- 37:30completed its two tasks here. sent it
- 37:32back to the orchestrator to write the
- 37:33article, which honestly in the future I
- 37:35would probably have an implement agent
- 37:36or a writing agent who's specialized
- 37:38with this, leaving the orchestrator to
- 37:40just deal with orchestration. So that's
- 37:42one change I'm going to make. And then
- 37:44it gave the summary here. So it accepted
- 37:45the deliverable. The final is 485 words.
- 37:48All the sources check out. And here's
- 37:50the simple recommendation. So honestly,
- 37:52that worked pretty well. But maybe we
- 37:53didn't need two researcher agents.
- 37:55That's a little bit of overkill for a
- 37:57five source limitation. that probably
- 37:59used up more tokens than what we needed
- 38:01here. So this is where if we close this
- 38:02and we go back to our orchestration
- 38:04settings, we can start moving beyond
- 38:06this auto decomposer.
- 38:12So this is where instead we can turn it
- 38:14off and we could let the orchestrator be
- 38:16the one to decompose the triage tasks.
- 38:18So why would you want to do that? Well,
- 38:20my orchestrator has a specific soul
- 38:22associated with it. If I go here and
- 38:23click edit soul, I have very specific
- 38:26instructions on how I want the
- 38:27orchestrator to work, how I want it to
- 38:29coordinate my team, who I want it to
- 38:30work with. I can put limits, I can
- 38:32connect specific memories. There's more
- 38:34context that can be given here from the
- 38:37orchestrator profile than just the auto
- 38:39decomposer, which doesn't necessarily
- 38:41have that same level of context. This is
- 38:42just automatic mode. This is more of a
- 38:44curated mode, and it doesn't even have
- 38:46to go through triage. Instead, it can
- 38:48just go straight into ready. But if we
- 38:49want to use the orchestrator to operate
- 38:51as the task decomposer, we need to give
- 38:54it specific conbon skills. So if I go
- 38:56over to orchestrator and then we go to
- 38:58capabilities, we can see here if I go to
- 39:00tools again and then to task, I've
- 39:02turned off task delegation. So basically
- 39:04what that means is I've removed the
- 39:06ability of the orchestrator agent to be
- 39:08able to create those delegated sub
- 39:09aents. Instead, I want the orchestrator
- 39:12to run the conbon board. So I can turn
- 39:14on these tools here. And what that does
- 39:15is if we go back over to conbon by
- 39:17having auto decompose turned off and the
- 39:19orchestrator turned on as the
- 39:21orchestration profile with the conbon
- 39:23tools the orchestrator will now break
- 39:25apart the tasks and then assign it to
- 39:27the particular profiles defaulting to
- 39:29the default assign here. So automatic
- 39:31decomposition buys you convenience. It's
- 39:33really easy. You just type in the task
- 39:35and click go and Hermes will break it
- 39:36down for you. But creating my own
- 39:38planner as the orchestration profile the
- 39:40orchestrator gives me a lot more
- 39:42deliberate control over the task design.
- 39:44and the roles in the review. It's not
- 39:46that one necessarily has to be lower
- 39:48cost than the other. It depends on the
- 39:49task, the complexity, and how much
- 39:51control you want to maintain and how the
- 39:53system operates. The real benefit is
- 39:56continuity. I can return tomorrow. I can
- 39:58see what's blocked. I can inspect the
- 39:59handoff, and I can resume without
- 40:01reconstructing the conversation or
- 40:03trying to set off more sub agents. So,
- 40:05the orchestrator plans, the dispatcher
- 40:07starts the system saying, "We're ready
- 40:09for work." And then the worker executes
- 40:10on the tasks assigned to it. So you can
- 40:12kind of think of each card as work
- 40:14units, not necessarily different agents,
- 40:16but a card can use helpers or contain a
- 40:18goal loop in and of itself. So if we
- 40:20were to do that again, we set which
- 40:22orchestration profile we want, what
- 40:23default assign we want, but instead of
- 40:26creating a new card in triage here, new
- 40:28task in triage, it would just sit here
- 40:29forever because the dispatcher doesn't
- 40:32have the auto decomposer to break that
- 40:35single task into the series of subtasks
- 40:37that then would be put into ready. I'm
- 40:39not going to go through that
- 40:40orchestration example. The key
- 40:42difference is that rather than dropping
- 40:43something into triage, you can either
- 40:45put it into to-do and then wait until
- 40:46you're ready. You can schedule it or if
- 40:48you want to trigger the orchestrator
- 40:49right away, you would drop the new task
- 40:51in ready and let it deal with the task
- 40:53decomposition instead of letting the
- 40:55auto decomposer do it. But I actually
- 40:56tested out the different scenarios to
- 40:58see which works best. So why don't we
- 41:00take a quick look at the results of my
- 41:02testing?
- 41:07So my thought was there's a lot of
- 41:08different coordination methods here.
- 41:10which one actually makes the most sense.
- 41:11The results showed that a single agent
- 41:13with task delegation for a simple task
- 41:16at least and running the orchestrator
- 41:18without the auto decomposer actually had
- 41:20pretty similar token usage and pretty
- 41:22similar quality. But using the auto
- 41:24decomposer and adding the goal loop
- 41:26actually added more overhead for this
- 41:28particular task. So this is obviously a
- 41:30very simple example. It's not by any
- 41:32means a proper benchmark. I just wanted
- 41:34to see how this worked for a particular
- 41:36research task for me. And one thing to
- 41:38keep in mind is that even if the
- 41:39workflow in the conbon takes more
- 41:41tokens, it might be worth it because you
- 41:43can go through and take a look at what
- 41:45was actually done. So it gives you more
- 41:46transparency. The actual right choice
- 41:48just depends on what your work really
- 41:50needs. So I'm going to keep exploring
- 41:52this more. I'm going to try and do some
- 41:54more complex conbon systems with coding
- 41:56so I can actually see what makes sense
- 41:58for my own workflows, how we can
- 42:00leverage the orchestration and control
- 42:02graphs that Hermes has built into it.
- 42:06So, do you need an agent team? Not
- 42:09necessarily. Start with the simplest
- 42:11level that actually meets your needs and
- 42:13then add coordination and complexity as
- 42:15you find yourself actually needing more.
- 42:18You want to find a specific problem that
- 42:19that extra coordination and effort is
- 42:22going to actually solve. Now, today's
- 42:24example was a very simple one. Next,
- 42:26we'll get more into how sub aents,
- 42:28loops, and graphs can fit together to
- 42:30solve more complex workflows. What
- 42:31workflow would be the most helpful for
- 42:33you? Please let me know in the comments
- 42:34and I'm happy to explore these topics
- 42:36more in future videos. If you found this
- 42:38video helpful, please like and subscribe
- 42:39as I really appreciate it. And please
- 42:41consider joining my memberships. My
- 42:42members enable me to continue making
- 42:44free videos like this one. Thanks again
- 42:46for watching and I will see you in the
- 42:47next video.
About this transcript
This page contains the full transcript of Subagents vs Agent Teams? 🧠Hermes Bots, Goal Loops & Kanban Graphs by Wanderloots, generated from the public captions YouTube serves with the video. The transcript has 9,470 words across 1,347 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.