Skip to content

AI Factory Roadmap

This document outlines the AI Factory roadmap with phased features such as more templates, better agents, higher automation, and self-service, mapped to customer impact. It is written for product managers, architects, and stakeholders planning Factory evolution.

The Factory roadmap focuses on building core capabilities, expanding agent capabilities, improving automation, and preparing for marketplace and enterprise features. All features are mapped to customer impact and business value.

Note

This roadmap focuses on phases and themes rather than exact dates. Phases may overlap, and priorities may shift based on customer feedback and market needs.

Goals for the Factory

Primary Goals

  • Reduce Time-to-Value - Reduce time from idea → running SaaS service
  • Standardize Architecture - Standardize architecture and cross-cutting concerns
  • Predictable Generation - Make code generation + agents predictable and testable
  • Enable Self-Service - Enable self-service for advanced users
  • Support Partners - Support partner-led implementations

Success Metrics

  • Time from project start to first running service
  • Number of templates available
  • Agent execution success rate
  • Customer satisfaction with generated code quality
  • Partner adoption and success

See: Factory Strategic Goals for Factory goals and OKRs.

Roadmap Themes

mindmap
  root((Factory Themes))
    Template Expansion
      More Templates
      Domain-Specific
      Integration Templates
    Agentic Orchestration
      Smarter Workflows
      Multi-Agent Patterns
      Better Collaboration
    Self-Service UX
      Easy Triggering
      Non-Dev Access
      Safe Scaffolding
    Observability & Safety
      Better Visibility
      Guardrails
      Evaluation
Hold "Alt" / "Option" to enable pan & zoom
Theme Description Customer Impact
Template Expansion More microservice, platform, integration templates Faster delivery of new microservices and integrations
Agentic Orchestration Smarter agent workflows, multi-agent patterns Less manual glue work, better collaboration
Self-Service UX Easier ways to trigger and configure runs Non-devs can trigger/scaffold work safely
Observability & Safety Better visibility, guardrails, evaluation Easier debugging and governance

Phased Feature Evolution

flowchart TD
    Phase1[Phase 1: Stabilize Core<br/>Now] --> Phase2[Phase 2: Expand & Improve<br/>Next]
    Phase2 --> Phase3[Phase 3: Self-Service & Marketplace<br/>Later]

    Phase1 --> Core[Core Templates<br/>5 Agents<br/>Basic Orchestration]
    Phase2 --> Expand[Domain Templates<br/>Extended Agents<br/>Advanced Knowledge]
    Phase3 --> SelfService[Self-Service Portal<br/>Marketplace Integration<br/>Enterprise Features]

    style Phase1 fill:#e3f2fd
    style Phase2 fill:#f3e5f5
    style Phase3 fill:#e8f5e9
Hold "Alt" / "Option" to enable pan & zoom

Phase 1: Stabilize Core (Now)

Focus: Solidify Factory core, essential templates, basic orchestration

Deliverables:

  • Core microservice template stable and production-ready
  • First 5 agents operational (Vision, Architect, Engineering, QA, DevOps)
  • Basic agent orchestration and collaboration patterns
  • Azure DevOps integration working
  • Basic knowledge & memory system
  • Console UI for project management and run monitoring

Customer Impact: Factory MVP enables first customer projects with consistent architecture and patterns.

Phase 2: Expand and Improve (Next)

Focus: Expand templates, improve agents, add domain-specific capabilities

Deliverables:

  • Domain-specific templates (e.g., Employment Services SaaS template)
  • Extended agent roles and capabilities
  • Better agent collaboration patterns
  • Advanced knowledge & memory (vector search, pattern reuse)
  • Improved run reporting and observability
  • Template marketplace infrastructure (internal)

Customer Impact: Faster delivery of domain-specific solutions, better code quality, improved developer experience.

Phase 3: Self-Service and Marketplace (Later)

Focus: Self-service capabilities, marketplace integration, enterprise features

Deliverables:

  • Self-service portal for advanced users
  • Marketplace integration (internal, then external)
  • Enterprise features (SSO, RBAC, audit logs)
  • Advanced observability and analytics
  • Performance optimizations
  • Multi-cloud support (future)

Customer Impact: Non-developers can trigger Factory runs, partners can contribute templates, enterprise customers get advanced features.

Decision

Quality Over Quantity: ConnectSoft prioritizes quality & observability over raw quantity of templates. Better to have fewer, well-tested templates than many templates with inconsistent quality. All templates must meet security, architecture, and quality standards.

Factory Dual Track: Engine vs. SaaS

The Factory operates in two complementary tracks that evolve together:

Factory-as-Engine

What it is: The core Factory capabilities - templates, agents, generation pipelines, knowledge system. This is the "engine" that generates code, infrastructure, and documentation.

Key Components:

  • Template catalog and overlay recipes
  • Agent system (Vision, Architect, Engineering, QA, DevOps, etc.)
  • Generation pipelines and orchestration
  • Knowledge & memory system
  • Azure DevOps / Git integration
  • Code generation and validation

Evolution Focus:

  • More templates and overlay recipes
  • Better agent capabilities and collaboration
  • Improved generation quality and speed
  • Enhanced knowledge system
  • Better observability and debugging

Factory-as-SaaS

What it is: The Factory as a SaaS product - tenant onboarding, UI, billing, operations, self-service portal. This is the "product" that customers use.

Key Components:

  • Tenant management and onboarding
  • Factory console UI
  • Project management and run monitoring
  • Billing and subscription management
  • Self-service portal
  • API for programmatic access
  • Enterprise features (SSO, RBAC, audit logs)

Evolution Focus:

  • Better developer experience
  • Self-service capabilities

Factory Support for connectsoft.me (Cycle 3)

The Factory provides critical infrastructure and capabilities for connectsoft.me Personal Agents Platform:

Agent Template and Workflow Scaffolding

What the Factory Provides:

  • Agent Template - Specialized template for hosting AI agents with Semantic Kernel / Microsoft.Extensions.AI integration, tool registration, conversation/turn persistence, and AI observability
  • Workflow Scaffolding - Templates and patterns for multi-agent workflows, sequential and parallel execution, coordinator agents
  • Personal-Tenant Aware Generation - Templates and generation patterns that support personal-tenant models (individual user accounts) distinct from organizational tenants

Real-World Learning Feedback Loop

How connectsoft.me Feeds Back into Factory:

  • Consumer Usage Patterns - Real-world consumer usage of agents and workflows provides learning that feeds back into templates used for connectsoft.io enterprise products
  • Workflow Patterns - Consumer workflow patterns (life admin, finance, learning, family) inform enterprise workflow templates
  • Agent Behavior - Consumer agent behavior and user interactions inform agent template improvements
  • Cost Optimization - Consumer usage patterns help optimize AI costs and token usage, benefiting all Factory consumers

Cycle-Specific Template Evolution

Cycle 2 → Templates for Horizontal SaaS:

  • Focus on B2B SaaS templates (Marketing Hub, CRM, CMS, etc.)
  • Multi-tenant organizational patterns
  • Enterprise integration patterns

Cycle 3 → Templates & Tooling for Personal Agents and Packs:

  • Personal agent templates (Inbox Agent, Planner Agent, Budget Agent, etc.)
  • Agent pack composition patterns
  • Personal workflow orchestration
  • Consumer connector patterns (email, calendar, file upload)

Cycle 4–5 → Templates for AI Bot Framework, Forms, Insurance & Other Verticals:

  • AI Bot Framework templates
  • Digital Forms SaaS templates
  • Vertical solution templates (Insurance, AdTech, HR)
  • Marketplace item templates

See: connectsoft.me Overview for product details.

See: Strategic Goals for five-cycle structure.

  • Enterprise features
  • Marketplace integration
  • Partner enablement

Cycle Dependencies

Cycle 1: AI Factory SaaS v1

  • Factory-as-Engine: Core templates, basic agents, generation pipelines operational
  • Factory-as-SaaS: Tenant onboarding, basic UI, project management, runs on Core Platform (Identity, Config, Audit, Billing)
  • Outcome: First SaaS product launched, developer/architect-facing, API-first

Cycle 2: Factory Used to Generate Horizontal SaaS

  • Factory-as-Engine: Enhanced templates for horizontal SaaS (Marketing, Links, Workflows, CMS, CRM), improved agents, better generation quality
  • Factory-as-SaaS: Improved UI, better project management, enhanced self-service
  • Outcome: Factory generates all Cycle 2 horizontal SaaS products

Cycle 3: Factory Support for connectsoft.me Personal Agents Platform

  • Factory-as-Engine: Agent Template for personal agents, workflow scaffolding for multi-agent workflows, personal-tenant aware generation patterns
  • Factory-as-SaaS: Personal agent templates, agent pack composition patterns, consumer connector patterns
  • Outcome: Factory provides infrastructure for connectsoft.me, gains real-world learning from consumer usage that feeds back into templates for connectsoft.io
  • Learning Feedback: Consumer usage patterns inform enterprise templates and agent behavior improvements

Cycle 4: Factory Used to Generate AI Bot Framework, Digital Forms, Insurance

  • Factory-as-Engine: AI-specific templates (Agent Template enhancements), bot framework templates, form builder templates, vertical solution templates
  • Factory-as-SaaS: Enhanced capabilities for AI/ML projects, better integration with AI Gateway
  • Outcome: Factory generates AI Bot Framework, Digital Forms SaaS, and Insurance Suite solution pack (first major vertical leveraging horizontal SaaS, AI Bot Framework, and lessons learned from connectsoft.me agents)

Cycle 5: Factory Producing Marketplace Items

  • Factory-as-Engine: Marketplace-ready templates, agent marketplace capabilities, template/agent packaging for marketplace
  • Factory-as-SaaS: Marketplace integration, partner contribution workflows, template/agent publishing tools
  • Outcome: Factory enables Template Marketplace, Agent Marketplace, and SaaS & Solution Marketplace
graph TB
    subgraph Engine["Factory-as-Engine"]
        Templates[Templates & Recipes]
        Agents[Agent System]
        Generation[Generation Pipelines]
        Knowledge[Knowledge System]
    end

    subgraph SaaS["Factory-as-SaaS"]
        Tenant[Tenant Management]
        UI[Console UI]
        Billing[Billing & Subscriptions]
        SelfService[Self-Service Portal]
    end

    subgraph Cycle1["Cycle 1: AI Factory SaaS"]
        FactorySaaS[AI Factory SaaS v1]
    end

    subgraph Cycle2["Cycle 2: Horizontal SaaS"]
        Marketing[Marketing Hub]
        Links[Short Links]
        Workflow[Workflow Orchestrator]
        CMS[Headless CMS]
        CRM[CRM Hub]
    end

    subgraph Cycle3["Cycle 3: AI & Forms"]
        BotFramework[AI Bot Framework]
        Forms[Digital Forms]
        Insurance[Insurance Suite]
    end

    subgraph Cycle4["Cycle 4: Marketplaces"]
        TemplateMkt[Template Marketplace]
        AgentMkt[Agent Marketplace]
        SaaSMkt[SaaS Marketplace]
    end

    Engine --> FactorySaaS
    SaaS --> FactorySaaS
    Engine --> Marketing
    Engine --> Links
    Engine --> Workflow
    Engine --> CMS
    Engine --> CRM
    Engine --> BotFramework
    Engine --> Forms
    Engine --> Insurance
    Engine --> TemplateMkt
    Engine --> AgentMkt
    Engine --> SaaSMkt

    style Engine fill:#e3f2fd
    style SaaS fill:#f3e5f5
    style Cycle1 fill:#bbdefb
    style Cycle2 fill:#c8e6c9
    style Cycle3 fill:#fff3e0
    style Cycle4 fill:#f3e5f5
Hold "Alt" / "Option" to enable pan & zoom

Customer Impact and Value

Capability Impact on Customer Business Value
More templates Faster delivery of new microservices Reduced time-to-market, lower costs
Agent orchestration Less manual glue work Reduced manual effort, better consistency
Self-service runs Non-devs can trigger/scaffold work safely Broader user base, faster iteration
Observability of runs Easier debugging and governance Better quality, faster issue resolution
Domain-specific templates Faster delivery of vertical solutions Competitive advantage, market expansion
Marketplace integration Access to partner-contributed templates Ecosystem growth, faster innovation

See: Factory Business Model for business model details.

See: Squads Business Model for squads value proposition.

Dependencies on Platforms and Ops

Platform Dependencies

Factory Relies On:

  • Stable Identity/Audit/Config/Bot templates for platform generation
  • Platform APIs for integration patterns
  • Platform capabilities for generated services

Factory Enables:

  • Platform generation and updates
  • Platform customization and extensions
  • Platform integration patterns

See: Platforms Roadmap for platform evolution.

See: Product Portfolio - Platforms for platform details.

Operations Dependencies

Factory Requires:

  • Robust observability infrastructure (logging, tracing, metrics)
  • CI/CD infrastructure for generated services
  • Monitoring and alerting for Factory operations
  • Support processes for Factory issues

See: Observability-Driven Design for observability principles.

See: Monitoring and Dashboards for monitoring details.

See: Factory Operations for Factory operations.

Risks and Open Questions

Design Tensions

Autonomy vs. Control:

  • How much autonomy to give customers vs. ConnectSoft
  • Balancing self-service with quality control
  • Partner contributions vs. ConnectSoft curation

Template Complexity vs. Maintainability:

  • More templates = more options but more maintenance
  • Domain-specific templates vs. generic templates
  • Template versioning and compatibility

Speed vs. Quality:

  • Faster generation vs. code quality
  • More templates vs. better templates
  • Self-service vs. guided workflows

Warning

Key Risks: 1. Too Many Templates Without Governance - Leads to chaos, inconsistent quality, maintenance burden 1. Over-Automation - Removing human judgment where it's needed 1. Partner Fragmentation - Too many partner templates without curation leads to confusion

Open Questions

  • How much self-service is appropriate for non-developers?
  • What's the right balance between ConnectSoft templates and partner contributions?
  • How to handle template deprecation and migration?
  • What's the right model for marketplace revenue sharing?

See: Marketplace Roadmap for marketplace evolution.

See: Partner Program Overview for partner program details.