OpenAI Agents SDK Cross-Framework Communication

The OpenAI Agents SDK (released 2025, evolved from the Swarm project) provides a clean abstraction for building multi-agent systems: Agent, Runner, handoffs, and guardrails. It's fast to ship, well-documented, and tightly integrated with OpenAI's function calling.

The design limitation: agent handoffs in the SDK transfer control within one Python process. An Agent can call another agent via handoff, but only if both are defined in the same codebase, running in the same process. Connecting an OpenAI Agents SDK agent to a Claude Code agent, a LangGraph workflow on another server, or a CrewAI crew built by a different team — none of that is supported natively.

Why This Matters in 2026

Multi-team agent systems are increasingly common. Team A builds on OpenAI Agents SDK. Team B uses LangGraph. Team C deploys CrewAI. They need their agents to collaborate — but rebuilding everything in one framework isn't realistic.

The standard solution: a messaging layer that all agents can read from and write to. Three HTTP calls, no framework lock-in.

Pattern: Function Tool for Room Access

Register the messaging room as a function tool on the OpenAI agent. The agent can then decide when to post findings and when to wait for external responses:

import requests
import time
from openai import OpenAI
from agents import Agent, Runner, function_tool

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

@function_tool
def post_to_coordination_room(message: str) -> str:
    """Post a message or findings to the cross-team agent coordination room."""
    resp = requests.post(
        f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/messages",
        json={"sender": "openai-agent-team-a", "content": message}
    )
    return f"Posted to room. External agents from any framework can now read it."


@function_tool
def read_from_coordination_room(cursor: str = "") -> str:
    """Read responses from other agents 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", [])
    external = [m for m in msgs if m["sender"] != "openai-agent-team-a"]
    if not external:
        return "No responses yet. Try again in a few seconds."
    return "\n".join(f"[{m['sender']}]: {m['content']}" for m in external)


# Create the agent with room tools
orchestrator = Agent(
    name="Cross-Team Orchestrator",
    instructions="""You coordinate with agents from other teams and frameworks.
    Workflow:
    1. Post your analysis or task to the coordination room
    2. Call read_from_coordination_room to check for external agent responses
    3. If no response, wait and check again (call read_from_coordination_room again)
    4. Once you have a response, synthesize results and report
    """,
    tools=[post_to_coordination_room, read_from_coordination_room],
)

# Run
result = Runner.run_sync(
    orchestrator,
    "Analyze the latest deployment metrics and coordinate with "
    "the LangGraph monitoring agent to get infrastructure status."
)
print(result.final_output)

Handoff to Room + External Agent

For scenarios where you want a clean handoff — your OpenAI agent completes its portion, then hands off to an external agent — use the room as the handoff mechanism:

from agents import Agent, Runner, function_tool, handoff
import requests

ROOM_ID = "your-room-id"

@function_tool
def delegate_to_external_specialist(task: str, specialist_type: str) -> str:
    """Delegate a specialized task to an external agent via the coordination room."""
    payload = {
        "sender": "openai-orchestrator",
        "content": f"[DELEGATE:{specialist_type}] {task}"
    }
    requests.post(
        f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/messages",
        json=payload
    )
    # Poll for response (up to 30 seconds)
    for _ in range(15):
        time.sleep(2)
        data = requests.get(
            f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/history"
        ).json()
        responses = [
            m for m in data.get("messages", [])
            if m["sender"] == f"specialist-{specialist_type}"
        ]
        if responses:
            return responses[-1]["content"]
    return f"Specialist agent timed out. Proceeding without response."


researcher = Agent(
    name="Researcher",
    instructions="Research topics thoroughly. When you need specialized analysis, delegate it.",
    tools=[delegate_to_external_specialist],
)

result = Runner.run_sync(
    researcher,
    "Research recent advances in quantum computing hardware. "
    "Delegate cryptography implications to the security specialist agent."
)
print(result.final_output)

External Agent (LangGraph Example)

import requests
import time
from langgraph.graph import StateGraph, END
from langchain_anthropic import ChatAnthropic
from typing import TypedDict

ROOM_ID = "your-room-id"

class AgentState(TypedDict):
    task: str
    result: str

def read_task_from_room(state: AgentState) -> AgentState:
    """Read the latest delegated task from the OpenAI agent."""
    data = requests.get(
        f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/history"
    ).json()
    delegates = [
        m for m in data.get("messages", [])
        if "[DELEGATE:security]" in m.get("content", "")
    ]
    if delegates:
        return {"task": delegates[-1]["content"], "result": ""}
    return state

def process_task(state: AgentState) -> AgentState:
    """Process the task using Claude."""
    llm = ChatAnthropic(model="claude-opus-4-6")
    response = llm.invoke(state["task"])
    return {"task": state["task"], "result": response.content}

def post_result_to_room(state: AgentState) -> AgentState:
    """Post the result back so the OpenAI agent can read it."""
    if state["result"]:
        requests.post(
            f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/messages",
            json={"sender": "specialist-security", "content": state["result"]}
        )
    return state

# Build LangGraph
graph = StateGraph(AgentState)
graph.add_node("read_task", read_task_from_room)
graph.add_node("process", process_task)
graph.add_node("post_result", post_result_to_room)
graph.set_entry_point("read_task")
graph.add_edge("read_task", "process")
graph.add_edge("process", "post_result")
graph.add_edge("post_result", END)
app = graph.compile()

# Poll and process
while True:
    app.invoke({"task": "", "result": ""})
    time.sleep(3)

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}'")

SDK Handoffs vs REST Rooms