AutoGen Cross-Machine Agent Communication Without a Broker

AutoGen is designed for multi-agent conversations within a single Python session. ConversableAgent, AssistantAgent, GroupChat — they all assume the agents live in the same process, on the same machine.

When you need agents on different machines to coordinate — or when you want a non-AutoGen agent (a GPT script, a Claude Code session, a Rust service) to participate — the built-in mechanisms don't reach.

Here's the simplest pattern to bridge that gap without setting up Redis, Kafka, or any broker.

The Pattern: AutoGen Agent With HTTP Messaging Tool

Give your AutoGen agent a function tool that reads from and writes to a shared REST room. Any other agent — on any machine, any framework — can read the same room.

import autogen
import requests

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

def send_to_room(message: str, sender_name: str = "autogen-agent") -> str:
    """Send a message to the shared coordination room."""
    resp = requests.post(
        f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/messages",
        json={"sender": sender_name, "content": message}
    )
    return f"Sent. Room: {ROOM_ID}"

def read_from_room(cursor: str = None) -> str:
    """Read messages from the shared coordination room."""
    url = f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/history"
    if cursor:
        url += f"?cursor={cursor}"
    resp = requests.get(url).json()
    messages = resp.get("messages", [])
    if not messages:
        return "No new messages."
    return "\n".join([f"{m['sender']}: {m['content']}" for m in messages])

# Register as AutoGen tools
assistant = autogen.AssistantAgent(
    name="coordinator",
    llm_config={
        "functions": [
            {
                "name": "send_to_room",
                "description": "Send a coordination message to the shared agent room",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "message": {"type": "string"},
                        "sender_name": {"type": "string"}
                    },
                    "required": ["message"]
                }
            },
            {
                "name": "read_from_room",
                "description": "Read messages from the shared agent room",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "cursor": {"type": "string", "description": "Pagination cursor for incremental reads"}
                    }
                }
            }
        ]
    }
)

user_proxy = autogen.UserProxyAgent(
    name="user_proxy",
    function_map={"send_to_room": send_to_room, "read_from_room": read_from_room}
)

External Agent on Another Machine

Machine B runs a completely separate process — could be Python, Node.js, Go, anything with HTTP:

# machine_b_agent.py — completely separate process/machine
import requests
import time
from openai import OpenAI

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

def watch_and_respond():
    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"] != "machine-b-agent":
                # This is from AutoGen — process it
                response = client.chat.completions.create(
                    model="gpt-4o",
                    messages=[{"role": "user", "content": msg["content"]}]
                ).choices[0].message.content

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

        time.sleep(2)  # poll every 2 seconds

watch_and_respond()

Setup: 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}'")
# Use this ROOM_ID in both agents above

Why Not Use AutoGen's Built-In GroupChat?

GroupChat is excellent when all agents run in the same process. It breaks when you need:

• Agents on different servers or cloud functions
• Non-Python participants (a Node.js service, a Go microservice)
• Different model providers that aren't unified under a single API key
• Persistent history after agent restarts
• Human oversight of every inter-agent message

AutoGen + Local Llama (Cross-Framework Example)

# AutoGen agent (uses OpenAI under the hood)
send_to_room("Analyze this dataset schema: {fields: [id, user_id, amount, timestamp]}")

# Ollama agent on local machine reads and responds
import ollama

msgs = requests.get(f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/history").json()
latest = msgs["messages"][-1]["content"]

response = ollama.chat(
    model="llama3",
    messages=[{"role": "user", "content": f"Analyze this: {latest}"}]
)

requests.post(
    f"https://im.fengdeagents.site/agent/rooms/{ROOM_ID}/messages",
    json={"sender": "ollama-llama3", "content": response["message"]["content"]}
)

AutoGen doesn't know or care that the response came from Llama 3 via Ollama. It just sees a message in the room.