Virtual agents are becoming essential tools in various industries, from customer service chatbots to advanced financial analysis assistants. These intelligent agents are revolutionizing how businesses operate and interact with clients, offering new levels of efficiency, personalization, and innovation.
With their increasing use, ensuring predictability and control of virtual agent behavior is crucial. Reliable and consistent actions are key to building user trust and gaining widespread acceptance. This is where frameworks like AutoGen and Langgraph come into play. These solutions help design intelligent agent behavior, incorporating advanced techniques to define and regulate their actions, reducing risks associated with unpredictable AI behaviors.
Predictability and control are vital for enhancing user experience and maintaining compliance with regulatory standards and ethical guidelines. As businesses rely more on AI-driven solutions, the ability to govern agent actions precisely becomes essential for responsible AI deployment. Implementing frameworks that bring predictability, control, evaluation, and monitoring into the ecosystem fosters confidence among users and stakeholders, encouraging broader adoption of virtual agents in everyday operations.
In this blog, we’ll explore a variety of frameworks and methods that improve the development of predictable and intelligent virtual agents. We will examine AutoGen and important components of this ecosystem that allow agents to interact in a controlled and productive manner. In particular, we’ll look at how to:
- By building a custom function to pick the next speaker on your criteria, you may use AutoGen methods to manage the speaker selection process.
- To depict a deterministic agent process, build a StateFlow model.
By combining these strategies, we aim to ensure that agent decision-making and task execution flow smoothly and dependably, leading to the intended results.
|Introduction to AutoGen and FSM
AutoGen is a cutting-edge framework that enables the creation of conversable agents powered by large language models (LLMs). These agents can engage in automated dialogues to collaboratively accomplish tasks.
The transition of roles and responsibilities between the different agents defined in a conversation to perform a task or set of functions can be defined in the following patterns:
Two-agent chat
- The simplest form of conversation pattern
- Two agents chat with each other
Sequential chat
- A sequence of chats between two agents
- Chained together by a carryover mechanism
- Summary of the previous chat brought into the context of the next chat
Group chat
- Involves more than two agents in a single chat
- Here is the Key question: Which agent should speak next?
- Strategies to select the next agent:
• round_robin: Agents take turns in a fixed order
• random: Agents are selected at random
• manual: Human selection of the next agent
• auto: Default, using an LLM (Large Language Model) to decide
Here’s where, rather than choosing at random or relying only on the LLM’s judgment, we might need greater control and predictability in determining who will speak next in a business setting. The foundation of intelligent flow engineering is this.
In the concept of “Flow Engineering,” several agents collaborate and engage with the environment and one another to complete a job. In contrast to conventional prompt engineering, Flow Engineering divides jobs into more manageable, smaller segments and helps the Large Language Model (LLM) modify its replies repeatedly. The AI’s output becomes far more accurate and efficient as a result of this iterative process, also known as “Flow”, which encourages ongoing self-improvement.
Flow Engineering is an essential part of the creation and implementation of intelligent agent systems because it guarantees improved efficiency and reliability by organizing complicated operations into a sequence of precise interactions.
An organized method of controlling agent behavior is offered by finite state machines (FSMs), which specify transitions between various states (or agents) according to pre-established rules. This potent combination guarantees a regulated and effective workflow, which is especially helpful in intricate customer service circumstances, combined with the unique speaker selection tool.
|Leveraging FSM for Controlled Agent Behavior
By using GroupChat classes allow agent transitions with or without the decision of the LLM. However, some use cases require more control over these transitions. Using FSMs to define transition paths provides this control, where each node represents an agent and each directed edge represents possible transitions.
In a large enterprise, managing customer support inquiries efficiently is crucial for maintaining customer satisfaction and operational efficiency. Imagine a company that receives thousands of support tickets daily, ranging from simple queries to complex issues requiring detailed troubleshooting. This is one of the enterprise scenarios where a multi-agent system with controlled agent behavior can make a significant impact.
Scenario: Automated Financial Consulting System
Consider a wealth management firm that provides personalized financial advice to a large number of clients. An intelligent multi-agent system can help streamline interactions, provide precise and tailored advice, and handle routine queries efficiently.
Key Agents and Their Roles
- Client Agent: Interfaces with clients, capturing their inputs and initiating consultation. The client agent can interact with all the other agents depending on the type of issue/query.
- Investment Advisor Agent: Provides advice on investment strategies and portfolio management. The investment advisor agent can refer to the tax advisor for any tax-related inputs, can respond to the client agent for any questions directed to this agent and can escalate specific queries to the escalation agent.
- Tax Advisor Agent: Handles queries related to tax planning and optimization. The tax advisor agent can refer to the investment advisor for any investment-related inputs, can respond to the client agent for any questions directed to this agent and can escalate specific queries to the escalation agent.
- Retirement Planner Agent: Assists with retirement planning and related financial strategies. The Retirement planner agent can refer to the tax advisor for any tax-related inputs, the investment advisor for any investment-related inputs, can respond to the client agent for any questions directed to this agent and can escalate specific queries to the escalation agent.
- Escalation Agent: Takes over complex cases requiring human financial advisors. The escalation agent will take the issue forward to the human agent or directly respond to the client agent so need not interact with any of the other agents.
Using FSM, we can define the limited flows and interaction between the different agents to bring in predictability and control too.
|Implementation Steps
1. Set Up the Environment
- Requirements:
First, let’s set up the environment:
1 |
pip install pyautogen |
For graph-based functionality:
1 2 3 |
%%capture --no-stderr %pip install pyautogen[graph]>=0.2.11 |
Import the necessary libraries:
1 2 3 4 5 6 7 8 9 10 11 12 |
import random import matplotlib.pyplot as plt import networkx as nx import autogen from autogen.agentchat.conversable_agent import ConversableAgent from autogen.agentchat.assistant_agent import AssistantAgent from autogen.agentchat.user_proxy_agent import UserProxyAgent from autogen.agentchat.groupchat import GroupChat from autogen.graph_utils import visualize_speaker_transitions_dict print(autogen.__version__) |
2. Define Agents and Transition Rules
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
agents = [ UserProxyAgent(name="ClientAgent", system_message="A proxy for taking client input", llm_config=False, human_input_mode="ALWAYS"), AssistantAgent(name="InvestmentAdvisorAgent", llm_config=llm_config), AssistantAgent(name="TaxAdvisorAgent", llm_config=llm_config), AssistantAgent(name="RetirementPlannerAgent", llm_config=llm_config), AssistantAgent(name="EscalationAgent", llm_config=llm_config), ] allowed_speaker_transitions_dict = { agents[0]: [agents[1], agents[2], agents[3], agents[4]], # ClientAgent to any advisor agent agents[1]: [agents[0], agents[2], agents[4]], # InvestmentAdvisor to Client, TaxAdvisor, or Escalation agents[2]: [agents[0], agents[1], agents[4]], # TaxAdvisor to Client, or Escalation agents[3]: [agents[0], agents[1], agents[2], agents[4]], # RetirementPlanner to Client, InvestmentAdvisor, TaxAdvisor, or Escalation agents[4]: [agents[0]], # EscalationAgent to Client agent only } visualize_speaker_transitions_dict(allowed_speaker_transitions_dict, agents) |
The relationship and flow between the agents could be visualized as below:
3. Simulate a Financial Consultation Interaction
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
group_chat = GroupChat( agents=agents, messages=[], max_round=20, allowed_or_disallowed_speaker_transitions=allowed_speaker_transitions_dict, speaker_transitions_type="allowed" ) manager = autogen.GroupChatManager( groupchat=group_chat, llm_config=llm_config, code_execution_config=False, is_termination_msg=is_termination_msg ) agents[0].initiate_chat(manager, message="I need advice on investment strategies. My risk profile is medium") |
This is a simplified example of the agents and this can be improvised by adding more specialized prompts and data to back up the advice. Below is a snapshot of the conversation:
The direct flow specified, which limits the flow from one agent to just a particular set of other agents depending on the type of issue, is the basis for the aforementioned transition.
4. Custom Speaker Selection Function
By establishing the StateFlow, we can further enhance and control agent interactions to produce deterministic workflows. We can add additional logic and conditions to a custom function that determines the next agent to reply based on the previous speaker’s response and the current state.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
def custom_speaker_selection_func(last_speaker, groupchat): if last_speaker == agents[0]: # ClientAgent return agents[1] # InvestmentAdvisorAgent elif last_speaker == agents[1]: # InvestmentAdvisorAgent last_message = groupchat.messages[-1]['content'] if "tax" in last_message: return agents[2] # TaxAdvisorAgent elif "retirement" in last_message: return agents[3] # RetirementPlannerAgent elif last_speaker == agents[2]: # TaxAdvisorAgent return agents[4] # EscalationAgent elif last_speaker == agents[3]: # RetirementPlannerAgent return agents[4] # EscalationAgent return None # End chat if EscalationAgent was the last speaker |
5. Configure Group Chat with Custom Speaker Selection
1 2 3 4 5 |
groupchat = GroupChat( agents=[agents[0], agents[1], agents[2], agents[3], agents[4]], speaker_selection_method=custom_speaker_selection_func, messages=[] ) |
6. Initiate the Chat
1 2 |
manager = autogen.GroupChatManager(groupchat=groupchat) agents[0].initiate_chat(manager, message="Hello, I need advice on my portfolio.") |
Utilizing StateFlow to design the workflow brings predictability and control to the interaction by adding logic based on intermediate responses, tools used, query constructs, etc, which is crucial for gaining acceptance and trust in virtual agent systems. As we continue to refine these architectures, the potential for intelligent virtual agents in wealth management and beyond is limitless.
|Advantages of FSM and StateFlow Based Agent System
Workflow Control and Configuration
The detailed description of how queries are routed between agents according to the kind of issue and the level of knowledge needed is made possible by the FSM and StateFlow methodology. By using a systematic method, it is ensured that the most suitable agent responds to each client inquiry, increasing customer happiness and efficiency. We can make sure that the transitions are rational and well-suited for different contexts by viewing the FSM.
Improved Interaction Between Agents
By utilizing each agent’s unique characteristics, the multi-agent system allows for the specialized processing of various query kinds. For example, the Investment Advisor Agent handles investment-related questions, whereas the tax advisor Agent handles tax-related concerns. Customers are guaranteed prompt and precise support from experts because of this specialty.
Scalability and Efficiency
Scalability is one of the main benefits of employing multi-agent systems powered by Intelligent Flow. These systems can manage a large number of queries without sacrificing quality or response speeds. Routine inquiries may be automated to free up human agents to work on more difficult jobs, increasing overall efficiency.
|Practical Benefits and Business Impact
Streamlined Assistance for Customers
The strain on human agents is greatly decreased by the FSM-driven system by automating the processing of routine questions. By doing this, response times are sped up and clients are guaranteed accurate and fast support.
Personalized Response to Inquiries
Based on preset rules, the hierarchical framework routes questions to the most suitable agent. This guarantees that agents with the necessary experience tackle specialist inquiries, enhancing the caliber of help offered.
Enhanced Operational Efficiency
Significant increases in operational efficiency result from the automation of repetitive processes and the effective management of intricate workflows. This results in lower expenses and improved resource management for the company.
|Conclusion
Using AutoGen to implement FSM-driven multi-agent architectures has several advantages, including better agent collaboration, more control over task execution, and effective handling of intricate workflows. Frameworks like Autogen brings a structured way to define the autonomous agent ecosystem by personifying the different roles with associated tasks, tools and flows. We will look at other frameworks like Langgraph, and Llama-agent which bring similar specialties to empower the agent ecosystem in our future blogs and also compare these frameworks on their relative performance and capabilities.
This method may be used for various corporate applications such as supply chain management, healthcare, and financial services, in addition to optimizing customer assistance. Businesses may attain higher levels of efficiency, precision, and dependability by utilizing these advanced strategies, which will pave the way for a more intelligent future.
To develop reliable autonomous agents, we must analyze the methods and strategies of our top performers and domain experts, replicate their effective approaches, and thoroughly document their processes, flows and behaviors. This becomes the most important input to designing our intelligent agent ecosystem and ensures the virtual agents can consistently achieve the desired outcomes. As the technology is maturing, bringing in predictability and control, more and more companies will leverage autonomous agents to streamline operations, boost efficiency, drive innovation, and secure a competitive edge in the ever-evolving market.
WalkingTree Technologies is renowned in the field of AI-driven solutions, with extensive expertise in leveraging technologies like AutoGen and FSM to transform agent behavior and enhance efficiency, control, and scalability. Our dedicated team of experts is committed to providing innovative solutions tailored to meet the unique needs of your business.
Visit our website to learn more about how we can support your business to innovation and success.
