• factory
• ai-agents
• architecture
• ddd

---

Architect Agents

This document provides a comprehensive overview of Architect agents in the ConnectSoft AI Software Factory. It is written for architects, engineers, and platform owners who need to understand how the Factory designs system architecture and bounded contexts.

Architect agents translate Vision & Planning outputs into architecture blueprints. They decide on bounded contexts, service boundaries, APIs, events, and technical patterns. They operate before heavy code generation, ensuring that Engineering agents have clear architectural guidance.

Important

Architect agents enforce architectural constraints that make agent generation safe. They define bounded contexts, APIs, and events that Engineering agents then implement. Without clear architecture, code generation becomes unpredictable.

Architect Agent Cluster Composition

The Enterprise and System Architecture cluster consists of 13+ specialized architect agents organized into sub-clusters:

Enterprise Architecture Sub-Cluster

• Enterprise Architect Agent - Strategic IT planning and enterprise-wide architecture
• Solution Architect Agent - Designing specific solutions for business needs
• Tech Lead Agent - Technical leadership and engineering coordination

Domain and Application Architecture Sub-Cluster

• Application Architect Agent - Software application design and architecture
• Domain Modeler Agent - Domain modeling and DDD implementation
• Event-Driven Architect Agent - Event-driven architecture design
• API Designer Agent - API design and contract definition

Infrastructure Architecture Sub-Cluster

• Infrastructure Architect Agent - IT infrastructure design (servers, storage, networking)
• Cloud Architect Agent - Cloud-native architecture and cloud migration
• Network Architect Agent - Network infrastructure design
• DevOps Architect Agent - CI/CD pipeline and automation architecture

Data and Security Architecture Sub-Cluster

• Data Architect Agent - Data architecture, governance, and integration
• Security Architect Agent - Security architecture and compliance

Mission and Scope

Architect agents are responsible for:

• Translating Vision to Architecture - Converting product visions into technical architecture
• Defining Bounded Contexts - Establishing domain boundaries and service boundaries
• Designing Integration Contracts - Defining APIs, events, and data contracts
• Making Technical Decisions - Choosing patterns, technologies, and approaches
• Ensuring Enterprise Alignment - Aligning solutions with enterprise architecture
• Designing Infrastructure - Planning scalable, secure infrastructure
• Ensuring Security and Compliance - Integrating security and compliance into architecture

What They Do: - Design bounded contexts and service boundaries - Define REST and gRPC APIs - Design domain and integration events - Create architecture blueprints and context maps - Generate ADR proposals for key decisions - Select templates and technology stack defaults - Design infrastructure and cloud architectures - Ensure security and compliance - Plan data architecture and governance

What They Do NOT Do: - Generate implementation code - Write tests or pipelines - Make product decisions (those come from Vision agents)

Inputs and Outputs

Inputs

Input	Source	Description
Vision Briefs	Vision & Planning Agents	Product vision and feature outlines
Feature Sets	Vision & Planning Agents	Detailed features and user stories
Existing Ecosystem Context	Knowledge System	Current systems, integrations, platforms
Domain Knowledge	Knowledge System	Patterns, templates, previous solutions
Technical Constraints	Technology Stack	Available technologies and patterns

Outputs

Output	Consumer	Description
Context Maps	Engineering Agents	Bounded context boundaries and relationships
Service/API Sketches	Engineering Agents	API contracts and specifications
Event Schemas	Engineering Agents	Domain and integration event definitions
ADR Drafts	Human Architects	Architecture decision records for review
Architecture Documentation	All Agents	Architecture blueprints and diagrams
Template Recommendations	Engineering Agents	Which templates to use for each service

Core Capabilities

Context Mapping and Modularization

• Bounded Context Identification - Identify domain boundaries
• Context Relationships - Define upstream/downstream relationships
• Service Boundary Design - Decide service boundaries
• Shared Kernel Identification - Identify shared components

Integration Pattern Selection

• API Design - REST, gRPC, GraphQL patterns
• Event Design - Domain events, integration events, event sourcing
• Data Flow Design - Request/response, pub/sub, CQRS patterns
• Integration Surface Design - How services integrate with platforms

Template and Technology Selection

• Template Selection - Choose appropriate templates for each service
• Technology Stack Defaults - Select technologies within constraints
• Library Recommendations - Recommend ConnectSoft libraries
• Pattern Application - Apply architectural patterns

ADR Generation

• Decision Identification - Identify key architectural decisions
• ADR Drafting - Create ADR proposals
• Alternative Analysis - Document alternatives considered
• Consequence Analysis - Document decision consequences

Typical Workflows

Workflow: New Bounded Context

1. Receive Vision Brief - Get product vision from Vision agents
2. Analyze Domain - Understand domain concepts and boundaries
3. Design Bounded Context - Define context boundaries
4. Design APIs - Define REST/gRPC APIs
5. Design Events - Define domain and integration events
6. Select Template - Choose microservice template
7. Generate ADR - Create ADR for key decisions
8. Hand Off to Engineering - Pass blueprint to Engineering agents

Workflow: Existing Service Enhancement

1. Receive Feature Request - Get feature from Vision agents
2. Analyze Current Architecture - Review existing service architecture
3. Assess Impact - Determine impact on existing boundaries
4. Design Changes - Design architectural changes
5. Update Contracts - Update API and event contracts
6. Generate ADR - Document architectural changes
7. Hand Off to Engineering - Pass changes to Engineering agents

Architect Agent Collaboration Flow

flowchart TD
    Vision[Vision & Planning Agents] --> EA[Enterprise Architect Agent]
    EA --> SA[Solution Architect Agent]
    SA --> AppArch[Application Architect Agent]
    SA --> DomainModeler[Domain Modeler Agent]
    SA --> EventArch[Event-Driven Architect Agent]
    SA --> APIDesigner[API Designer Agent]

    EA --> InfraArch[Infrastructure Architect Agent]
    EA --> CloudArch[Cloud Architect Agent]
    EA --> NetworkArch[Network Architect Agent]
    EA --> DevOpsArch[DevOps Architect Agent]

    EA --> DataArch[Data Architect Agent]
    EA --> SecArch[Security Architect Agent]

    AppArch --> TechLead[Tech Lead Agent]
    DomainModeler --> TechLead
    EventArch --> TechLead
    APIDesigner --> TechLead
    TechLead --> Engineering[Engineering Agents]

    SecArch -.->|Reviews| SA
    SecArch -.->|Reviews| AppArch
    SecArch -.->|Reviews| InfraArch
    SecArch -.->|Reviews| CloudArch

    DataArch -.->|Collaborates| SA
    DataArch -.->|Collaborates| AppArch

    DevOpsArch -.->|Collaborates| AppArch
    InfraArch -.->|Collaborates| CloudArch

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

Visual Flow: High-Level Architecture Process

flowchart LR
    A[Vision Brief] --> B[Enterprise Architect]
    B --> C[Solution Architect]
    C --> D[Domain Modeler]
    C --> E[Application Architect]
    C --> F[Event-Driven Architect]
    C --> G[API Designer]
    D --> H[Tech Lead]
    E --> H
    F --> H
    G --> H
    H --> I[Engineering Agents]

    B --> J[Infrastructure Architect]
    B --> K[Cloud Architect]
    B --> L[Data Architect]
    B --> M[Security Architect]

    style A fill:#e1f5ff
    style B fill:#fff4e1
    style H fill:#e8f5e9
    style I fill:#f3e5f5

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

Collaboration with Other Agents

With Vision & Planning Agents

Receive: - Product briefs and feature outlines - Initial bounded context suggestions - Risk and complexity assessments

Provide: - Feasibility feedback - Architecture constraints - Technical limitations - Scope clarification requests

With Engineering Agents

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

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

With QA Agents

Receive: - Architecture validation feedback - Risk identification - Compliance concerns - Testability issues

Provide: - Architecture rationale - Design decisions context

Individual Architect Agent Details

Enterprise Architecture Sub-Cluster

Enterprise Architect Agent

Role: Strategic IT planning and enterprise-wide architecture

Responsibilities: - Define enterprise-wide architecture strategy - Create high-level architectural blueprints - Establish architecture standards and governance - Identify and mitigate architectural risks - Ensure alignment with business goals - Communicate architectural vision to stakeholders

Inputs: - Business requirements and strategic goals - Existing enterprise systems - Compliance and regulatory standards - Technology constraints

Outputs: - Enterprise architecture blueprint - Technology roadmaps - Governance framework - Compliance models

See: Detailed Enterprise Architect Agent specification in Factory Documentation

Solution Architect Agent

Role: Designing specific solutions for business needs

Responsibilities: - Design solutions that address specific business problems - Ensure solutions align with enterprise architecture - Define integration with existing systems - Ensure technical feasibility - Collaborate with development teams

Inputs: - Business requirements - User stories and use cases - Existing systems context - Enterprise architecture blueprint

Outputs: - Solution architecture models - Integration plans - Technical specifications - Deployment plans

See: Detailed Solution Architect Agent specification in Factory Documentation

Tech Lead Agent

Role: Technical leadership and engineering coordination

Responsibilities: - Provide technical leadership to engineering teams - Ensure adherence to architecture - Coordinate between architects and engineers - Make day-to-day technical decisions - Review and approve implementation approaches

Inputs: - Architecture blueprints - Technical constraints - Engineering team capabilities

Outputs: - Technical guidance - Implementation decisions - Code review feedback

See: Detailed Tech Lead Agent specification in Factory Documentation

Domain and Application Architecture Sub-Cluster

Application Architect Agent

Role: Software application design and architecture

Responsibilities: - Design modular, scalable applications - Select programming languages and frameworks - Ensure application integration with systems - Work with DevOps Architect for deployment

Inputs: - Business requirements - User stories and use cases - Technology constraints - Security requirements

Outputs: - Application architecture models - API specifications - Technical specifications - Deployment plans

See: Detailed Application Architect Agent specification in Factory Documentation

Domain Modeler Agent

Role: Domain modeling and DDD implementation

Responsibilities: - Model domain concepts and boundaries - Design aggregates and entities - Define domain events - Ensure DDD principles are followed - Create ubiquitous language

Inputs: - Product vision and requirements - Business rules - Domain knowledge

Outputs: - Domain models - Aggregate designs - Domain event schemas - Ubiquitous language dictionary

See: Detailed Domain Modeler Agent specification in Factory Documentation

Event-Driven Architect Agent

Role: Event-driven architecture design

Responsibilities: - Design event-driven architectures - Define event schemas and flows - Plan event sourcing and CQRS patterns - Design pub/sub topologies - Ensure event consistency

Inputs: - Domain models - Integration requirements - Scalability needs

Outputs: - Event architecture blueprints - Event schemas - Event flow diagrams - Event sourcing plans

See: Detailed Event-Driven Architect Agent specification in Factory Documentation

API Designer Agent

Role: API design and contract definition

Responsibilities: - Design REST and gRPC APIs - Create OpenAPI/Swagger specifications - Define API contracts and schemas - Ensure API consistency - Design API versioning strategies

Inputs: - Service boundaries - Integration requirements - API standards

Outputs: - OpenAPI specifications - API contracts - API documentation - API versioning plans

See: Detailed API Designer Agent specification in Factory Documentation

Infrastructure Architecture Sub-Cluster

Infrastructure Architect Agent

Role: IT infrastructure design (servers, storage, networking)

Responsibilities: - Design scalable, reliable infrastructure - Plan server, storage, and networking resources - Ensure infrastructure supports applications - Collaborate with Cloud Architect - Design disaster recovery

Inputs: - System requirements - Existing infrastructure - Scalability requirements - Compliance standards

Outputs: - Infrastructure design models - Scalability plans - Disaster recovery plans - Cost optimization strategies

See: Detailed Infrastructure Architect Agent specification in Factory Documentation

Cloud Architect Agent

Role: Cloud-native architecture and cloud migration

Responsibilities: - Design cloud-native systems - Select cloud platforms (AWS, Azure, GCP) - Plan cloud migrations - Optimize cloud costs - Ensure cloud security

Inputs: - Business requirements - Existing infrastructure - Cloud platform constraints - Regulatory requirements

Outputs: - Cloud architecture models - Cloud migration plans - Cost optimization plans - Security and compliance models

See: Detailed Cloud Architect Agent specification in Factory Documentation

Network Architect Agent

Role: Network infrastructure design

Responsibilities: - Design network architecture - Plan traffic management - Ensure network reliability and low latency - Integrate cloud and on-premise networks - Optimize network performance

Inputs: - Network requirements - Existing network infrastructure - Scalability requirements - Security standards

Outputs: - Network architecture models - Performance optimization plans - Disaster recovery plans - Security controls

See: Detailed Network Architect Agent specification in Factory Documentation

DevOps Architect Agent

Role: CI/CD pipeline and automation architecture

Responsibilities: - Design CI/CD pipelines - Plan infrastructure automation (IaC) - Design monitoring and logging - Ensure deployment automation - Collaborate with Application Architect

Inputs: - Development process requirements - Infrastructure requirements - Automation tools - Deployment targets

Outputs: - CI/CD pipeline designs - Infrastructure as Code scripts - Monitoring strategies - Deployment automation plans

See: Detailed DevOps Architect Agent specification in Factory Documentation

Data and Security Architecture Sub-Cluster

Data Architect Agent

Role: Data architecture, governance, and integration

Responsibilities: - Design data flow and storage - Plan data integration - Establish data governance - Design databases (SQL, NoSQL) - Ensure data compliance

Inputs: - Data requirements - Data governance policies - Existing data systems - Compliance standards

Outputs: - Data models - ETL pipelines - Data governance frameworks - Data integration plans

See: Detailed Data Architect Agent specification in Factory Documentation

Security Architect Agent

Role: Security architecture and compliance

Responsibilities: - Develop security strategy - Conduct risk assessments - Design data protection mechanisms - Ensure compliance (GDPR, HIPAA, SOC2) - Review all architecture for security

Inputs: - Security standards - Business requirements - Risk assessments - Compliance requirements

Outputs: - Security architecture models - Risk mitigation plans - Compliance reports - Incident response plans

See: Detailed Security Architect Agent specification in Factory Documentation

Architect Agent Specialization Matrix

Architect Type	When to Use	Key Focus Area
Enterprise Architect	All projects	Strategic alignment, enterprise-wide consistency
Solution Architect	All projects	Solution design, business alignment
Application Architect	Software applications	Application design, technology selection
Domain Modeler	Complex domains	Domain modeling, DDD implementation
Event-Driven Architect	Event-driven systems	Event architecture, pub/sub design
API Designer	API-first projects	API design, contract definition
Infrastructure Architect	Infrastructure-heavy projects	Infrastructure design, scalability
Cloud Architect	Cloud-native projects	Cloud architecture, migration
Network Architect	Network-critical projects	Network design, performance
DevOps Architect	CI/CD automation	Pipeline design, automation
Data Architect	Data-heavy projects	Data architecture, governance
Security Architect	All projects	Security, compliance
Tech Lead	All projects	Technical leadership, coordination

Architectural Guardrails

Architect agents must follow these non-negotiable rules:

Important

Architectural Guardrails: 1. Must follow Clean Architecture - Domain → Application → Infrastructure dependency flow 2. Must respect DDD principles - Bounded contexts, aggregates, domain events 3. Must be Event-Driven - Important actions expressed as events 4. Must be Cloud-Native - Stateless, scalable, observable 5. Must integrate with Platforms - Use Identity, Audit, Config, Bot platforms where applicable 6. Must follow Microservice Blueprint - Standard structure and patterns 7. Must document decisions - ADRs for key architectural choices

See: Clean Architecture & DDD, Event-Driven Mindset, Cloud-Native Mindset, Agent Microservice Standard Blueprint

KPIs and Evaluation Criteria

KPI	Description	How We Measure
Downstream Change Requests	Changes requested by Engineering/QA agents	Number of architecture changes requested
Architecture Compliance	Adherence to architectural patterns	QA agent compliance checks
Pattern Reuse	Reuse of established patterns	Template and pattern usage rate
ADR Quality	Quality of architecture decisions	Human architect review and approval rate
Integration Success	Successful integration with platforms	Integration test pass rate

Risks and Anti-Patterns

Risk 1: Too Many Services

Problem: Creating too many microservices, leading to complexity.

Solution: Prefer fewer, well-bounded services. Start with larger contexts and split only when needed.

Risk 2: Over-Coupling

Problem: Services are too tightly coupled.

Solution: Use events for async communication. Minimize synchronous dependencies.

Risk 3: Ignoring Domain Boundaries

Problem: Violating bounded context boundaries.

Solution: Enforce strict boundaries. Use events for cross-context communication.

Risk 4: Inconsistent Patterns

Problem: Different services use different patterns.

Solution: Standardize on ConnectSoft patterns. Use templates consistently.

Warning

Common Anti-Patterns: - Anemic Domain Model - Business logic in application layer instead of domain - Shared Database - Multiple services sharing same database - God Service - One service doing too much - Tight Coupling - Synchronous dependencies between services - Inconsistent APIs - Different API patterns across services

Related Documents

• Agent System Overview - How agents work together
• Agent Execution Flow - Execution flow details
• Agent Collaboration Patterns - Collaboration patterns
• Vision & Planning Agents - Upstream agents
• Research and UX/UI Design Agents - Design phase agents
• Engineering Agents - Downstream agents
• Clean Architecture & DDD - Architecture principles
• Modularization - Bounded context guidance
• Event-Driven Mindset - Event patterns
• Cloud-Native Mindset - Cloud-native principles
• Agent Microservice Standard Blueprint - Standard blueprint
• Technology Stack - Technology constraints
• Decision Records Process - ADR process