Agent System Overview

This document provides a comprehensive overview of the multi-agent system that powers the ConnectSoft AI Software Factory. It is written for architects and engineers understanding how specialized agents collaborate to generate complete SaaS solutions.

The Factory uses a multi-agent system where specialized agents own specific roles across the entire software lifecycle: from vision and planning through architecture, engineering, QA, DevOps, deployment, and post-production optimization. Each agent has clear responsibilities, inputs, and outputs, enabling predictable and safe code generation at scale.

The ConnectSoft Agent System includes 60+ specialized agents organized into 10 agent clusters, covering pre-production, production, and post-production phases of the software lifecycle.

Note

Agent roles map to human roles: Vision & Planning Agents act as Product Managers, Architect Agents act as Solution Architects, Engineering Agents act as Developers, QA Agents act as QA Engineers, DevOps Agents act as DevOps Engineers, and post-production agents handle growth, optimization, and runtime customization. This familiar structure makes the Factory's behavior predictable and understandable.

Agent Categories Overview

The Factory organizes agents into 10 primary categories:

Category	Purpose	Agent Count	Phase
Vision and Product Planning	Transform ideas into structured product visions and plans	4 agents	Pre-Production
Research and UX/UI Design	Create user-centered experiences and design systems	4 agents	Pre-Production
Enterprise and System Architecture	Design scalable, secure system architectures	13+ agents	Pre-Production
Software Engineering	Implement code, generate services, manage workflows	15+ agents	Production
DevOps, Deployment, and Delivery	Automate CI/CD, provision infrastructure, manage releases	4 agents	Production
Security, Compliance, and QA	Ensure quality, security, and compliance	10+ agents	Production
Observability and Monitoring	Monitor systems and provide insights	1 agent	Post-Production
Growth, Marketing, and Customer Success	Optimize growth, marketing, and customer engagement	4 agents	Post-Production
Platform Evolution and Runtime Customization	Enable runtime customization and platform evolution	6+ agents	Post-Production
Documentation and Knowledge Management	Generate documentation and manage knowledge	3 agents	All Phases

Complete Agent System Flow

flowchart TB
    subgraph Vision["Vision and Product Planning"]
        VisionArchitect[Vision Architect]
        ProductManager[Product Manager]
        ProductOwner[Product Owner]
        BusinessAnalyst[Business Analyst]
        VisionArchitect --> ProductManager
        ProductManager --> ProductOwner
        ProductOwner --> BusinessAnalyst
    end

    subgraph Research["Research and UX/UI Design"]
        UXResearcher[User Researcher]
        UXDesigner[UX Designer]
        UIDesigner[UI Designer]
        AccessibilityEngineer[Accessibility Engineer]
        BusinessAnalyst --> UXResearcher
        UXResearcher --> UXDesigner
        UXDesigner --> UIDesigner
        UIDesigner --> AccessibilityEngineer
    end

    subgraph Architecture["Enterprise and System Architecture"]
        EnterpriseArchitect[Enterprise Architect]
        SolutionArchitect[Solution Architect]
        ApplicationArchitect[Application Architect]
        DomainModeler[Domain Modeler]
        EventDrivenArchitect[Event-Driven Architect]
        APIDesigner[API Designer]
        DataArchitect[Data Architect]
        InfrastructureArchitect[Infrastructure Architect]
        NetworkArchitect[Network Architect]
        CloudArchitect[Cloud Architect]
        SecurityArchitect[Security Architect]
        DevOpsArchitect[DevOps Architect]
        TechLead[Tech Lead]
        AccessibilityEngineer --> EnterpriseArchitect
        EnterpriseArchitect --> SolutionArchitect
        SolutionArchitect --> ApplicationArchitect
        ApplicationArchitect --> DomainModeler
        DomainModeler --> EventDrivenArchitect
        EventDrivenArchitect --> APIDesigner
        APIDesigner --> TechLead
    end

    subgraph Engineering["Software Engineering"]
        BackendDeveloper[Backend Developer]
        FrontendDeveloper[Frontend Developer]
        MobileDeveloper[Mobile Developer]
        InfrastructureEngineer[Infrastructure Engineer]
        MicroserviceGenerator[Microservice Generator]
        LibraryGenerator[Library Generator]
        APILibraryGenerator[API Library Generator]
        APIGatewayGenerator[API Gateway Generator]
        AdapterGenerator[Adapter Generator]
        UIComponentGenerator[UI Component Generator]
        CodeCommitter[Code Committer]
        PullRequestCreator[Pull Request Creator]
        BugResolver[Bug Resolver]
        TechLead --> BackendDeveloper
        TechLead --> FrontendDeveloper
        TechLead --> MobileDeveloper
        BackendDeveloper --> CodeCommitter
        FrontendDeveloper --> CodeCommitter
        MobileDeveloper --> CodeCommitter
        CodeCommitter --> PullRequestCreator
        PullRequestCreator --> BugResolver
    end

    subgraph QA["Security, Compliance, and QA"]
        QAEngineer[QA Engineer]
        TestAutomationEngineer[Test Automation Engineer]
        TestGenerator[Test Generator]
        TestCaseGenerator[Test Case Generator]
        TestCoverageValidator[Test Coverage Validator]
        LoadPerformanceTester[Load & Performance Tester]
        ChaosEngineer[Chaos Engineer]
        BugInvestigator[Bug Investigator]
        CodeReviewer[Code Reviewer]
        SecurityEngineer[Security Engineer]
        PrivacyCompliance[Privacy Compliance]
        PenetrationTester[Penetration Tester]
        BugResolver --> QAEngineer
        QAEngineer --> TestAutomationEngineer
        QAEngineer --> TestGenerator
        QAEngineer --> TestCaseGenerator
        TestGenerator --> TestCoverageValidator
        TestCoverageValidator --> CodeReviewer
    end

    subgraph DevOps["DevOps, Deployment, and Delivery"]
        DevOpsEngineer[DevOps Engineer]
        CloudProvisioner[Cloud Provisioner]
        DeploymentOrchestrator[Deployment Orchestrator]
        ReleaseManager[Release Manager]
        CodeReviewer --> ReleaseManager
        ReleaseManager --> DevOpsEngineer
        DevOpsEngineer --> CloudProvisioner
        CloudProvisioner --> DeploymentOrchestrator
    end

    subgraph Observability["Observability and Monitoring"]
        ObservabilityEngineer[Observability Engineer]
        DeploymentOrchestrator --> ObservabilityEngineer
    end

    subgraph Growth["Growth, Marketing, and Customer Success"]
        MarketingSpecialist[Marketing Specialist]
        GrowthStrategist[Growth Strategist]
        ABTestingAgent[A/B Testing Agent]
        CustomerSuccessAgent[Customer Success Agent]
        ObservabilityEngineer --> CustomerSuccessAgent
        CustomerSuccessAgent --> GrowthStrategist
        GrowthStrategist --> MarketingSpecialist
        GrowthStrategist --> ABTestingAgent
    end

    subgraph Evolution["Platform Evolution and Runtime"]
        FeatureToggleManager[Feature Toggle Manager]
        SelfServicePortal[Self-Service Portal Builder]
        LowCodeAPI[Low-Code API Platform]
        Localization[Localization Agent]
        FeedbackEvolution[Feedback Evolution Agent]
        CostOptimization[Cost Optimization Agent]
        ABTestingAgent --> FeedbackEvolution
        FeedbackEvolution --> FeatureToggleManager
        FeedbackEvolution --> SelfServicePortal
        FeedbackEvolution --> LowCodeAPI
        FeedbackEvolution --> CostOptimization
    end

    subgraph Documentation["Documentation and Knowledge"]
        DocumentationWriter[Documentation Writer]
        KnowledgeManagement[Knowledge Management]
        UbiquitousLanguage[Ubiquitous Language]
    end

    DocumentationWriter -.->|Documents| Vision
    DocumentationWriter -.->|Documents| Architecture
    DocumentationWriter -.->|Documents| Engineering
    KnowledgeManagement -.->|Provides Context| Vision
    KnowledgeManagement -.->|Provides Context| Architecture
    KnowledgeManagement -.->|Provides Context| Engineering
    UbiquitousLanguage -.->|Ensures Consistency| Vision
    UbiquitousLanguage -.->|Ensures Consistency| Architecture

Hold "Alt" / "Option" to enable pan & zoom

Agent Types and Responsibilities

The Factory uses specialized agents, each with a specific domain of expertise:

Vision & Planning Agents

Inputs:

• Product ideas and high-level requirements
• Business context and constraints
• Existing system documentation

Outputs:

• Refined product plans
• User stories and epics
• Feature breakdowns
• Product roadmaps

Responsibilities:

• Refine vague requirements into actionable plans
• Break down features into user stories
• Prioritize work based on business value
• Create product documentation

Architect Agents

Inputs:

• Product plans and user stories
• Existing architecture documentation
• Domain knowledge from knowledge system

Outputs:

• Bounded context designs
• API specifications (OpenAPI/Swagger)
• Event schemas and integration contracts
• Architecture Decision Records (ADRs)
• Context maps and system diagrams

Responsibilities:

• Design bounded contexts following DDD principles
• Define APIs and integration points
• Design event-driven architectures
• Ensure architectural consistency
• Document architectural decisions

Engineering Agents

Inputs:

• Architecture blueprints and ADRs
• Microservice templates
• Library references
• Code patterns from knowledge system

Outputs:

• Complete microservice code (Domain, Application, Infrastructure, API layers)
• Unit tests and integration tests
• Code documentation
• Configuration files

Responsibilities:

• Generate code following Clean Architecture
• Implement domain logic and use cases
• Create infrastructure integrations
• Generate API controllers and models
• Write tests for generated code

QA & Validation Agents

Inputs:

• Generated code
• Test specifications
• Quality gates and standards

Outputs:

• Test suites (unit, integration, acceptance)
• BDD specifications
• Quality reports
• Test coverage metrics
• Bug reports and fix suggestions

Responsibilities:

• Generate comprehensive test suites
• Validate code quality and standards
• Run static analysis and linting
• Verify architectural compliance
• Suggest improvements and fixes

DevOps Agents

Inputs:

• Generated microservices
• Infrastructure requirements
• Deployment targets

Outputs:

• CI/CD pipelines (Azure DevOps YAML)
• Infrastructure-as-Code (Bicep templates)
• Kubernetes manifests
• Deployment configurations
• Monitoring and alerting setup

Responsibilities:

• Create CI/CD pipelines
• Generate Infrastructure-as-Code
• Configure deployment targets
• Set up observability (logging, tracing, metrics)
• Create runbooks and operational docs

Research and UX/UI Design Agents

Inputs:

• Product vision and user personas
• Business requirements
• User research data
• Design system guidelines

Outputs:

• User research reports
• UX wireframes and user flows
• UI design systems and component libraries
• Accessibility audits

Responsibilities:

• Conduct user research and create personas
• Design user experiences and interfaces
• Create design systems and component libraries
• Ensure accessibility compliance
• Generate UI component code

See: Research and UX/UI Design Agents for detailed capabilities.

DevOps, Deployment, and Delivery Agents

Inputs:

• Generated code and repositories
• Infrastructure requirements
• Deployment targets
• Release policies

Outputs:

• CI/CD pipelines (Azure DevOps YAML)
• Infrastructure-as-Code (Bicep/Pulumi templates)
• Deployment configurations
• Release approvals
• Deployment summaries

Responsibilities:

• Generate CI/CD pipelines
• Provision cloud infrastructure
• Orchestrate deployments
• Manage release approvals
• Handle rollbacks and recovery

See: DevOps, Deployment, and Delivery Agents for detailed capabilities.

Security and Compliance Agents

Inputs:

• Generated code and configurations
• Compliance requirements
• Security policies
• Threat models

Outputs:

• Security assessments
• Compliance reports
• Penetration test results
• Policy violations and fixes
• Audit trails

Responsibilities:

• Validate security best practices
• Check compliance with regulations (GDPR, HIPAA, SOC2)
• Perform penetration testing
• Generate security documentation
• Suggest security improvements

See: QA Agents for security and compliance agent details.

Observability Agents

Inputs:

• Deployed services
• Monitoring requirements
• SLO definitions

Outputs:

• Observability configurations
• Dashboard definitions
• Alert rules
• Metrics and tracing setup

Responsibilities:

• Configure logging, tracing, and metrics
• Set up monitoring dashboards
• Define alert rules
• Integrate with observability platforms
• Analyze system health

See: Observability Agents for detailed capabilities.

Growth, Marketing, and Customer Success Agents

Inputs:

• Production metrics and user data
• Customer feedback
• Business goals

Outputs:

• Growth strategies
• Marketing campaigns
• A/B test configurations
• Customer success reports

Responsibilities:

• Analyze user engagement and growth metrics
• Design marketing campaigns
• Configure A/B tests and experiments
• Monitor customer success metrics
• Optimize user acquisition and retention

See: Growth, Marketing, and Customer Success Agents for detailed capabilities.

Platform Evolution and Runtime Agents

Inputs:

• Production usage data
• User feedback
• Feature requests
• Cost metrics

Outputs:

• Feature toggle configurations
• Self-service portal implementations
• Low-code API platforms
• Localization configurations
• Cost optimization recommendations

Responsibilities:

• Manage feature toggles and editions
• Build self-service portals
• Create low-code API platforms
• Handle localization and internationalization
• Collect and process user feedback
• Optimize platform costs

See: Platform Evolution and Runtime Agents for detailed capabilities.

Documentation and Knowledge Management Agents

Inputs:

• Generated code and artifacts
• Architecture decisions
• Domain knowledge

Outputs:

• API documentation
• Architecture documentation
• User guides
• Knowledge base entries
• Ubiquitous language dictionaries

Responsibilities:

• Generate documentation throughout lifecycle
• Capture and organize knowledge
• Maintain ubiquitous language consistency
• Create knowledge bases
• Update documentation as systems evolve

See: Documentation and Knowledge Management Agents for detailed capabilities.

Core Agent Capabilities

All agents share core capabilities that enable them to work effectively:

Planning and Task Decomposition

Agents can break down high-level goals into actionable tasks:

• Vision agents decompose product ideas into epics and stories
• Architect agents decompose designs into implementation tasks
• Engineering agents decompose features into code modules

Template and Library Usage

Agents use templates and libraries to ensure consistency:

• Engineering agents use microservice templates for structure
• All agents reference ConnectSoft.Extensions.* libraries
• Templates enforce architectural patterns automatically

Azure DevOps Integration

Agents read and write Azure DevOps artifacts:

• Read: Work items, repositories, pipelines, documentation
• Write: Code commits, work items, pull requests, pipelines
• Update: Existing work items, documentation, configurations

Knowledge and Memory Access

Agents query and store knowledge for pattern reuse:

• Query: Semantic search for similar solutions
• Store: Generated artifacts with metadata
• Learn: Patterns from previous projects
• Reuse: Proven solutions and best practices

Observability and Tracing

All agent actions are observable:

• Correlation IDs track work across agents
• Event logs record all actions
• Metrics track agent performance
• Traces enable debugging and analysis

Agent Lifecycle

Agents follow a structured lifecycle from initialization to completion, with different phases for pre-production, production, and post-production agents:

stateDiagram-v2
    [*] --> Initialized: Agent Created
    Initialized --> Assigned: Task Received
    Assigned --> Planning: Analyze Requirements
    Planning --> Executing: Plan Approved
    Executing --> Validating: Work Complete
    Validating --> Reporting: Validation Pass
    Validating --> Executing: Validation Failed
    Reporting --> PostProduction: Post-Production Agents
    Reporting --> [*]: Task Complete

    Executing --> Error: Exception Occurred
    Error --> Planning: Retry with Fix
    Error --> Reporting: Error Handled

    PostProduction --> Monitoring: Monitor Runtime
    Monitoring --> Optimizing: Optimize Performance
    Optimizing --> Evolving: Evolve Platform
    Evolving --> PostProduction: Continuous Loop

Hold "Alt" / "Option" to enable pan & zoom

Lifecycle Stages:

1. Initialized - Agent created and ready to receive tasks
2. Assigned - Task assigned by orchestrator with context
3. Planning - Agent analyzes requirements and creates execution plan
4. Executing - Agent performs work (generates code, creates artifacts)
5. Validating - Agent validates its own work or QA agent validates
6. Reporting - Agent reports completion and outcomes
7. Post-Production - Post-production agents monitor, optimize, and evolve systems
8. Error - Error occurred, agent handles or retries

Factory Orchestrator and Agent Coordination

The Factory Orchestrator coordinates all agents and manages workflows:

Orchestrator Responsibilities

• Task Assignment - Assigns tasks to appropriate agents based on type and availability
• Dependency Management - Ensures tasks execute in correct order (e.g., architecture before engineering)
• Workflow Coordination - Manages multi-agent workflows and handoffs
• Error Handling - Handles failures, retries, and escalation
• Progress Tracking - Monitors agent progress and overall workflow status

Coordination Patterns

The orchestrator uses several coordination patterns:

flowchart TD
    INPUT[Product Requirements] --> ORCH[Factory Orchestrator]

    ORCH -->|1. Assign| VP[Vision & Planning Agent]
    VP -->|Product Plan| ORCH

    ORCH -->|2. Assign| AA[Architect Agent]
    AA -->|Blueprints| ORCH

    ORCH -->|3. Assign in Parallel| EA1[Engineering Agent 1]
    ORCH -->|3. Assign in Parallel| EA2[Engineering Agent 2]
    EA1 -->|Code| ORCH
    EA2 -->|Code| ORCH

    ORCH -->|4. Assign| QA[QA Agent]
    QA -->|Test Results| ORCH

    ORCH -->|5. Assign| DA[DevOps Agent]
    DA -->|Infrastructure| ORCH

    ORCH -->|Final Artifacts| ADO[Azure DevOps]

    style ORCH fill:#2563EB,color:#fff
    style ADO fill:#10B981,color:#fff

Hold "Alt" / "Option" to enable pan & zoom

Sequential Coordination:

• Vision → Architect → Engineering (must happen in order)
• Each stage depends on previous stage's outputs

Parallel Coordination:

• Multiple Engineering agents can work on different microservices simultaneously
• QA agents can validate multiple services in parallel

Review Loops:

• QA agents can request fixes from Engineering agents
• Architect agents can review Engineering outputs
• Orchestrator manages retry loops and iterations

Retry and Error Handling

The orchestrator handles errors gracefully:

• Retries - Failed tasks are retried with exponential backoff
• Escalation - Critical failures escalate to human review
• Compensation - Rollback mechanisms for partial failures
• Logging - All errors logged with full context for debugging

Example: End-to-End Run with Agents

Here's how agents collaborate in a typical generation run:

Scenario: Customer wants a new "Billing" bounded context for their SaaS platform.

1. Vision & Planning Agent receives the requirement:

   • Refines "Billing" into specific features: subscriptions, invoices, payments
   • Creates user stories: "As a customer, I want to view my invoices..."
   • Outputs: Product plan with epics and stories

2. Architect Agent receives the product plan:

   • Designs Billing bounded context with aggregates (Subscription, Invoice, Payment)
   • Defines APIs: GET /invoices, POST /payments, etc.
   • Designs events: InvoiceCreated, PaymentProcessed
   • Outputs: Architecture blueprint, ADR, OpenAPI spec

3. Engineering Agent receives the blueprint:

   • Generates Billing microservice using microservice template
   • Implements Subscription, Invoice, Payment aggregates
   • Creates use cases: CreateInvoice, ProcessPayment
   • Generates API controllers and models
   • Outputs: Complete microservice code

4. QA Agent receives the generated code:

   • Generates unit tests for domain logic
   • Generates integration tests for APIs
   • Generates acceptance tests for user stories
   • Validates code quality and standards
   • Outputs: Test suites and quality report

5. DevOps Agent receives the microservice:

   • Creates Azure DevOps pipeline (build, test, deploy)
   • Generates Bicep templates for Azure resources
   • Configures monitoring and alerting
   • Outputs: CI/CD pipeline and infrastructure code

6. Orchestrator commits all artifacts to Azure DevOps:

   • Creates repository for Billing microservice
   • Commits code, tests, pipelines, documentation
   • Creates work items linked to code
   • Updates project documentation

Result: Complete, production-ready Billing microservice with tests, infrastructure, and documentation in customer's Azure DevOps.

Post-Production Agents

Unlike traditional software factories that stop at deployment, ConnectSoft includes post-production agents that continue to work after code is deployed to production. These agents enable continuous optimization, growth, and platform evolution.

Post-Production Agent Categories

Observability and Monitoring:

• Observability Engineer Agent - Monitors system health, configures alerts, analyzes metrics

Growth, Marketing, and Customer Success:

• Marketing Specialist Agent - Designs and executes marketing campaigns
• Growth Strategist Agent - Analyzes growth metrics and optimizes user acquisition
• A/B Testing and Experimentation Agent - Configures and analyzes experiments
• Customer Success Agent - Monitors customer satisfaction and engagement

Platform Evolution and Runtime Customization:

• Feature Toggle and Edition Manager Agent - Manages feature flags and product editions
• Self-Service Portal Builder Agent - Creates self-service portals for users
• Low-Code API Platform Agent - Enables low-code API creation and customization
• Localization and Internationalization Agent - Handles multi-language support
• Feedback and Evolution Agent - Collects and processes user feedback
• Platform Cost Optimization Agent - Optimizes infrastructure and operational costs

Post-Production Workflows

Post-production agents operate in continuous loops:

1. Monitor - Observability agents monitor system health and user behavior
2. Analyze - Growth and Customer Success agents analyze metrics and feedback
3. Optimize - Agents optimize performance, costs, and user experience
4. Evolve - Platform Evolution agents implement runtime customizations
5. Feedback Loop - Insights feed back to Vision & Planning agents for future iterations

Benefits of Post-Production Agents

• Continuous Optimization - Systems improve automatically based on real usage
• Growth Acceleration - Marketing and growth agents optimize user acquisition
• Cost Efficiency - Cost optimization agents reduce infrastructure spend
• User-Centric Evolution - Feedback agents ensure systems evolve based on user needs
• Runtime Customization - Self-service and low-code agents enable user customization

See: Observability Agents for monitoring capabilities See: Growth, Marketing, and Customer Success Agents for growth optimization See: Platform Evolution and Runtime Agents for runtime customization

Related Documents

• Agent Execution Flow - Detailed workflow from prompt to production
• Agent Collaboration Patterns - Patterns for agent interactions
• Knowledge & Memory System - How agents learn and improve
• Factory Overview - High-level Factory architecture

Agent Category Overviews

• Vision & Planning Agents - Product vision and planning (4 agents)
• Research and UX/UI Design Agents - User research and design (4 agents)
• Architect Agents - System architecture (13+ agents)
• Engineering Agents - Code generation and implementation (15+ agents)
• DevOps, Deployment, and Delivery Agents - CI/CD and deployment (4 agents)
• QA Agents - Quality assurance, security, and compliance (10+ agents)
• Observability Agents - Monitoring and observability (1 agent)
• Growth, Marketing, and Customer Success Agents - Growth optimization (4 agents)
• Platform Evolution and Runtime Agents - Runtime customization (6+ agents)
• Documentation and Knowledge Management Agents - Documentation and knowledge (3 agents)