AutoGen vs MetaGPT: Software Development Agents Compared

import autogen

llm_config = {
    "config_list": [{"model": "gpt-4o", "api_key": "your-key"}],
    "temperature": 0.1
}

# Define specialist agents
product_manager = autogen.AssistantAgent(
    name="Product_Manager",
    llm_config=llm_config,
    system_message="""You are a senior product manager. Given a feature request, you:
    1. Clarify requirements by asking specific questions
    2. Write user stories in 'As a [user], I want [feature], so that [benefit]' format
    3. Define acceptance criteria for each story
    4. Flag any technical constraints or risks
    Reply DONE when requirements are complete."""
)

software_architect = autogen.AssistantAgent(
    name="Software_Architect",
    llm_config=llm_config,
    system_message="""You are a software architect. Given requirements, you:
    1. Design the high-level architecture (modules, data flow, APIs)
    2. Choose appropriate tech stack with justification
    3. Define data models and API contracts
    4. Identify potential bottlenecks or scaling concerns
    Use diagrams in text format when helpful."""
)

senior_engineer = autogen.AssistantAgent(
    name="Senior_Engineer",
    llm_config=llm_config,
    system_message="""You are a senior software engineer. You write production-quality code:
    - Clean, well-commented Python/TypeScript/whatever is appropriate
    - Error handling for all edge cases
    - Tests alongside implementation
    - Follow the architecture decisions from the architect
    Always write complete, runnable code."""
)

qa_engineer = autogen.AssistantAgent(
    name="QA_Engineer",
    llm_config=llm_config,
    system_message="""You are a QA engineer. You review code and tests:
    1. Check for logic errors and edge cases
    2. Verify error handling is complete
    3. Add missing test cases
    4. Flag security concerns
    Reply APPROVED when code meets quality standards."""
)

# User proxy with code execution
developer_proxy = autogen.UserProxyAgent(
    name="Developer",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=20,
    code_execution_config={
        "work_dir": "autogen_project",
        "use_docker": False
    },
    is_termination_msg=lambda x: "APPROVED" in x.get("content", "") 
                                  and "QA" in x.get("name", "")
)

# Group chat for collaborative development
groupchat = autogen.GroupChat(
    agents=[developer_proxy, product_manager, software_architect, 
            senior_engineer, qa_engineer],
    messages=[],
    max_round=30,
    speaker_selection_method="auto"
)

manager = autogen.GroupChatManager(
    groupchat=groupchat,
    llm_config=llm_config
)

# Kick off development
developer_proxy.initiate_chat(
    manager,
    message="""Build a REST API for a task management system with:
    - CRUD operations for tasks
    - User authentication (JWT)
    - Task assignment and status tracking
    - FastAPI + SQLAlchemy + PostgreSQL
    
    Produce complete, runnable code. QA should approve before we finish."""
)

pip install metagpt

import asyncio
from metagpt.software_company import SoftwareCompany
from metagpt.roles import ProjectManager, ProductManager, Architect, Engineer, QaEngineer

async def build_with_metagpt(requirement: str, output_dir: str = "metagpt_project"):
    """Run MetaGPT's full software development workflow."""
    
    company = SoftwareCompany()
    
    # Hire the team — each role has a pre-configured system prompt
    company.hire([
        ProductManager(),
        Architect(),
        ProjectManager(),
        Engineer(n_borg=3),  # 3 parallel engineers for faster code generation
        QaEngineer()
    ])
    
    # Set investment (controls how much computation to spend)
    company.invest(3.0)  # $3 budget
    
    # Run development
    await company.start_project(requirement)
    
    return output_dir

# Simple invocation
asyncio.run(build_with_metagpt(
    "Build a command-line todo app with SQLite storage, "
    "supporting add, list, complete, and delete operations"
))

metagpt_project/
  docs/
    prd.md              # Product Requirements Document
    system_design.md    # Architecture document
    api_spec.md         # API contracts
    data_api_design.md  # Data model design
  resources/
    class_diagram.png   # UML class diagram
    sequence_diagram.png
  todo_cli/
    __init__.py
    main.py             # Entry point
    models.py           # Data models
    database.py         # SQLite connection
    commands.py         # CLI commands
  tests/
    test_main.py        # Unit tests
    test_database.py
  requirements.txt
  README.md

# This is roughly what MetaGPT does internally — simplified
class MetaGPTWorkflow:
    """Simplified MetaGPT-style workflow for illustration."""
    
    def __init__(self, llm_client):
        self.llm = llm_client
        self.artifacts = {}
    
    async def run(self, requirement: str) -> dict:
        """Execute the full development pipeline."""
        
        # Stage 1: Product Manager writes PRD
        print("ProductManager: Writing PRD...")
        self.artifacts["prd"] = await self._product_manager_step(requirement)
        
        # Stage 2: Architect designs system
        print("Architect: Designing architecture...")
        self.artifacts["design"] = await self._architect_step(self.artifacts["prd"])
        
        # Stage 3: Project Manager creates tasks
        print("ProjectManager: Creating task breakdown...")
        self.artifacts["tasks"] = await self._pm_step(
            self.artifacts["prd"], 
            self.artifacts["design"]
        )
        
        # Stage 4: Engineers write code (parallelizable)
        print("Engineers: Writing code...")
        self.artifacts["code"] = await self._engineer_step(
            self.artifacts["design"],
            self.artifacts["tasks"]
        )
        
        # Stage 5: QA reviews and tests
        print("QaEngineer: Writing tests and reviewing...")
        self.artifacts["tests"] = await self._qa_step(
            self.artifacts["code"],
            self.artifacts["prd"]
        )
        
        return self.artifacts
    
    async def _product_manager_step(self, requirement: str) -> str:
        prompt = f"""You are a Product Manager. Write a PRD for:
        {requirement}
        
        Include: Goals, User Stories, Requirements, Success Metrics, Constraints"""
        
        response = self.llm.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.2
        )
        return response.choices[0].message.content
    
    # ... similar methods for each stage

# MetaGPT sweet spot — concise, well-defined requirement
asyncio.run(build_with_metagpt(
    "Build a REST API that accepts a URL, stores it in Redis with a short key, "
    "and redirects short URLs to originals. FastAPI + Redis. Include rate limiting."
))

# MetaGPT struggles — too vague or domain-specific
asyncio.run(build_with_metagpt(
    "Build a trading algorithm that processes real-time market data and executes orders"
    # This needs human domain expertise MetaGPT doesn't have
))

import asyncio
import autogen

async def combined_approach(requirement: str):
    """Use MetaGPT for architecture, AutoGen for refinement."""
    
    # Step 1: MetaGPT generates initial structure and documentation
    print("Running MetaGPT for initial architecture and code...")
    from metagpt.software_company import SoftwareCompany
    from metagpt.roles import ProductManager, Architect, ProjectManager, Engineer
    
    company = SoftwareCompany()
    company.hire([ProductManager(), Architect(), ProjectManager(), Engineer()])
    company.invest(2.0)
    await company.start_project(requirement)
    
    # Step 2: Read MetaGPT's output
    import os
    generated_code = []
    for root, dirs, files in os.walk("workspace"):
        for file in files:
            if file.endswith(".py"):
                with open(os.path.join(root, file)) as f:
                    generated_code.append(f"# {file}\n{f.read()}")
    
    code_context = "\n\n".join(generated_code[:5])  # First 5 files
    
    # Step 3: AutoGen refines and extends
    llm_config = {"config_list": [{"model": "gpt-4o", "api_key": "your-key"}]}
    
    refiner = autogen.AssistantAgent(
        name="Code_Refiner",
        llm_config=llm_config,
        system_message="You review and improve generated code for production readiness."
    )
    
    user_proxy = autogen.UserProxyAgent(
        name="Developer",
        human_input_mode="TERMINATE",
        code_execution_config={"work_dir": "refined_project", "use_docker": False}
    )
    
    user_proxy.initiate_chat(
        refiner,
        message=f"""Review and improve this MetaGPT-generated code:
        
{code_context}

Add:
1. Comprehensive error handling
2. Logging
3. Input validation
4. Environment variable configuration
5. Additional edge case tests"""
    )

asyncio.run(combined_approach(
    "Build a URL shortener with FastAPI, Redis, and PostgreSQL"
))