# AutoGen MCP

> AutoGen MCP manages complex, multi-agent AI workflows. Define customized LLM roles, run isolated sessions, map out entire agent topologies, and get deep traces of every conversation between specialized agents from any AI client.

## Overview
- **Category:** superpower
- **Price:** Free
- **Tags:** multi-agent-systems, workflow-automation, execution-logs, agent-memory, conversational-ai, task-automation

## Description

This connector lets you build and monitor advanced AI teams. Instead of writing one prompt for a single task, you define several cooperating agents—like a coder, a reviewer, and a project manager—that talk to each other until the job is done. You can create completely isolated memory spaces for these workflows so they run cleanly without interference. Furthermore, you can visualize how the entire process flows, mapping out all the steps an agent takes from start to finish. If your automated tasks get complicated, this MCP gives you full visibility into the execution logs and conversations between agents, letting you debug exactly where things went wrong in a complex chain of actions. Connecting via Vinkius means you can access this whole suite of capabilities directly from Claude, Cursor, or any other AI client.

## Tools

### create_agent
Defines a new customized agent with specific parameters and roles.

### create_message
Sends an initial or follow-up message to start or continue a running agent session.

### list_skills
Lists available Python functions that can be used by the agents to perform external tasks.

### create_session
Sets up a new, isolated memory space for multi-agent workflows.

### delete_session
Permanently removes an existing agent conversation session from the system.

### list_agents
Retrieves a list of all customized agents currently configured in the instance.

### list_messages
Fetches the complete message history for any specific agent session.

### list_models
Lists all constrained Large Language Models available for use in the agents.

### list_sessions
Retrieves a list of all active or completed agent conversation sessions.

### list_workflows
Retrieves a list of all pre-defined, multi-agent workflow topologies.

## Prompt Examples

**Prompt:** 
```
List all configured LLM models available right now.
```

**Response:** 
```
You have 3 restricted LLM configurations available in your AutoGen Studio instance. gpt-4-turbo for complex agents, gpt-3.5-turbo mapped for basic coder roles, and a local quantized llama-3 constraint. Want me to inspect the multi-agent Workflows built on top of them?
```

**Prompt:** 
```
Analyze the message traces for the session running the Code Reviewer.
```

**Response:** 
```
Fetching historical agent-to-agent traces for Tracker UUID cd82-... User_Proxy provided the diff 3 minutes ago. Coder_Agent built a solution, but Critic_Agent heavily rejected it due to a hard-coded API key security issue inside the script. The Coder is currently stalled retrying a new commit implementation. Should I intervene?
```

**Prompt:** 
```
Create a new isolated session and execute the research workflow.
```

**Response:** 
```
A new clean boundary UUID a9f2-bcd has been created. I've successfully routed a POST Message into it targeting the 'Market Research' topograph topology. The agentic group is starting now. Should I poll it and summarize their conclusions after five minutes?
```

## Capabilities

### Define Agent Roles
Create specialized AI agents with custom parameters and roles (like user proxies or critics) for specific tasks.

### Manage Isolated Sessions
Start a clean, blank memory space to run a multi-agent workflow without mixing it up with previous tasks.

### Trace Agent Conversations
Retrieve deep message history, showing every back-and-forth conversation between agents inside the system's logging structure.

### Visualize Workflows
Map out and view the entire graph of agent dependencies and available pre-defined workflow topologies.

### Audit Model Configurations
Review existing constrained fallback LLM settings that the system uses for running agents.

## Use Cases

### Debugging a failed code review loop
A development team's automated process fails because the Coder and Critic agents disagree on an API key format. Instead of guessing, you use `list_messages` to pull the full conversation trace, pinpointing that the failure stemmed from a hard-coded key issue in the original script.

### Running complex market research
A Product Manager needs to run an experimental 'Market Research' workflow. They use `create_session` first, then execute the workflow, allowing the agent group to gather and synthesize data before they even look at a single line of output.

### Validating backend automation steps
An engineer needs to verify that a new payment processing system will handle edge cases. They use `list_skills` to check the available Python functions and then define specialized agents via `create_agent` to simulate the required user roles.

### Analyzing multiple experiments
A researcher runs five different LLM-to-LLM dialogue simulations. By using `list_sessions`, they can quickly retrieve and grade the complete message history from each one without mixing up data or having to restart the process.

## Benefits

- You can define new roles for your agents using the `create_agent` tool. This means you're not just running a generic AI; you're setting up specialized workers like 'Coder' or 'Critic'.
- Need to start fresh? Use `create_session` to build an isolated memory space for multi-agent workflows. Nothing from the previous run can pollute this one.
- The most useful thing is debugging: tools like `list_messages` let you pull deep agent-to-agent traces, showing exactly why a decision was made or where the conversation stalled.
- Don't get lost in complexity; use `list_workflows` to map out all predefined topologies and know what kind of automated process you can run next.
- Keep track of everything with `list_sessions`, giving you a clear overview of every agent group that has been active or completed in the system.

## How It Works

The bottom line is that you control an entire team of specialist AIs from one place.

1. First, subscribe to this MCP and provide your AutoGen Studio instance Base URL.
2. Next, dispatch a request from your AI client—this tells the system which workflow or agent group needs to start.
3. Finally, you get back detailed logs showing every step, message, and decision made by the entire swarm of specialized agents.

## Frequently Asked Questions

**Can my AI agent debug a looping multi-agent conversation?**
Yes. You can instruct your primary agent to retrieve the message traces for a specific AutoGen session ID. It will instantly unpack the internal LLM-to-LLM conversation, highlighting exactly which secondary agent is looping, throwing errors, or deviating from the constraints without manual log parsing.

**How do I add a new Python capability or skill dynamicly?**
Your agent can list currently mapped Python skills bound to the studio runtime. If you need a new capability, your primary AI can iterate on the script directly on your CLI/editor and once deployed in your studio, you can map it natively to customized agents via the creation parameters.

**Can it trigger a Workflow to start executing a new complex task?**
Absolutely. Ask your agent to create a fresh, blank, and completely isolated session, then dispatch a newly constructed 'human message' targeting an existing Multi-Agent workflow topology. It initiates the whole automated logic sequence securely and remotely.

**How do I check the full history of an agent conversation using `list_messages`?**
Yes, it retrieves the complete message trace. You provide a session ID and get every human prompt and every agent-to-agent reply that happened up to this point. This is crucial for debugging why agents made certain decisions.

**When running complex tasks, how do I manage memory boundaries using `create_session` or `delete_session`?**
They are completely isolated from each other. When you call `create_session`, you get a fresh, blank context (a new UUID). Once the task is done, use `delete_session` to permanently wipe that entire history, preventing data bleed between runs.

**How do I see which customized agents are available in my environment using `list_agents`?**
This command provides a manifest of all your defined agent roles. Running `list_agents` shows every specialized entity—like the Coder or Critic—that's ready to participate in a workflow without needing manual setup.

**Are my LLM configurations compatible? How do I audit them using `list_models`?**
You can easily check your current LLM options. Calling `list_models` audits the constrained fallback OpenAI configurations stored in the instance. This confirms exactly which underlying models are attached and ready for use across all workflows.

**Where do I find out what external tools my agents can access? What does `list_skills` show?**
It lists every Python skill function you've injected into the system. This tells your AI client exactly what external capabilities, like database lookups or API calls, are available for your agents to use when they execute a task.