QUICKSTART GUIDE

Microsoft AutoGen + xBind Identity

Add identity-based authentication to Microsoft AutoGen multi-agent conversations. Replace API keys with per-agent DIDs. Each agent gets its own verifiable identity. Zero key management, zero credential rotation, zero cascading failures.

@private.me/autogen 5 minutes to first message Python 3.10+
View @private.me/autogen on npm →
← Back to All Integrations
📚 Complete Documentation
For complete documentation including pricing, purchase API, and technical specifications, see the full white paper.
Step 01

Installation

Install the AutoGen adapter via pip. Works with any AutoGen version 0.2.0 or higher.

Terminal bash 
# Install AutoGen (if not already installed)
pip install pyautogen

# Install xBind adapter for AutoGen
pip install @private.me/autogen
Package Requirement

Requires pyautogen >= 0.2.0 and @private.me/xbind >= 1.0.0. The adapter automatically installs xBind as a dependency.

Step 02

Basic Multi-Agent Conversation

Create two AutoGen agents with xBind identity. Each agent gets its own DID. Messages are authenticated end-to-end.

multi_agent_conversation.py python 
from autogen import AssistantAgent, UserProxyAgent
from private_me.autogen_xbind import xBindAdapter

# Create xBind adapter (automatically generates DIDs for agents)
adapter = xBindAdapter()

# Create assistant agent with xBind identity
assistant = AssistantAgent(
    name="assistant",
    llm_config={"model": "gpt-4", "api_key": "..."}
)

# Create user proxy agent with xBind identity
user_proxy = UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=10
)

# Enable xBind identity for both agents
adapter.enable_for_agent(assistant)
adapter.enable_for_agent(user_proxy)

# Start conversation (messages are authenticated via xBind)
user_proxy.initiate_chat(
    assistant,
    message="What is the weather in San Francisco?"
)

# Each message is signed with sender DID, verified by recipient DID
# Zero API keys, zero credential rotation, zero cascading failures
How It Works

xBindAdapter.enable_for_agent() wraps the agent's send and receive methods. Every outgoing message is signed with the sender's DID. Every incoming message is verified against the sender's DID. Messages without valid signatures are rejected.

Step 03

Group Chat with Identity

Enable xBind identity for multi-agent group conversations. Each agent maintains its own identity. The group chat manager authenticates all messages.

group_chat_identity.py python 
from autogen import AssistantAgent, GroupChat, GroupChatManager
from private_me.autogen_xbind import xBindAdapter

# Create xBind adapter
adapter = xBindAdapter()

# Create three agents
researcher = AssistantAgent(name="researcher", llm_config={...})
engineer = AssistantAgent(name="engineer", llm_config={...})
reviewer = AssistantAgent(name="reviewer", llm_config={...})

# Enable xBind identity for each agent
adapter.enable_for_agent(researcher)
adapter.enable_for_agent(engineer)
adapter.enable_for_agent(reviewer)

# Create group chat
groupchat = GroupChat(
    agents=[researcher, engineer, reviewer],
    messages=[],
    max_round=12
)

# Create group chat manager with xBind identity
manager = GroupChatManager(groupchat=groupchat, llm_config={...})
adapter.enable_for_agent(manager)

# Start group conversation
researcher.initiate_chat(
    manager,
    message="Let's design a distributed file storage system."
)

# All messages authenticated:
# - researcher → manager (verified)
# - manager → engineer (verified)
# - engineer → manager (verified)
# - manager → reviewer (verified)
Why xBind for AutoGen

Benefits

Per-Agent Identity

Each AutoGen agent gets its own DID. No shared API keys, no credential leakage across agents. Identity is cryptographically bound to the agent instance.

Message Authentication

Every message signed with sender DID, verified by recipient. Tampered messages rejected automatically. Man-in-the-middle attacks prevented.

Zero Key Management

No API keys to rotate, no credentials to store, no secrets to leak. DIDs are self-sovereign. Agent restart = same DID, zero config.

Group Chat Security

All group chat messages authenticated end-to-end. Manager verifies every sender. No impersonation possible, even with compromised network.

Drop-In Integration

3 lines to enable xBind. Zero changes to AutoGen agents. Works with existing LLM configs, tools, and conversation flows.

Audit Trail

Every message includes sender DID and signature. Full conversation audit trail. Provable authorship for compliance and debugging.

Advanced

Custom Trust Registry

Restrict agent-to-agent communication using a trust registry. Only allow messages from pre-approved DIDs.

trust_registry.py python 
from private_me.autogen_xbind import xBindAdapter, TrustRegistry

# Create trust registry
registry = TrustRegistry()

# Create adapter with trust registry
adapter = xBindAdapter(trust_registry=registry)

# Create agents
agent_a = AssistantAgent(name="agent_a", llm_config={...})
agent_b = AssistantAgent(name="agent_b", llm_config={...})
agent_c = AssistantAgent(name="agent_c", llm_config={...})

# Enable xBind for all agents
adapter.enable_for_agent(agent_a)
adapter.enable_for_agent(agent_b)
adapter.enable_for_agent(agent_c)

# Add agent_a and agent_b to trust registry (agent_c excluded)
registry.add_did(agent_a.xbind_did)
registry.add_did(agent_b.xbind_did)

# agent_a ↔ agent_b: messages accepted (both in registry)
# agent_c → agent_a: messages rejected (agent_c not in registry)
# agent_a → agent_c: messages rejected (agent_c not in registry)
Trust Registry Enforcement

When a trust registry is configured, agents ONLY accept messages from DIDs in the registry. Messages from unknown DIDs are silently dropped. This prevents unauthorized agents from joining conversations.

What's Next

Next Steps

Need Help?

Questions about AutoGen + xBind integration? Email contact@private.me or open a support ticket at private.me/support.