Skip to content

AUTOGEN_ARCHITECTURE.md

Latest commit

 

History

History
421 lines (335 loc) · 14.4 KB

AUTOGEN_ARCHITECTURE.md

File metadata and controls

421 lines (335 loc) · 14.4 KB

Launchonomy AutoGen Architecture Guide

🎯 Overview

This document explains our strategic approach to using AutoGen v0.4, what we leverage from the framework, what we've built custom, and the architectural reasoning behind these decisions.

📋 Table of Contents

  1. What We Use From AutoGen
  2. What We Don't Use From AutoGen
  3. Our Custom Architecture
  4. Strategic Reasoning
  5. Integration Points
  6. Future Considerations

🔧 What We Use From AutoGen

Core Infrastructure (✅ Used)

1. Model Client Management

from autogen_ext.models.openai import OpenAIChatCompletionClient

# We use AutoGen's enhanced OpenAI client for:
enhanced_client = EnhancedOpenAIClient(
    monitor=monitor,
    api_key=api_key,
    model=model_name,
    timeout=60.0,        # Built-in timeout handling
    max_retries=3,       # Automatic retry logic
    retry_delay=1.0      # Exponential backoff
)

Why We Use This:

  • ✅ Robust Error Handling: Built-in retry logic for rate limits and timeouts
  • ✅ Connection Pooling: Better performance through connection reuse
  • ✅ Standardized Token Tracking: Consistent usage monitoring
  • ✅ Future-Proof: Stays updated with OpenAI API changes

2. Message Types & Standards

from autogen_core.models import SystemMessage, UserMessage

# We use AutoGen's standardized message types for:
messages = [
    SystemMessage(content=system_prompt, source="system"),
    UserMessage(content=user_prompt, source="user")
]

Why We Use This:

  • ✅ Standardization: Consistent message format across all agents
  • ✅ Conversation History: Proper message threading and context
  • ✅ Interoperability: Compatible with AutoGen ecosystem
  • ✅ Type Safety: Better error detection and IDE support

3. Base Agent Framework

from autogen_core import RoutedAgent

class OrchestrationAgent(RoutedAgent):
    def __init__(self, client):
        super().__init__(SYSTEM_PROMPT)
        self._client = client

Why We Use This:

  • ✅ Foundation: Solid base for agent implementation
  • ✅ Client Integration: Seamless model client integration
  • ✅ Extensibility: Easy to add custom behavior on top

❌ What We Don't Use From AutoGen

High-Level Orchestration (❌ Not Used)

1. AutoGen Teams/Selector

# We DON'T use:
# - Teams
# - Selector
# - Built-in orchestration patterns

Why We Don't Use This:

  • ❌ Too Generic: Doesn't support our C-Suite consensus model
  • ❌ Limited Business Logic: Can't handle complex business workflows
  • ❌ No State Management: Lacks persistent mission state
  • ❌ No Financial Controls: Missing budget and cost management
  • ❌ No Human-in-Loop: Can't handle approval workflows

2. AutoGen State Management

# We DON'T use:
# - Built-in state containers
# - AutoGen's state serialization
# - Default conversation persistence

Why We Don't Use This:

  • ❌ Business Context Missing: Doesn't understand missions, cycles, budgets
  • ❌ No Resume Capability: Can't resume complex business operations
  • ❌ Limited Analytics: No cost tracking, KPI monitoring
  • ❌ No Audit Trail: Missing detailed decision logging

3. AutoGen GraphFlow/DSL

# We DON'T use:
# - GraphFlow for workflow definition
# - Built-in DSL patterns
# - Predefined conversation flows

Why We Don't Use This:

  • ❌ Business Workflow Mismatch: Doesn't match C-Suite → Specialist → Execution pattern
  • ❌ No Dynamic Agent Creation: Can't create specialists on-demand
  • ❌ Limited Review Process: No peer review and consensus mechanisms
  • ❌ No Tool Integration: Missing business tool orchestration

🏗️ Our Custom Architecture

1. C-Suite Consensus Orchestration

What We Built:

class OrchestrationAgent(RoutedAgent):
    async def _conduct_csuite_planning(self, strategic_csuite, mission_context, loop_results, cycle_log):
        """Custom C-Suite strategic planning session."""
        # Get input from CEO, CTO, CFO, CRO agents
        # Synthesize consensus on strategic direction
        # Allocate budget and resources
        # Set iteration priorities

Why We Built This:

  • 🎯 Business Realism: Mirrors real C-Suite decision-making
  • 🎯 Strategic Oversight: High-level business strategy coordination
  • 🎯 Resource Allocation: Budget and priority management
  • 🎯 Risk Management: Multiple perspectives on decisions

2. Mission State Management

What We Built:

@dataclass
class OverallMissionLog:
    mission_id: str
    overall_mission: str
    final_status: str
    total_mission_cost: float
    decision_cycles_summary: List[Dict[str, Any]]
    created_agents: List[str]
    current_decision_focus: Optional[str]
    kpi_outcomes: Dict[str, Any]
    retrospective_analysis: Dict[str, Any]

Why We Built This:

  • 🎯 Business Continuity: Resume complex missions across sessions
  • 🎯 Cost Tracking: Monitor spending and ROI
  • 🎯 Audit Trail: Complete decision history for compliance
  • 🎯 Performance Analytics: KPI tracking and retrospective analysis

3. Dynamic Agent Provisioning

What We Built:

class AgentManager:
    async def create_specialized_agent(self, decision, agent_management_logs, json_parsing_logs, communicator):
        """Create specialist agents on-demand based on business needs."""
        # Analyze decision requirements
        # Design specialist agent specification
        # Create and register new agent
        # Add to mission context

Why We Built This:

  • 🎯 Adaptive Expertise: Create specialists as business needs emerge
  • 🎯 Cost Efficiency: Only create agents when needed
  • 🎯 Domain Knowledge: Specialists with focused expertise
  • 🎯 Scalability: Unlimited specialist creation capability

4. Workflow Agent Integration

What We Built:

class WorkflowAgent(ABC):
    @abstractmethod
    async def execute(self, task_description: str, context: Dict[str, Any]) -> WorkflowOutput:
        """Execute business workflow with standardized output."""
        
# Specialized workflow agents:
# - ScanAgent: Market analysis and opportunity detection
# - DeployAgent: MVP deployment and infrastructure
# - CampaignAgent: Customer acquisition campaigns
# - AnalyticsAgent: Performance tracking and optimization
# - FinanceAgent: Budget management and financial controls
# - GrowthAgent: Scaling and optimization strategies

Why We Built This:

  • 🎯 Business Operations: Real business workflow execution
  • 🎯 Tool Integration: Connect to external business tools
  • 🎯 Standardized Output: Consistent workflow results
  • 🎯 Human Oversight: Approval gates for critical operations

5. Peer Review & Consensus System

What We Built:

class ReviewManager:
    async def batch_peer_review(self, subject_agent_name, content_to_review, available_agents, review_logs, json_logs, final=False):
        """Coordinate peer reviews with consensus checking."""
        # Get reviews from multiple agents
        # Check for consensus
        # Provide detailed feedback
        # Support revision cycles

Why We Built This:

  • 🎯 Quality Assurance: Multiple agent validation of decisions
  • 🎯 Risk Mitigation: Catch errors before execution
  • 🎯 Collective Intelligence: Leverage diverse agent perspectives
  • 🎯 Continuous Improvement: Learn from review feedback

6. Enhanced Communication Layer

What We Built:

class EnhancedAgentCommunicator:
    def __init__(self):
        self.conversation_histories: Dict[str, List] = {}
        
    async def ask_agent(self, agent, prompt, include_history=False):
        """Enhanced communication with conversation context."""
        # Manage conversation history
        # Handle JSON parsing with retries
        # Track costs and tokens
        # Provide structured error handling

Why We Built This:

  • 🎯 Context Awareness: Maintain conversation history per agent
  • 🎯 Reliability: Robust JSON parsing with retries
  • 🎯 Cost Tracking: Monitor communication costs
  • 🎯 Error Recovery: Graceful handling of communication failures

🧠 Strategic Reasoning

Why This Hybrid Approach?

1. Business Domain Expertise

  • AutoGen: Provides excellent technical infrastructure
  • Our Custom Layer: Adds business logic and domain knowledge
  • Result: Technical robustness + Business intelligence

2. Flexibility vs. Structure

  • AutoGen: Handles low-level communication and model management
  • Our Custom Layer: Implements business-specific workflows and decision patterns
  • Result: Flexible foundation + Structured business processes

3. Future-Proofing

  • AutoGen: Keeps us updated with latest AI/ML advances
  • Our Custom Layer: Protects our business logic from framework changes
  • Result: Innovation adoption + Business continuity

4. Maintainability

  • AutoGen: Reduces code we need to maintain for basic functionality
  • Our Custom Layer: Focused on business value, not infrastructure
  • Result: Less maintenance overhead + More business focus

🔗 Integration Points

How Our Custom Architecture Integrates with AutoGen

1. Client Integration

# AutoGen provides the client
client = OpenAIChatCompletionClient(...)

# We enhance it with business monitoring
enhanced_client = EnhancedOpenAIClient(monitor=monitor, ...)

# Our orchestrator uses the enhanced client
orchestrator = OrchestrationAgent(client=enhanced_client)

2. Message Flow

# AutoGen message types
messages = [SystemMessage(...), UserMessage(...)]

# Our communication layer adds business context
response = await communicator.ask_agent(agent, prompt, include_history=True)

# Our orchestrator processes business logic
decision = await orchestrator.make_strategic_decision(response)

3. Agent Lifecycle

# AutoGen base agent
class SpecialistAgent(RoutedAgent):
    def __init__(self, system_prompt):
        super().__init__(system_prompt)

# Our agent manager handles business lifecycle
agent = await agent_manager.create_specialized_agent(business_need)

# Our orchestrator coordinates business workflows
result = await orchestrator.execute_business_cycle(agent)

🔮 Future Considerations

What We Might Adopt from AutoGen

1. Streaming Responses (When Needed)

# Future: For real-time user interfaces
async for chunk in client.stream(messages):
    update_ui(chunk)

2. Enhanced Tool Calling (If We Add More Tools)

# Future: For complex tool orchestration
tools = [spreadsheet_tool, crm_tool, analytics_tool]
response = await client.create_with_tools(messages, tools)

3. Better Async Patterns (For High Concurrency)

# Future: For handling multiple missions simultaneously
async with AsyncTaskGroup() as group:
    for mission in active_missions:
        group.create_task(process_mission(mission))

What We'll Keep Custom

1. C-Suite Consensus (Core Business Logic)

  • Too specific to our business model
  • Requires deep domain knowledge
  • Critical competitive advantage

2. Mission State Management (Business Continuity)

  • Complex business state requirements
  • Audit and compliance needs
  • Custom analytics and reporting

3. Workflow Integration (Business Operations)

  • Specific to our business tools
  • Custom approval processes
  • Domain-specific optimizations

📊 Architecture Summary

AutoGen Layer (Foundation)

┌─────────────────────────────────────────┐
│           AutoGen v0.4 Core             │
├─────────────────────────────────────────┤
│ • OpenAIChatCompletionClient            │
│ • RoutedAgent base class                │
│ • SystemMessage/UserMessage types       │
│ • Connection pooling & retry logic      │
│ • Token tracking & error handling       │
└─────────────────────────────────────────┘

Our Custom Layer (Business Logic)

┌─────────────────────────────────────────┐
│        Launchonomy Business Layer       │
├─────────────────────────────────────────┤
│ • C-Suite Consensus Orchestration       │
│ • Mission State & Resume Capability     │
│ • Dynamic Agent Provisioning            │
│ • Workflow Agent Integration            │
│ • Peer Review & Quality Assurance       │
│ • Cost Tracking & Budget Management     │
│ • Human-in-Loop Approval Processes      │
│ • Business Analytics & KPI Tracking     │
└─────────────────────────────────────────┘

Integration Benefits

  • ✅ Technical Robustness: AutoGen handles infrastructure
  • ✅ Business Intelligence: Our layer adds domain expertise
  • ✅ Maintainability: Clear separation of concerns
  • ✅ Future-Proof: Can adopt new AutoGen features selectively
  • ✅ Competitive Advantage: Custom business logic remains proprietary

🎯 Conclusion

Our architecture strategically leverages AutoGen v0.4 for what it does best (technical infrastructure) while building custom solutions for our unique business requirements (C-Suite orchestration, mission management, workflow integration).

This hybrid approach gives us:

  • Best of Both Worlds: Technical excellence + Business domain expertise
  • Flexibility: Can evolve both layers independently
  • Competitive Advantage: Unique business capabilities
  • Future-Ready: Foundation for adopting new AI advances

The result is a sophisticated autonomous business system that combines the robustness of AutoGen with the intelligence of custom business logic.