“AI” has become the hot topic of discussion over the past two years since the release of the ChatGPT web user interface. Worldwide searches for the term “AI” have increased by roughly 400% since November 2022. Although language models have been around for years and interest in them has skyrocketed, it’s important to remember that this technology is still relatively nascent. Despite the innumerable “wow” moments many of us have had with ChatGPT and other large language models (LLMs) since late 2022, the tech and business worlds are still figuring out – and inventing – ways to create real value with this technology.
One fast-developing area in the Generative AI (GenAI) space that is beginning to show significant promise is agentic systems. These comprise numerous specialised LLM “agents” that leverage the reasoning ability of LLMs and can cooperate to achieve goals. To understand how this unlocks value, we begin by examining the progression in the development from single LLM chatbots to sophisticated systems with multiple LLMs working together before diving into a concrete example of an agentic system.
From Single Language Model to Multiple Agents
The lowest hanging fruit for business with LLMs has been to use them to interact with customers as chatbots or improve employee productivity as digital assistants. Despite the ease with which these models can fulfill these two roles, there are limits to how useful a simple chatbot or RAG system is to a company. What happens if someone needs to do more than one narrow task – as is the case for most knowledge work tasks today? As a concrete example, someone may need to first search for and retrieve multiple documents from a database, summarise the most relevant ones, and then generate a report comprising the most important insights across the summaries. A single LLM that attempted to do this would most likely fail at this multi-step task which requires a different set of skills and actions at each step. This highlights the importance of the first property of agentic systems: individual LLM agents that are designed for task-specific roles.
A useful emergent property of LLMs is their ability to reason to a limited, but impressive, extent. This reasoning ability is clear when giving an LLM a piece of text and asking it to answer a question related to that text. This reasoning ability can also be extended to breaking down a task into smaller parts – which could then be passed to task-specific agents – or deciding on a simple, but specific course of action given an input text.
Reasoning alone, however, will only get you so far. In our world of modular interconnected systems, so much value is created and realised by these interconnections. But how can an LLM interact with external systems? Enter tool usage.
Although the usage of tools by LLMs may seem alarmingly human-like, how it works is somewhat less magical, albeit nevertheless ingenious. Imagine you wanted to find the weather report for Camps Bay in Cape Town for Christmas Day. To get information right now you would probably open a weather app on your phone and enter the location and date you wanted the weather forecast for using the app’s interface. This information would then be sent to the weather app’s server through an API endpoint, the result returned, and your weather forecast shown to you. By using an LLM, the app’s interface can be replaced by a user saying, “I want the weather for Camps Bay, South Africa on Wednesday 25th December 2024”. In this case, the LLM would then extract just the relevant information – the location and date – which is then sent to the weather app’s server, the result is returned, and your weather forecast is shown to you. This is what is meant by “tool-use”: the LLM is able to extract information from text and pass the relevant information onto a program or API that does a specific task.
When combining task-specific agents that have reasoning ability with tool calling, we’re able to create systems of reasoning agents that can interact not only with each other but with the outside world as well. At this point, we can formalise the definition of agents and agentic systems. An agent is an instance of an LLM that has a clearly defined task. An agentic system consists of sequential calls to different instances of one or more LLMs (each an individual agent) where each LLM instance is focused on performing a clearly defined sub-task. With more advanced agentic systems, the agents may interact with each other, for example, where the actions of sub-agents may be coordinated by another agent. These agents may have access to external tools, like databases or APIs, which they interact with based on the text inputs they receive – as in the above tool-calling example. An agentic system can best be explained with a tangible use case.
Imagine your goal was to create an intelligent system for ordering a meal from a boutique Mexican restaurant to be collected by the customer. We could split this task into two smaller sub-tasks, namely:
- Menu Item Selection
- Payment
To enable this system, there would be an overarching Router Agent that passes the conversation to one of these sub-agents based on the user’s goal.
Each of these agents is a separate instance of an LLM. Each has its own system prompt, which describes how they should operate. Each also has a separate tool at their disposal: the Menu Item Selector Agent has access to a database containing menu items and the Payment Agent has access to a payment gateway through an API endpoint. At the beginning of the conversation, the Router Agent would infer from the conversation that no food had been chosen by the user and would therefore pass the user to the Menu Item Selector Agent. This agent would help the user to find something that suits their tastes and dietary needs in a conversational way. Once the menu item has been selected, the overarching Router Agent would pass the user to the Payment Agent to collect the user’s payment details – again in a conversational way. Once the payment was successful, this agent would thank the user for their order and tell them their payment was successful.
Why Agents Change the Game
Through this evolution from the lone solo agent to systems of agents, we begin to create truly cognitive systems. By incorporating a conversational user interface with a system of interacting, decision-making, tool-using agents, we vastly increase the range and complexity of activities we’re able to execute with generative AI. In the same way, we build strong multi-disciplinary teams to achieve great results at work, we can achieve vastly more complex goals with GenAI by dividing tasks between task-specific agents. By shifting our design approach to one where the division of labour is clearly defined, we design systems in which the whole is significantly greater than the sum of its parts. At diconium data, we’ve built some exciting multi-agent systems, for a wide range of use cases. From tools that dramatically increase the sales team’s productivity to a voice-first sales agent, our solutions meet tangible business needs and give users real “wow” moments. Reach out to us to find out how we can help you build cutting-edge GenAI tools that solve your real business challenges.