playbooks

home / skills / a5c-ai / babysitter / autogen-setup

autogen-setup skill

/plugins/babysitter/skills/babysit/process/specializations/ai-agents-conversational/skills/autogen-setup

This skill configures AutoGen agents and orchestrates multi-agent conversations, enabling reliable autonomous planning and human-in-the-loop workflows.

npx playbooks add skill a5c-ai/babysitter --skill autogen-setup

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
1.2 KB
---
name: autogen-setup
description: Microsoft AutoGen multi-agent configuration for conversational AI systems
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash
  - Glob
  - Grep
---

# AutoGen Setup Skill

## Capabilities

- Configure AutoGen agents (AssistantAgent, UserProxyAgent)
- Set up agent conversations and group chats
- Implement code execution capabilities
- Design human-in-the-loop patterns
- Configure nested agent architectures
- Implement custom reply functions

## Target Processes

- multi-agent-system
- autonomous-task-planning

## Implementation Details

### Agent Types

1. **AssistantAgent**: LLM-powered assistant
2. **UserProxyAgent**: Human proxy with code execution
3. **GroupChatManager**: Multi-agent orchestration
4. **ConversableAgent**: Base class for custom agents

### Configuration Options

- LLM configuration (models, temperatures)
- Code execution settings
- Human input mode
- Max consecutive auto-replies
- Function calling configuration

### Patterns

- Two-agent conversations
- Group chats with selection
- Nested conversations
- Teachable agents

### Best Practices

- Proper termination conditions
- Safe code execution sandboxing
- Clear agent system messages
- Monitor conversation flow

### Dependencies

- pyautogen

Overview

This skill configures Microsoft AutoGen multi-agent setups for conversational AI systems, enabling deterministic, resumable orchestration of agent workflows. It provides ready patterns for assistant and user-proxy agents, group chats, nested architectures, and safe code execution. The skill focuses on practical configuration options and human-in-the-loop designs to build robust, auditable agent systems.

How this skill works

The skill defines agent classes (AssistantAgent, UserProxyAgent, ConversableAgent) and a GroupChatManager to orchestrate multi-agent conversations. It exposes LLM settings, code execution controls, reply limits, and function-calling hooks so you can tune behavior and safety. You wire agents into two-agent, group, or nested conversation patterns and apply termination and sandboxing policies for reliable operation.

When to use it

  • Building deterministic multi-agent conversational workflows that must resume after interruption.
  • Coordinating assistants and human proxies for tasks requiring code execution or approval.
  • Running teachable agents that refine behavior through staged conversations.
  • Orchestrating group chat scenarios where role selection and turn-taking are required.
  • Implementing nested agent patterns for hierarchical task decomposition.

Best practices

  • Define explicit termination conditions and max consecutive auto-replies to avoid runaway loops.
  • Sandbox any code execution and restrict available libraries and I/O for safety.
  • Provide clear, concise system messages to each agent to align roles and expectations.
  • Monitor conversation flow and log state transitions for auditing and resumability.
  • Tune LLM temperature and function-calling settings based on task determinism needs.

Example use cases

  • A developer assistant (AssistantAgent) proposes code changes and a UserProxyAgent executes tests in a sandboxed environment.
  • A group-managed design review where multiple specialist agents provide perspectives and a manager agent consolidates decisions.
  • A teachable on-call agent that escalates complex incidents to human operators while logging resolution steps.
  • An autonomous task planner that decomposes goals into subtasks handled by nested agents and reports progress to a human overseer.

FAQ

Can agents execute arbitrary code?

Code execution is supported but must be sandboxed and explicitly configured. Limit available modules and enforce time and resource caps.

How do I keep conversations resumable?

Persist conversation state, agent roles, and pending actions. Use deterministic LLM settings and record system messages to reproduce context on restart.