Is tool-calling all you need?Interaction patterns in multi-agent systems
Part II: Existing Agent Orchestration methods similar to agents-as-tools
The first part of this series explained what multi-agent AI systems are and why they are useful, and introduced the powerful agents-as-tools interaction pattern. This blog will review the interaction patterns that we believe are similar or equivalent to agents-as-tools.
Note that all the frameworks we discuss here are exciting, complex, and fast-moving, so we lay no claim to absolute truth in our discussion. What we say here about these frameworks is our best understanding of them at the time of writing, and we'll be grateful for clarification if you believe anything we say here is wrong or incomplete.
Perhaps the most popular multi-agent framework at the moment is Autogen [https://microsoft.github.io/autogen/]. Autogen's agents don't have an agent executor, instead their method of interaction with each other is a conversation, where one agent can ask another to, for example, execute code, and a special agent ("User Proxy") executes the code and otherwise interacts with the outside world.
In the case when there are only two agents in a chat, and all one of them does is execute code for the other [https://github.com/microsoft/autogen/blob/main/notebook/agentchat_MathChat.ipynb], the situation is really equivalent to a single agent with an agent executor [https://motleycrew.readthedocs.io/en/latest/examples/math_single_agent.html].
If instead two or more agents are using LLMs to exchange chat messages with each other, this can be regarded as equivalent to one of the agents (the 'chat manager') using the other(s) as tools to request answers from, each time sending the whole chat history so far as the request to each agent-as-tool, and getting the next message back as the reply.
All agents sharing a common chat is not an approach that scales well, however. Much of the craft of multi-agent design, and of programming more generally, consists in slicing a task into small distinct pieces that interact as little with each other as possible. In that spirit, Autogen has introduced some encapsulation methods, such as society-of-mind [https://microsoft.github.io/autogen/docs/notebooks/agentchat_society_of_mind/] and nested chats [https://microsoft.github.io/autogen/docs/notebooks/agentchat_nestedchat/]; these are again almost pure examples of agents-as tools.
Another popular multiagent framework is CrewAI [https://www.crewai.com/]. Its noteworthy features are a concept of a Task, that can be executed by an agent, and of "delegation", allowing agents to pass the task on to other agents (those other agents weren't allowed to pass it on further, though, when we last looked). Finally, it has the concept of a Process, with two implementations: firstly, Sequential, where tasks are assigned agents by the user and executed in a predetermined sequence, and Hierarchical, where the order of execution of tasks, and agents to execute them, is determined by a dedicated manager agent.
How much of this is equivalent to agents-as-tools? Delegation is explicitly implemented as agents-as-tools under the hood, it's not even clear why a separate concept needed to be introduced for it. Sequential Process is a simple for-loop that executes the tasks in turn and passes each task's output to the next task's input, similar to the >> operator in motleycrew. The Hierarchical process also perfectly fits the tool-calling paradigm, where the manager agent could for example call an ordering tool with a list of pairs (task name, agent name) representing the order and agent assignment of the tasks, which would create a Sequential process with that ordering and agents; or, if we want the assignment to depend on the output of earlier tasks, it could call multiple times a NextTask tool, passing it a single pair (task name, agent name) at a time.
All in all, both the delegation and the process concepts in CrewAI seem to be redundant, and could have just as easily been implemented as tool calling. On the other hand, its Task concept we found a great idea, and it inspired the Task [https://motleycrew.readthedocs.io/en/latest/key_concepts.html#tasks-task-units-and-workers] concept in motleycrew.
At this point you might be tempted to think that tool calling, in particular agents-as-tools, is the universal pattern for mulit-agent interaction. Unfortunately, that is not the case. The next part of this series will review two frameworks, Langgraph [https://www.langchain.com/langgraph] and MetaGPT [https://github.com/geekan/MetaGPT] that use very different orchestration methods.