Flowise offers two extremely powerful solutions for building complex agent workflows. Multi-agents and sequential agents. Deciding which solution to go with can be rather confusing.

So in this video we'll compare these two different features by creating the same project in both. Let's start by having a look at the multi-agent example. Here we have this supervisor node which is responsible for delegating the tasks between the different worker nodes.

For example the software developer node and a code reviewer. And if we compare this to the sequential agent example, you will notice that this flow looks way more complex, but this also gives us way more control over the behavior of our application. First let's have a look at creating a multi-agent team using multi-agent.

First I'm going to save my chat flow and let's call it multi-agent software development team. Let's save this and for this example I simply want a team with two workers. A software developer and a code reviewer.

With multi-agents this is super simple. Let's go to add nodes and under multi-agents let's start by adding a supervisor node and let's also assign an LLM to the supervisor. So for this I'll use the chat openai node.

So for the chat openai node I'll select my credentials, I'll select the model name as GPT40 and let's set a temperature of 0. 4. And lastly let's connect our chat openai node to the supervisor node.

Great! The supervisor is responsible for delegating the task between the different worker nodes. If we open up the additional parameters we can see that the system prompt was pre-populated for us and in this prompt we can see that the team members is actually a variable which is dynamically populated for us.

And in this prompt the supervisor is instructed to decide on which team member needs to be called next or to respond with the word finish to terminate the execution. We don't have to change anything here. Let's simply save this prompt, let's close this popup and let's assign our workers.

Let's go to add nodes and under multi-agents let's add two worker nodes. So I'll simply copy this node and let's assign the name and worker prompts. For the first worker let's call it software developer.

And for the worker prompt let's enter something like you are a software developer. Build an app based on the user's requirements. Use technologies like React, JavaScript and Talwin CSS.

Pass the code to the code reviewer once done. You can complete your task once the code reviewer provides a suitable response. Great, let's have a look at our second worker.

For the worker name let's call this code reviewer. And for the worker prompt let's enter your job is to perform a code review. Check that the code is well written, performant and contains suitable comments.

Always pass your feedback back to the software developer. Let's save this and let's also attach our workers to the supervisor node like so. When using multi-agents to create AI teams this is actually all you have to do.

Let's save this flow and let's test it. Let's ask you to build an app for us like build a to-do list app. The execution is complete and let's have a look at what we got back.

First we can see that the supervisor correctly determined that the next step should be the software developer. So the software developer was executed and produced all of this code. This was then passed back to the supervisor who then determined that the code reviewer should be called next.

And the code reviewer therefore returned these refinements to the solution. This feedback was then passed back to the software developer and the software developer and the code reviewer went back and forth a few times and then finally returned this final feedback. Great, this was very easy to set up and we can easily add more workers to this project without having to change anything else.

One limitation with this though is that we have very little control over our application and we are relying on the supervisor to make the right decisions for us. The best we can do is try and adjust the supervisor system prompt or the worker prompts effective behavior of this application. Now in order to understand how sequential agents work we will try to replicate this application using only the nodes available to the sequential agents.

Let's create a new flow and let's call this sequential agent software team. Let's save this and let's start by adding a node to the canvas and instead of going to multi-agents we will now scroll down to sequential agents. Sequential agents need a starting node and this represents the start of our project.

Let's also attach a chat model so under add nodes and on the chat models I'm going to add the chat openai node to the canvas. I'll select my credentials, let's select the model name as GPT40 and let's set the temperature to something like 0. 2 as we do want our models to follow our prompt instructions.

Let's attach our model to the starting node. We don't actually need agent memory for this example but we do need state. So let's go to add nodes and under sequential agents let's add the state node and let's attach our state node to our starting node.

Great! We will have a look at why we need the state node in a second but let's first continue with our application. Once the application starts we want a supervisor node to be executed.

The supervisor will be responsible for determining which node should be called next. So let's go to add nodes and with the sequential agents we need to think which node we will use for our supervisor. We can either set an agent node or an allyl m node.

For the supervisor I will be using the allyl m node and this won't make sense in a second. Let's connect the starting node to the allyl m node and let's call this supervisor. The supervisors function is simply to determine which node to call next and to set a variable in state.

So the allyl m node would be perfect for that as the allyl m nodes allow us to extract information from the output and then update a state variable. So let's set up the supervisor node. Within additional parameters let's start by setting a system prompt.

Let's enter you are a supervisor tasked with managing a conversation between the following workers. With a multi-agent node the list of workers was simply a variable which was dynamically populated for you. But with the sequential agents we actually have to list the names of the agents or workers within this flow.

This provide further instructions like given the following user's request respond with a worker to act next. Each worker will perform a task and respond with their results and status. When finished respond with finish.

Select strategically to minimize the number of steps taken. Let's save the system prompt and let's also add a human prompt. The human prompt is a special kind of prompt which will be appended at the end of the list of messages.

Let's enter something like given the conversation above who should act next or should be finished. Select one of software developer or code reviewer. So at the start of our application the system prompt will be added at the very top of our prompt.

Then each of our workers will run and append their messages to the conversation history. Then this human prompt will be added at the very end of the conversation and then instruct this model to figure out which node to call next. I hope that makes sense.

Now the result of executing this node will be either software developer, code reviewer or the word finish. So we just want to extract that single word and we can do that using the JSON structured output. Let's click on add item and let's extract a value called next.

Next we'll have a type of enum which is simply a list of possible values. These possible values will be software developer, code reviewer, so I'll simply paste these into this field, comma, finish. So looking at the values we've got software developer, comma, code reviewer, finish.

And for the description I'll enter the role to act next. That's it. So the end result of this node will simply be either software developer, code reviewer or the word finish.

In fact let's go ahead and test out this node by itself by adding an end node to this project and let's attach the LLM to the end node. Great. Let's save this flow and in the chat let's enter, build a to-do list app and the result from executing this will be a JSON structure with a property called next and a value of software developer.

Now we need to figure out how we can use the results from the LLM node, so this value over here to conditionally calling the correct agent. So let's close the chat, let's delete this end node and let's add a condition node. So on the sequential agents let's add this condition node and let's attach the LLM node to our condition node.

Let's call our condition node, determine next node and within the conditions, let's add two conditions. So for the variable we could try and use the output from the previous node, so the LLM node, but a better implementation is to use state. So what we could do is take the output from this LLM node and install it in state and these state values will be available to all the agents within this flow.

So within state let's click on additional parameters and let's create a new property which I'll call next. For the operation let's select replace and initially this value will be blank. Let's go to update state, let's click on add item and when we double click on the key value, we can see the property that we just created in the state called next and for the value we can now assign the value which we created in the structured output which we called next as well.

So for the value let's click on flow dot output dot and let's call this next. This flow dot output is actually referring to the output of this node, the LLM node, and in this output we have this property called next. So we're simply assigning the value of next to the state value of next.

Great, so back in our condition for the variable we can now select that next property within state and now we can say that if state is equal to a value of software developer, then we want to trigger the output of software developer. Then let's create another condition also on the next value in state and if this is equal to code reviewer, then we want to trigger the output of code reviewer. Let's save this and you will now notice that on the condition node we now have different outputs for code reviewer, software developer, and an end state.

This end state will be triggered when the LLM node returns a value of finish or anything that's not code reviewer or software developer. Let's start by adding our two workers under add nodes under sequential agents. Let's add the agent node.

I'm actually going to duplicate this node and let's start with our software developer. For the agent name let's set software developer and for the system prompt, let's enter something like you are a software developer. Build an app based on the user's requirements.

Use technologies like react, javascript, development, and node for creating the app. Always pass the code to the code reviewer. The process may be completed once the code reviewer provides a suitable review.

Then let's have a look at our second worker. Let's give it a name of code reviewer and for the system prompt let's enter your job is to review code from the software developer. Ensure that good coding practices were followed and that the code is well commented.

Pass your feedback back to the software developer once done. Now let's attach our code reviewer from the conditions output to our code review agent. Let's do the same for the software developer and let's also add an end state.

So let's go to add nodes. Let's grab our end node and let's attach this end output from the condition and let's attach it to our end node. Great.

We will improve this end state in a few minutes, but let's first focus on getting these two worker nodes working. So the first time we run this application, the next state will be blank and the supervisor node will try to determine which agent to call next. Initially that's most likely going to be the software developer.

Therefore the condition node will call this software developer node who will produce some sort of output. Now each of these agent nodes need some sort of end state. So after this node is executed, what is it supposed to do next?

This can either be an end node or a loop. And for this example, we do want a loop. So under sequential agents, let's add a loop.

Let's attach the agent to the loop node and we want to loop back to the supervisor. So I'll actually copy the name of the supervisor and paste it into the loop. Let's do the same thing for the code reviewer agent.

Like so. This simply means that after the software developer has executed, it will append its output to the message list and then loop back to the supervisor node over here. The supervisor will now attempt to figure out which node to call next.

And that will most likely be the code reviewer. So the condition node will then trigger the code reviewer who will then review the output of the software developer and provide some feedback. The code reviewer will then loop back to the supervisor, etc.

At some point, the software developer is actually going to respond to the supervisor saying that the process can be completed, at which point this end state over here will be triggered. But of course, we don't want to just terminate this process without any output. So let's add one more node to summarize all the previous messages and provide something for our end user.

Let's go to add nodes under sequential agents. Let's add an LLM node. Then let's connect this end condition to the LLM node.

And let's attach our LLM node to this end state over here. Let's give this LLM node a name, which is summary and under conditional parameters. And let's add a human prompt like given the above conversations, reasonings and instructions, generate a final summarized answer.

And remember, the reason we're using a human prompt is because the human prompt will be appended at the bottom of our messages list. So therefore, this model will have a view of all the previous outputs from these different nodes. So it will be able to summarize those conversations for us.

That's all we have to do in this node. And I think that's all we have to do for this project, actually. Let's save this flow and let's test it out.

So in the chat, let's enter, build a to-do list app. Our supervisor is running. And we can see that the next property in state was set to software developer.

The software developer was then executed and they produced some code for us. This then looped back to the supervisor, who now determined that the next node to be called should be the code reviewer. And therefore, the code reviewer was correctly called, which then provided some feedback as well.

And this time, the software developer was called to make those revisions. After some back and forth between the agents, our supervisor finally set the state to finish. And therefore, our summary node was called, which then provided the final output of this chain.

I hope this video helped you to better understand the inner workings of sequential agents. If you would like to learn more about using sequential agents, then definitely check out this crash course over here.

Sequential vs. Multi Agents: Which Flowise Feature is Right for You?