Day 18/30: Shared State in Agents

I recently spent a frustrating afternoon debugging a conversation flow in our customer support bot, built using LangGraph and MCP. The issue was that two agents, designed to work together seamlessly, kept losing context and repeating the same questions to the user. It was as if they had no memory of their previous interactions. After digging through the code and the MCP protocol documentation, I realized the problem boiled down to a simple yet critical decision: how these agents were sharing information with each other.

The support bot is designed to hand off conversations between two agents: one for general inquiries and another for more complex, technical issues. The idea is that when the general inquiries agent reaches its limits, it seamlessly transfers the conversation to the technical agent, which can dive deeper into the user's problem. However, the technical agent kept asking for the user's issue description again, despite the general inquiries agent having already collected this information. This was not only inefficient but also frustrating for the users.

The root of the problem lay in how the agents were managing their state. Initially, I had each agent maintain its own isolated state, which seemed like the most straightforward approach to avoid unintended side effects between them. However, this isolation meant that when the conversation was handed off from one agent to the other, none of the previously gathered context was preserved. The technical agent had no knowledge of the information the general inquiries agent had already obtained.

To solve this issue, I needed to implement a shared scratchpad or state mechanism that would allow both agents to access and update the conversation context without compromising the integrity of their individual states. LangGraph provides a powerful tool for managing state transitions and interactions through its StateGraph API, and MCP offers the add_node and add_conditional_edges methods to define complex workflows and conditions under which state transitions occur.

Here's an example of how I used these tools to create a shared scratchpad for the agents:

import langgraph as lg
from mcp import StateGraph, add_node, add_conditional_edges

# Define the shared scratchpad as a node in the StateGraph
shared_scratchpad = StateGraph()
add_node(shared_scratchpad, 'context', {'user_issue': None})

# Define the agents and their initial states
general_inquiries_agent = lg.Agent('general_inquiries')
technical_agent = lg.Agent('technical')

# Add conditional edges to manage state transitions based on the conversation flow
add_conditional_edges(shared_scratchpad, [
    ('general_inquiries', 'technical', lambda context: context['user_issue'] is not None)
])

# Example of updating the shared scratchpad from within an agent
def update_context(agent, user_input):
    context = shared_scratchpad.get_node('context')
    context['user_issue'] = user_input
    shared_scratchpad.update_node('context', context)

# Usage within an agent's workflow
def general_inquiries_workflow(user_input):
    update_context(general_inquiries_agent, user_input)
    # Hand off to technical agent if necessary
    if shared_scratchpad.evaluate_transition('general_inquiries', 'technical'):
        return technical_agent.handle_conversation()

# Technical agent can access the shared context
def technical_agent_workflow():
    context = shared_scratchpad.get_node('context')
    user_issue = context['user_issue']
    # Proceed with the conversation using the shared context
    return handle_technical_issue(user_issue)

This approach allowed the agents to share the conversation context effectively, significantly improving the user experience by eliminating redundant questions and ensuring a smoother handoff between agents.

One practical gotcha to watch out for when implementing shared state mechanisms is ensuring that the state updates are properly synchronized and that race conditions are avoided, especially in distributed or concurrent environments. This might involve using locking mechanisms or transactional updates to the shared state, depending on the specific requirements and constraints of your application.

As we move forward in building more complex agentic AI systems, the ability to manage shared state and facilitate seamless interactions between agents will become increasingly crucial. Tomorrow, we'll delve into another critical aspect of agent development, exploring how to enhance the autonomy and decision-making capabilities of our agents.