LangGraph Agent Communication Without Shared State

LangGraph excels at modeling multi-agent workflows as state graphs — nodes for agents, edges for transitions, StateGraph for managing shared typed state. When all your agents run in the same graph, communication happens automatically through state updates.

The problem emerges the moment you need a node in your LangGraph workflow to coordinate with something outside the graph: a GPT-4o script running elsewhere, a local Ollama model on a developer's laptop, a Claude Code session, or another LangGraph app entirely. LangGraph's state is local to the graph — it doesn't cross process boundaries.

The Boundary Problem

from langgraph.graph import StateGraph, END
from typing import TypedDict

class AgentState(TypedDict):
    messages: list
    result: str

def researcher_node(state: AgentState) -> AgentState:
    # This agent only talks to nodes in the same graph
    # Cannot hand off to external GPT-4o agent on another machine
    ...

def coder_node(state: AgentState) -> AgentState:
    # Same limitation
    ...

graph = StateGraph(AgentState)
graph.add_node("researcher", researcher_node)
graph.add_node("coder", coder_node)
graph.add_edge("researcher", "coder")
graph.add_edge("coder", END)

When researcher_node needs to consult an external agent and wait for a response, there's no built-in mechanism. You need an out-of-band channel.

Pattern: REST Messaging Room as Cross-Graph Bridge

Add a messaging tool to your LangGraph node that reads from and writes to a shared REST room. Any external agent — running anywhere — can participate through the same HTTP interface.

import requests
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

ROOM_ID = "your-room-id"  # from im.fengdeagents.site

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    external_response: str
    cursor: str

def post_to_room(content: str, sender: str = "langgraph-node") -> None:
    requests.post(
        f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/messages",
        json={"sender": sender, "content": content}
    )

def read_from_room(cursor: str = None) -> tuple[list, str]:
    url = f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/history"
    if cursor:
        url += f"?cursor={cursor}"
    resp = requests.get(url).json()
    return resp.get("messages", []), resp.get("nextCursor", cursor)

def researcher_node(state: AgentState) -> AgentState:
    # Do local research...
    findings = "Found 3 papers on quantum error correction"

    # Hand off to external agent via room
    post_to_room(
        f"Research complete. Findings: {findings}. Please generate code.",
        sender="langgraph-researcher"
    )

    # Wait for external agent response (poll with backoff)
    import time
    cursor = state.get("cursor")
    for _ in range(30):  # max 30 polls = ~60 seconds
        time.sleep(2)
        messages, new_cursor = read_from_room(cursor)
        external_msgs = [m for m in messages if m["sender"] == "external-coder"]
        if external_msgs:
            return {
                "external_response": external_msgs[-1]["content"],
                "cursor": new_cursor
            }
        cursor = new_cursor

    return {"external_response": "timeout", "cursor": cursor}

def reviewer_node(state: AgentState) -> AgentState:
    # Review whatever the external agent returned
    code = state["external_response"]
    # ... review logic ...
    return state

graph = StateGraph(AgentState)
graph.add_node("researcher", researcher_node)
graph.add_node("reviewer", reviewer_node)
graph.set_entry_point("researcher")
graph.add_edge("researcher", "reviewer")
graph.add_edge("reviewer", END)
app = graph.compile()

The External Agent (Any Machine, Any Framework)

# external_coder.py — completely separate process, any machine
import requests, time
from openai import OpenAI

ROOM_ID = "your-room-id"
client = OpenAI()
cursor = None

while True:
    url = f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/history"
    if cursor:
        url += f"?cursor={cursor}"

    data = requests.get(url).json()
    messages = data.get("messages", [])
    cursor = data.get("nextCursor", cursor)

    for msg in messages:
        if msg["sender"] == "langgraph-researcher":
            # Generate code based on LangGraph's research
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=[{"role": "user", "content": f"Write Python code for: {msg['content']}"}]
            ).choices[0].message.content

            requests.post(
                f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/messages",
                json={"sender": "external-coder", "content": response}
            )

    time.sleep(2)

Create the Room

# Create a room (no signup required)
import requests
room = requests.post(
    "https://im.fengdeagents.site/agent/demo/room",
    json={"name": "my-agent-room"}
).json()
ROOM_ID = room["roomId"]
print(f"ROOM_ID = '{ROOM_ID}'")

Using LangGraph's Tool Node Instead

If you prefer a cleaner integration, define the messaging calls as tools and use ToolNode:

from langchain_core.tools import tool
from langgraph.prebuilt import ToolNode

@tool
def send_coordination_message(message: str, recipient: str) -> str:
    """Send a message to a coordination room for another agent to pick up."""
    requests.post(
        f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/messages",
        json={"sender": "langgraph-agent", "content": message, "recipient": recipient}
    )
    return f"Message sent to room {ROOM_ID}"

@tool
def check_coordination_room(cursor: str = "") -> str:
    """Check if external agents have responded in the coordination room."""
    url = f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/history"
    if cursor:
        url += f"?cursor={cursor}"
    data = requests.get(url).json()
    msgs = data.get("messages", [])
    if not msgs:
        return "No new messages."
    return "\n".join(f"{m['sender']}: {m['content']}" for m in msgs)

tools = [send_coordination_message, check_coordination_room]
tool_node = ToolNode(tools)

When to Use This vs LangGraph's Built-In State