AI Agents and Multi-Agent Systems: Building Intelligent Workflows

Alvin
April 9, 2025
Approx. read time: 7 mins

In today’s rapidly evolving artificial intelligence landscape, AI agents have become powerful tools for automating complex tasks and decision-making processes. This blog explores the fascinating world of AI agents, particularly focusing on multi-agent systems and how they can be implemented using Python and LangGraph.

What is an AI Agent?

An AI agent is a software entity that can perceive its environment, make decisions, and take actions to achieve specific goals. Unlike traditional software that follows predetermined rules, AI agents can adapt their behavior based on their experiences and the changing environment.

Key characteristics of AI agents include:

Autonomy: They can operate without direct human intervention
Reactivity: They respond to changes in their environment
Proactivity: They can take the initiative to achieve their goals
Social ability: They can interact with other agents or humans

AI agents typically follow a perception-action cycle:

Perceive the environment
Process information using their knowledge and reasoning capabilities
Plan and decide on appropriate actions
Execute those actions
Learn from the outcomes

Why Multi-Agent Systems Matter

While a single AI agent can be powerful, multiple agents working together can handle more complex scenarios through:

Division of labor: Different agents can specialize in different tasks
Parallel processing: Multiple agents can work simultaneously
Redundancy: If one agent fails, others can continue
Diverse perspectives: Different agents can approach problems differently

Let’s explore how to build a multi-agent system using Python and LangGraph, with a practical example from the financial domain.

Building a Financial Advisory Multi-Agent System

For our example, we’ll create a simplified financial advisory system with multiple specialized agents:

Market Analyzer: Analyzes market trends
Risk Assessor: Evaluates investment risks
Client Communicator: Translates technical findings into client-friendly language

Each agent will have specific responsibilities yet work together to provide comprehensive financial advice.

Setting Up the Environment

First, let’s install the necessary libraries:

# Install required packages
pip install langchain langchain-openai langgraph

Now, let’s import the required modules:

import os
from typing import Dict, List, Any
from enum import Enum

from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, SystemMessage
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END

Defining a Simple Tool

We’ll start with a simple tool that our agents can use:

from langchain_core.tools import tool

@tool
def get_stock_price(ticker: str) -> str:
    """
    Get the current price of a stock (simulated data).
   
    Args:
        ticker: The stock ticker symbol to look up.
       
    Returns:
        The current stock price.
    """
    # In a real implementation, this would call an API
    stocks = {
        "AAPL": 178.72,
        "MSFT": 413.64,
        "GOOGL": 177.48,
        "AMZN": 185.07,
        "TSLA": 177.58
    }
   
    if ticker in stocks:
        return f"{ticker} is currently trading at ${stocks[ticker]}"
    else:
        return f"No data available for {ticker}."

Defining the Agent State

Let’s define a simple structure for our multi-agent system’s state:

class AgentState(dict):
    """State for our multi-agent system."""
    messages: List[BaseMessage]
    next_agent: str

class AgentType(str, Enum):
    """Types of agents in our system."""
    MARKET_ANALYZER = "market_analyzer"
    RISK_ASSESSOR = "risk_assessor"
    CLIENT_COMMUNICATOR = "client_communicator"

Creating the Market Analyzer Agent

Our first agent will analyze market data:

def create_market_analyzer():
    """Create the market analyzer agent."""
    system_prompt = """You are a Market Analyzer agent in a financial advisory system.
   
    Your job is to analyze stocks and provide insights based on their current prices.
    Focus on facts and clear analysis.
   
    After your analysis, the Risk Assessor agent will evaluate the investment risks.
    """
   
    llm = ChatOpenAI(model="gpt-4o", temperature=0)
    llm_with_tools = llm.bind_tools([get_stock_price])
   
    def agent_function(state: AgentState) -> AgentState:
        """Market analyzer agent function."""
        messages = state["messages"]
       
        # Generate response using the LLM with tools
        response = llm_with_tools.invoke(messages)
       
        # Return updated state, passing to risk assessor next
        return {
            "messages": messages + [response],
            "next_agent": AgentType.RISK_ASSESSOR
        }
       
    return agent_function

Creating the Risk Assessor Agent

Our second agent will assess investment risks:

def create_risk_assessor():
    """Create the risk assessor agent."""
    system_prompt = """You are a Risk Assessor agent in a financial advisory system.
   
    Your job is to evaluate the risk of investments based on the Market Analyzer's insights.
    Assign a risk level (Low, Medium, High) to each investment option.
   
    After your assessment, the Client Communicator will translate the findings for the client.
    """
   
    llm = ChatOpenAI(model="gpt-4o", temperature=0)
   
    def agent_function(state: AgentState) -> AgentState:
        """Risk assessor agent function."""
        messages = state["messages"] + [SystemMessage(content=system_prompt)]
       
        # Generate response
        response = llm.invoke(messages)
       
        # Return updated state, passing to client communicator next
        return {
            "messages": messages + [response],
            "next_agent": AgentType.CLIENT_COMMUNICATOR
        }
       
    return agent_function

Creating the Client Communicator Agent

Our final agent will communicate with the client:

def create_client_communicator():
    """Create the client communicator agent."""
    system_prompt = """You are a Client Communicator agent in a financial advisory system.
   
    Your job is to translate technical financial information into clear, client-friendly language.
    Explain the market analysis and risk assessment in terms the client can understand.
    Provide a concise, actionable summary of the investment advice.
   
    This is the final step in the workflow.
    """
   
    llm = ChatOpenAI(model="gpt-4o", temperature=0)
   
    def agent_function(state: AgentState) -> AgentState:
        """Client communicator agent function."""
        messages = state["messages"] + [SystemMessage(content=system_prompt)]
       
        # Generate response
        response = llm.invoke(messages)
       
        # Return updated state, ending the workflow
        return {
            "messages": messages + [response],
            "next_agent": END
        }
       
    return agent_function

Constructing the Multi-Agent Workflow

Now we’ll use LangGraph to orchestrate our agents into a coherent workflow:

def build_financial_advisor_workflow():
    """Build the financial advisor workflow."""
    # Create the agents
    market_analyzer = create_market_analyzer()
    risk_assessor = create_risk_assessor()
    client_communicator = create_client_communicator()
   
    # Initialize the workflow graph
    workflow = StateGraph(AgentState)
   
    # Add nodes for each agent
    workflow.add_node(AgentType.MARKET_ANALYZER, market_analyzer)
    workflow.add_node(AgentType.RISK_ASSESSOR, risk_assessor)
    workflow.add_node(AgentType.CLIENT_COMMUNICATOR, client_communicator)
   
    # Add edges to connect the agents
    workflow.add_conditional_edges(
        AgentType.MARKET_ANALYZER,
        lambda state: state["next_agent"]
    )
    workflow.add_conditional_edges(
        AgentType.RISK_ASSESSOR,
        lambda state: state["next_agent"]
    )
    workflow.add_conditional_edges(
        AgentType.CLIENT_COMMUNICATOR,
        lambda state: state["next_agent"]
    )
   
    # Set the entry point
    workflow.set_entry_point(AgentType.MARKET_ANALYZER)
   
    # Compile the graph
    return workflow.compile()

Running the Multi-Agent System

Let’s create a simple function to run our financial advisor:

def run_financial_advisor(user_query: str) -> List[BaseMessage]:
    """Run the financial advisory multi-agent workflow."""
    # Build the workflow
    financial_advisor = build_financial_advisor_workflow()
   
    # Initialize state
    initial_state = {
        "messages": [
            SystemMessage(content="You are a financial advisory system."),
            HumanMessage(content=user_query)
        ],
        "next_agent": AgentType.MARKET_ANALYZER
    }
   
    # Execute the workflow
    result = financial_advisor.invoke(initial_state)
   
    # Return the conversation history
    return result["messages"]

Example Usage

Here’s how you might use our multi-agent system:

user_query = "I'm interested in investing in Apple (AAPL) and Microsoft (MSFT). What can you tell me about these stocks?"

# Run the multi-agent system
conversation = run_financial_advisor(user_query)

# Display the conversation
for message in conversation:
    if isinstance(message, HumanMessage):
        print(f"USER: {message.content}\n")
    elif isinstance(message, AIMessage):
        if "Market Analyzer" in message.content[:30]:
            print(f"MARKET ANALYZER: {message.content}\n")
        elif "Risk Assessor" in message.content[:30]:
            print(f"RISK ASSESSOR: {message.content}\n")
        elif "Client Communicator" in message.content[:30]:
            print(f"CLIENT COMMUNICATOR: {message.content}\n")
        else:
            print(f"SYSTEM: {message.content}\n")

Expanding the System: Advanced Patterns

Once you have the basic multi-agent system working, you can explore more advanced patterns:

Parallel Processing

You can modify your workflow to have agents work in parallel:

# Creating a parallel execution branch
def build_parallel_workflow():
    workflow = StateGraph(AgentState)
   
    # Add your agents as nodes
    # ...
   
    # Setup parallel branches
    workflow.add_edge(AgentType.MARKET_ANALYZER, "branch_selector")
    workflow.add_conditional_edges(
        "branch_selector",
        lambda state: {"branch1": state["needs_analysis"], "branch2": state["needs_history"]}
    )
   
    return workflow.compile()

Dynamic Routing

You can implement dynamic routing based on message content:

def determine_next_agent(message_content):
    """Determine which agent should act next based on the content."""
    if "risk" in message_content.lower():
        return AgentType.RISK_ASSESSOR
    elif "explanation" in message_content.lower():
        return AgentType.CLIENT_COMMUNICATOR
    else:
        return AgentType.MARKET_ANALYZER

# Then use this in your agent functions
def dynamic_routing_agent(state):
    # ... process input ...
   
    # Determine next agent dynamically
    next_agent = determine_next_agent(response.content)
   
    return {
        "messages": state["messages"] + [response],
        "next_agent": next_agent
    }

Real-World Applications

Multi-agent systems have numerous applications in finance:

Investment Advisory: Specialized agents for different asset classes
Fraud Detection: Multiple agents monitor different aspects of transactions
Customer Service: Routing questions to specialized financial experts
Risk Management: Different agents monitor various risk factors

Conclusion

AI agents and multi-agent systems represent a significant advancement in how we can leverage artificial intelligence to solve complex problems. By breaking down tasks into specialized domains and allowing agents to collaborate, we can create more robust and flexible AI systems.

Our financial advisory example demonstrates how different specialized agents can work together to provide comprehensive advice that no single agent could deliver alone. Each agent contributes its unique expertise while being part of a coherent workflow.

As you build your own multi-agent systems, remember to:

Define clear responsibilities for each agent
Design efficient communication between agents
Implement appropriate routing to ensure the right agent handles each task
Test the system thoroughly with various inputs

Whether you’re looking to optimize business processes, enhance decision-making, or create more engaging user experiences, multi-agent systems provide a robust framework for building the next generation of intelligent applications.

Services

Browse our services

Learn more

Case Study

A military organisation harnesses AI