Skip to content

Engineering Agents

This document provides a comprehensive overview of Engineering agents in the ConnectSoft AI Software Factory. It is written for engineers, architects, and platform owners who need to understand how the Factory generates production-ready code.

Engineering agents implement architecture using templates and libraries. They generate code, tests, CI/CD pipelines, and documentation based on architecture blueprints. They act as power users of templates and libraries, not raw code generators—ensuring consistency and quality through reuse.

Tip

Engineering agents generate production-ready code, not prototypes. All code follows Clean Architecture, includes tests, and is ready for deployment. They leverage templates and libraries to ensure consistency and reduce errors.

Engineering Agent Cluster Composition

The Software Engineering cluster consists of 15+ specialized agents organized into sub-clusters:

Developer Role Agents

  • Backend Developer Agent - Implements application logic, services, adapters
  • Frontend Developer Agent - Builds SPAs, UI components, state managers
  • Mobile Developer Agent - Constructs mobile features, device APIs, offline modes
  • Infrastructure Engineer Agent - Generates Helm charts, Bicep, Pulumi, YAML

Generator Agents

  • Microservice Generator Agent - Produces full Clean Architecture microservice skeletons
  • Library Generator Agent - Emits modular, reusable code libraries
  • API Library Generator Agent - Produces strongly-typed API clients from OpenAPI/gRPC
  • API Gateway Generator Agent - Creates gateway configs, routing, CORS/security
  • Adapter Generator Agent - Implements infrastructure ports (repositories, clients)
  • UI Component Library Generator Agent - Generates reusable UI component libraries

Workflow Agents

  • Code Committer Agent - Commits traceable, formatted, validated code
  • Pull Request Creator Agent - Builds PRs with metadata, links, test references
  • Bug Resolver Agent - Responds to alerts, patches defects, validates fixes

Mission and Scope

Engineering agents are responsible for:

  • Implementing Architecture - Converting architecture blueprints into working code
  • Using Templates - Leveraging microservice templates for structure
  • Applying Libraries - Using ConnectSoft libraries for common patterns
  • Generating Artifacts - Creating code, tests, pipelines, and docs
  • Managing Workflows - Handling Git commits, PRs, and bug resolution
  • Generating Infrastructure - Creating IaC, Helm charts, and deployment configs

What They Do: - Generate domain, application, infrastructure, and API code - Create microservices from templates - Implement user stories and features - Generate unit and integration tests - Create CI/CD pipelines - Generate documentation and README files - Integrate with ConnectSoft platforms (Identity, Audit, Config, Bot) - Commit code and create pull requests - Resolve bugs and defects

What They Do NOT Do: - Make architectural decisions (Architect agents) - Define requirements (Vision & Planning agents) - Review code quality (QA agents)

Inputs and Outputs

Inputs

Input Source Description
Architecture Blueprints Architect Agents Bounded contexts, APIs, events
ADRs Architect Agents Architecture decision records
Context Maps Architect Agents Service boundaries and relationships
User Stories Vision & Planning Agents Feature requirements
Templates Template System Microservice and library templates
Libraries Library Catalog ConnectSoft.Extensions.* libraries
Knowledge Knowledge System Previous patterns and solutions

Outputs

Output Consumer Description
Repository Structure QA Agents, DevOps Api, Application, Domain, Infrastructure projects
Domain Code QA Agents Entities, aggregates, domain events
Application Code QA Agents Use cases, handlers, DTOs
Infrastructure Code QA Agents Repositories, external clients, integrations
API Code QA Agents Controllers, endpoints, request/response models
Tests QA Agents Unit tests, integration tests, BDD specs
Pipelines DevOps Agents CI/CD pipeline definitions
Documentation All README, API docs, code comments

Core Capabilities

Template Parameterization

  • Template Selection - Choose appropriate templates for each service
  • Parameter Configuration - Configure template parameters (bounded context, entities, etc.)
  • Template Customization - Customize templates for specific needs
  • Template Versioning - Use correct template versions

Library Application

  • Library Selection - Choose appropriate ConnectSoft libraries
  • Library Integration - Integrate libraries into generated code
  • Version Management - Use compatible library versions
  • Pattern Application - Apply library patterns correctly

Code Generation

  • Domain Layer - Generate entities, aggregates, domain events
  • Application Layer - Generate use cases, handlers, DTOs
  • Infrastructure Layer - Generate repositories, external clients
  • API Layer - Generate controllers, endpoints, models

Git and Azure DevOps Integration

  • Branch Creation - Create feature branches
  • Commit Generation - Generate structured commits
  • PR Creation - Create pull requests
  • Work Item Linking - Link commits to work items

Observability Integration

  • Logging - Add structured logging
  • Tracing - Add distributed tracing
  • Metrics - Add performance metrics
  • Health Checks - Add health check endpoints

Typical Workflows

Workflow: New Service Generation

  1. Receive Blueprint - Get architecture blueprint from Architect agent
  2. Select Template - Choose microservice template
  3. Configure Parameters - Set template parameters (bounded context, entities, etc.)
  4. Generate Structure - Create project structure (Api, Application, Domain, Infrastructure)
  5. Generate Domain Code - Generate entities, aggregates, domain events
  6. Generate Application Code - Generate use cases, handlers
  7. Generate Infrastructure Code - Generate repositories, external clients
  8. Generate API Code - Generate controllers, endpoints
  9. Add Libraries - Integrate ConnectSoft libraries
  10. Generate Tests - Create unit and integration tests
  11. Generate Pipelines - Create CI/CD pipelines
  12. Generate Documentation - Create README and API docs
  13. Commit to Azure DevOps - Push code to repository

Workflow: Existing Service Enhancement

  1. Receive Feature Request - Get feature from Vision/Planning agents
  2. Analyze Current Code - Review existing service structure
  3. Update Domain - Add/update domain entities and events
  4. Update Application - Add/update use cases and handlers
  5. Update Infrastructure - Add/update repositories and integrations
  6. Update API - Add/update endpoints
  7. Update Tests - Add/update tests
  8. Update Pipelines - Update CI/CD if needed
  9. Commit Changes - Push changes to repository

Engineering Agent Collaboration Flow

flowchart TD
    Arch[Architecture Blueprint] --> MicroserviceGen[Microservice Generator Agent]
    MicroserviceGen --> BackendDev[Backend Developer Agent]
    MicroserviceGen --> FrontendDev[Frontend Developer Agent]
    MicroserviceGen --> MobileDev[Mobile Developer Agent]

    BackendDev --> AdapterGen[Adapter Generator Agent]
    FrontendDev --> UIComponentGen[UI Component Generator Agent]

    BackendDev --> InfraEngineer[Infrastructure Engineer Agent]
    FrontendDev --> InfraEngineer
    MobileDev --> InfraEngineer

    BackendDev --> APILibGen[API Library Generator Agent]
    Arch --> APIGatewayGen[API Gateway Generator Agent]

    BackendDev --> CodeCommitter[Code Committer Agent]
    FrontendDev --> CodeCommitter
    MobileDev --> CodeCommitter

    CodeCommitter --> PRCreator[Pull Request Creator Agent]
    PRCreator --> QA[QA Agents]

    QA -->|Bug Found| BugResolver[Bug Resolver Agent]
    BugResolver --> BackendDev

    style Arch fill:#e1f5ff
    style MicroserviceGen fill:#fff4e1
    style CodeCommitter fill:#e8f5e9
    style QA fill:#f3e5f5
Hold "Alt" / "Option" to enable pan & zoom

Visual Flow: Complete Engineering Process

flowchart LR
    A[Architecture Blueprint] --> B[Microservice Generator]
    B --> C[Backend Developer]
    B --> D[Frontend Developer]
    B --> E[Mobile Developer]
    C --> F[Adapter Generator]
    C --> G[API Library Generator]
    D --> H[UI Component Generator]
    C --> I[Infrastructure Engineer]
    C --> J[Code Committer]
    D --> J
    E --> J
    J --> K[Pull Request Creator]
    K --> L[QA Agents]
    L -->|Bugs| M[Bug Resolver]
    M --> C

    style A fill:#e1f5ff
    style B fill:#fff4e1
    style J fill:#e8f5e9
    style L fill:#f3e5f5
Hold "Alt" / "Option" to enable pan & zoom

Collaboration with Other Agents

With Architect Agents

Receive: - Architecture blueprints - ADRs and technical constraints - API and event specifications - Template recommendations

Provide: - Implementation questions - Technical feasibility concerns - Pattern application questions

With QA Agents

Receive: - Code review feedback - Quality violations - Test coverage gaps - Security/compliance issues

Provide: - Code fixes and improvements - Additional tests - Documentation updates

With Vision & Planning Agents

Receive: - User stories and requirements - Feature specifications - Business rules

Provide: - Implementation complexity feedback - Technical blockers - Estimation adjustments

Individual Engineering Agent Details

Developer Role Agents

Backend Developer Agent

Role: Implements application logic, services, and adapters

Responsibilities: - Implement use case handlers and application logic - Create domain services and value objects - Implement input/output ports - Write validators and business rules - Generate domain entities and aggregates - Create API controllers and endpoints

Inputs: - Architecture blueprints - Domain models - API specifications - Use case contracts

Outputs: - Use case handlers - Domain entities and aggregates - API controllers - DTOs and validators

See: Detailed Backend Developer Agent specification in Factory Documentation

Frontend Developer Agent

Role: Builds SPAs, UI components, and state managers

Responsibilities: - Develop SPA components and pages - Create route managers and navigation - Build API connectors and state management - Implement UI logic and interactions - Generate responsive layouts - Create form validations

Inputs: - UI/UX designs - API specifications - Component requirements

Outputs: - React/Vue/Angular components - State management code - API client code - Routing configurations

See: Detailed Frontend Developer Agent specification in Factory Documentation

Mobile Developer Agent

Role: Constructs mobile features, device APIs, and offline modes

Responsibilities: - Build cross-platform mobile views - Implement native device integrations - Create offline sync layers - Handle mobile-specific APIs (camera, GPS, etc.) - Implement push notifications - Create mobile navigation

Inputs: - Mobile app requirements - Device API specifications - Offline requirements

Outputs: - Mobile app code (React Native, Flutter, native) - Device integration code - Offline sync logic - Mobile UI components

See: Detailed Mobile Developer Agent specification in Factory Documentation

Infrastructure Engineer Agent

Role: Generates Helm charts, Bicep, Pulumi, and YAML configurations

Responsibilities: - Generate Infrastructure as Code (IaC) - Create Helm charts for Kubernetes - Generate Bicep/Pulumi templates - Create service mesh configurations - Generate DNS and networking configs - Create secrets and config maps

Inputs: - Infrastructure requirements - Cloud platform constraints - Deployment targets

Outputs: - Helm charts - Bicep/Pulumi templates - Kubernetes manifests - Infrastructure configurations

See: Detailed Infrastructure Engineer Agent specification in Factory Documentation

Generator Agents

Microservice Generator Agent

Role: Produces full Clean Architecture microservice skeletons

Responsibilities: - Generate complete microservice structure - Create Clean Architecture layers (Domain, Application, Infrastructure, API) - Set up dependency injection - Generate solution and project files - Create controller scaffolds - Set up test projects

Inputs: - Architecture blueprint - Bounded context definition - Template selection

Outputs: - Complete microservice scaffold - Project structure - DI configuration - Basic controllers

See: Detailed Microservice Generator Agent specification in Factory Documentation

Library Generator Agent

Role: Emits modular, reusable code libraries

Responsibilities: - Generate shared libraries (logging, DTOs, utilities) - Create domain libraries - Generate validation libraries - Create mapping libraries - Generate observability libraries

Inputs: - Library requirements - Reusability needs

Outputs: - Library projects - NuGet packages - Library documentation

See: Detailed Library Generator Agent specification in Factory Documentation

API Library Generator Agent

Role: Produces strongly-typed API clients from OpenAPI/gRPC contracts

Responsibilities: - Generate API clients from OpenAPI specs - Create gRPC clients - Generate TypeScript/JavaScript clients - Create C# API clients - Generate client documentation

Inputs: - OpenAPI/Swagger specifications - gRPC proto files - Target language requirements

Outputs: - Strongly-typed API clients - Client libraries - API documentation

See: Detailed API Library Generator Agent specification in Factory Documentation

API Gateway Generator Agent

Role: Creates gateway configs, routing, CORS/security enforcement

Responsibilities: - Generate API Gateway configurations - Create routing rules - Set up CORS policies - Configure security policies - Set up rate limiting - Create gateway middleware

Inputs: - API specifications - Routing requirements - Security policies

Outputs: - Gateway configurations - Routing rules - Security policies - Middleware code

See: Detailed API Gateway Generator Agent specification in Factory Documentation

Adapter Generator Agent

Role: Implements infrastructure ports (repositories, clients)

Responsibilities: - Generate repository implementations - Create external API clients - Implement messaging adapters - Generate storage adapters - Create database adapters - Implement caching adapters

Inputs: - Port definitions - Infrastructure requirements - External service contracts

Outputs: - Repository implementations - External client code - Adapter configurations

See: Detailed Adapter Generator Agent specification in Factory Documentation

UI Component Library Generator Agent

Role: Generates reusable UI component libraries

Responsibilities: - Generate UI component libraries - Create design system components - Generate component documentation - Create component tests - Generate Storybook stories

Inputs: - Design system specifications - Component requirements

Outputs: - UI component library - Component documentation - Component tests

See: Detailed UI Component Library Generator Agent specification in Factory Documentation

Workflow Agents

Code Committer Agent

Role: Commits traceable, formatted, validated code

Responsibilities: - Create Git commits with trace IDs - Format commit messages - Validate code before commit - Tag commits with metadata - Prepare clean Git tree for PRs - Support mono-repo and multi-repo structures

Inputs: - Generated code - Trace metadata - Commit requirements

Outputs: - Git commits - Commit metadata - Event: CommitReady

See: Detailed Code Committer Agent specification in Factory Documentation

Pull Request Creator Agent

Role: Builds PRs with metadata, links, test references

Responsibilities: - Create pull requests with structured titles - Attach module diffs and trace references - Include test coverage summaries - Link PRs to work items - Generate PR descriptions - Trigger pipeline evaluation

Inputs: - Committed code - Trace metadata - Work item links

Outputs: - Pull requests - PR metadata - Event: PullRequestCreated

See: Detailed Pull Request Creator Agent specification in Factory Documentation

Bug Resolver Agent

Role: Responds to alerts, patches defects, validates fixes

Responsibilities: - Analyze bug reports and test failures - Generate bug fixes - Apply patches to code - Trigger retests - Document resolution path - Create fix PRs

Inputs: - Bug reports - Test failures - QA feedback

Outputs: - Bug fixes - Fix PRs - Resolution documentation - Event: BugFixed

See: Detailed Bug Resolver Agent specification in Factory Documentation

Engineering Agent Workflow Summary

Phase Agents Involved Output
Scaffolding Microservice Generator Complete service structure
Code Generation Backend/Frontend/Mobile Developer Application code
Infrastructure Adapter Generator, Infrastructure Engineer Adapters and IaC
Libraries Library Generator, API Library Generator Reusable libraries
Commit Code Committer Git commits
PR Creation Pull Request Creator Pull requests
Bug Resolution Bug Resolver Bug fixes

Interaction with Templates and Libraries

Template Usage

Engineering agents use templates as the foundation for all generated code:

  • Microservice Template - Primary template for new services
  • Library Template - For creating shared libraries
  • Infrastructure Template - For IaC and deployment scripts

Template Selection Process: 1. Analyze architecture blueprint 2. Identify required capabilities 3. Select appropriate template 4. Configure template parameters 5. Generate code from template

See: Microservice Template for template details.

Library Integration

Engineering agents integrate ConnectSoft libraries:

  • ConnectSoft.Extensions.Http.OpenIdConnect - OAuth2/OIDC client
  • ConnectSoft.Extensions.Observability - OpenTelemetry integration
  • ConnectSoft.Extensions.Messaging - Event-driven messaging
  • ConnectSoft.Extensions.Compliance - Compliance and redaction

Library Version Management: - Use versions compatible with Technology Stack - Keep versions consistent across services - Update versions when templates update

Tip

Template & Library Reuse Guidelines: - Always use templates for new services—don't generate from scratch - Prefer ConnectSoft libraries over custom implementations - Keep library versions consistent with Technology Stack decisions - Don't modify template structure—extend in your code instead

See: Libraries Catalog for available libraries.

KPIs and Evaluation Criteria

KPI Description How We Measure
Build Success Rate Percentage of generated code that builds successfully Build pipeline success rate
Test Coverage Test coverage of generated code Code coverage metrics
Architectural Compliance Adherence to architectural patterns QA agent compliance checks
Template Usage Use of templates vs custom code Template usage rate
Library Usage Use of ConnectSoft libraries Library integration rate
Time to First Commit Speed from blueprint to first commit Time from blueprint to commit

Risks and Anti-Patterns

Risk 1: Over-Customizing Generated Code

Problem: Modifying generated code in ways that break template upgradability.

Solution: Extend code in separate files. Don't modify template-generated code directly.

Risk 2: Ignoring Observability

Problem: Not adding logging, tracing, or metrics.

Solution: Observability is mandatory. All generated code includes observability hooks.

Risk 3: Ignoring Security

Problem: Not integrating security patterns.

Solution: Security patterns are built into templates. Always use them.

Risk 4: Inconsistent Patterns

Problem: Different services use different patterns.

Solution: Use templates and libraries consistently. Follow standard patterns.

Warning

Common Anti-Patterns: - Modifying Template Code - Don't modify template-generated code directly - Ignoring Libraries - Don't reinvent what libraries provide - Skipping Tests - All code must have tests - Ignoring Observability - Observability is mandatory, not optional - Inconsistent Patterns - Use templates and libraries consistently