Skip to content

ConnectSoft AI Factory

One governed control plane for everything an organization runs with AI: agents, skills, tools, models, knowledge, memory, execution environments and the people who decide. Models are replaceable; the organization's accumulated intelligence is not. The first solution pack is software engineering: governed engineering workflows and the generation, delivery and operation of SaaS products from ConnectSoft templates.

Start with the platform map Read the architecture decisions See what exists today

Target

This site describes a target architecture and labels every page. The labels are Target, Current implementation, Decision, Evidence, Historical and Generated; read the label before the content. Facts about services, contexts, events and tables come from one machine-readable model and are rendered into the catalogs, so a number on a catalog page and a number on a design page never disagree.

What it is

flowchart LR
    Models["Foundation models<br/>providers, compute"] --> Factory
    subgraph Factory["ConnectSoft AI Factory"]
        direction TB
        CP["Control plane<br/>projects, releases, runs, approvals, budgets"]
        RT["Agent runtime<br/>steps, attempts, leases, recovery"]
        KM["Knowledge and memory<br/>sources, context, governed learning"]
        TL["Tools and MCP<br/>side-effect classes, sandboxes"]
        TO["Trust and operations<br/>policy, audit, evaluation, FinOps"]
        CP --> RT --> TL
        KM --> RT
        TO --> CP & RT & TL
    end
    Factory --> People["People<br/>requesters, reviewers, operators"]
    Factory --> Products["Generated products<br/>operated as a managed service"]
Hold "Alt" / "Option" to enable pan & zoom

The Factory sits between model providers and compute on one side and an organization's agents, knowledge, workflows, execution environments and people on the other. It decides what runs, with what context, under which policy, and who decided, and it keeps the evidence.

A run is submitted in a project scope, pinned to immutable published assets, reserved against a budget, executed under a lease, gated by exact-version approvals for anything that writes, spends or ships, and settled with reconciled usage. Every one of those words is a designed object with an owner, a schema and a state machine on this site.

Nine planes, sixteen platforms, forty-two bounded contexts and one hundred eighty-three logical services, each with a deployment granularity (standalone host, module of a host, canonical external, later). The meta-model defines the vocabulary; the platform map places everything; the generated service catalog is the index.

The Factory produces and operates SaaS products from ConnectSoft templates for twenty-nine verticals, under editions that cover internal budget control, usage-based billing and seat plans (commercial model). Generated products are run by ConnectSoft as a managed service with fleet-level operations.

The moat is owned intelligence: published assets, evaluation evidence, knowledge, memory and execution history stay with the organization while models are swapped. Capability dependencies are stated without dates in capability dependencies; what is real today is on this page. The stakeholder pages say it for executives, customers, investors and partners.

The ecosystem at a glance

mindmap
  root((ConnectSoft AI Factory))
    Experience
      Factory Studio
    Control
      Control Plane
    Agent and Orchestration runtime
      Agent Mesh
    Model and Compute
      Model and Compute Platform
    Knowledge and Memory
      Knowledge Platform
    Capability and Tools
      Tools and MCP Platform
      Integration Platform
      Marketplace
    Execution
      DevOps and GitOps
      Runtime Cloud
      Product Fleet Operations
    Data and Event
      Data and Event Platform
    Trust and Operations
      Governance
      Observability
    Solution packs
      Software Factory templates and libraries
      Generated SaaS
Hold "Alt" / "Option" to enable pan & zoom

Planes

Planes are logical layers; platforms are the product groupings inside them; each platform owns bounded contexts and services. Every plane index lists its platforms, contexts, services, boundary events and gateways from the model.

flowchart TB
    EXP["Experience plane<br/>Factory Studio, CLI, VS Code, SDKs"]
    CTL["Control plane<br/>projects, publication, run authority, usage, commercial"]
    RUN["Agent and Orchestration runtime<br/>Agent Mesh, workflow engine"]
    MDL["Model and Compute<br/>gateway, capability routing, profiles, pools"]
    KNW["Knowledge and Memory<br/>ingestion, retrieval, graph, memory, context"]
    CAP["Capability and Tools<br/>tools and MCP, integration, marketplace"]
    EXE["Execution<br/>delivery, runtime cloud, product fleet operations"]
    DAT["Data and Event<br/>envelopes, topics, stores, retention"]
    TRU["Trust and Operations<br/>governance, observability, evaluation, FinOps"]
    EXP --> CTL --> RUN
    RUN --> MDL & KNW & CAP
    CAP --> EXE
    DAT -.-> CTL & RUN & KNW
    TRU -.-> CTL & RUN & CAP & EXE
Hold "Alt" / "Option" to enable pan & zoom
Plane Owns Start here
Experience Web Studio, CLI, VS Code extension, SDKs; how people submit, review and govern Experience plane · Factory Studio
Control Projects and environments, published releases, run and approval authority, budgets, the Factory's own commercial model Control plane · Run Control
Agent and Orchestration runtime Executing a run: steps, attempts, leases, checkpoints, human-in-the-loop, recovery; workflow definitions and engine Agent runtime
Model and Compute Model gateway, capability routing, provider profiles, compute pools and placement Model and Compute
Knowledge and Memory Documents, code, search, knowledge graph, provenance, memory lifecycle, context engineering Knowledge and Memory
Capability and Tools Tools and MCP servers with side-effect classes, connectors, marketplace Capability and Tools
Execution Sandboxes and workspaces, build and delivery pipelines, environments, fleet operations of generated products Execution
Data and Event Relational, cache, vector, graph and blob stores; event envelope, topics, outbox and inbox profiles, retention and residency Data and Event
Trust and Operations Policy, audit, approvals policy, secret broker, evaluation, observability, FinOps, reliability Trust and Operations

Solution packs

Engineering agents, skills, workflows, blueprints, DSLs, templates and libraries that turn a product vision into generated, tested, delivered services. One hundred agent specifications, forty-three templates and the ConnectSoft library estate are catalogued here.

Software Factory pack Vision to Production workflow Templates

The products the Factory produces: bounded contexts on the ConnectSoft SaaS foundations (tenants, products catalog, entitlements, billing, metering), identity and authorization, API gateways, Blazor shells and micro-frontends, operated as a managed service with per-product SLOs, upgrades and incidents.

Generated SaaS pack Product fleet operations

From vision to a running product

flowchart LR
    V["Vision and intent"] --> B["Blueprints and DSLs"]
    B --> G["Generated services, MFEs, pipelines"]
    G --> Q["Evaluation and quality gates"]
    Q --> R["Release and delivery"]
    R --> O["Operated product<br/>fleet inventory, SLOs, upgrades"]
    O -. feedback, telemetry, usage .-> V
Hold "Alt" / "Option" to enable pan & zoom

Every arrow is a governed run: pinned assets, budget reserved, exact-version approvals where the action writes, spends or ships, receipts and evidence kept. Industry examples per vertical are being added to the workflow pages as the examples section of the site is built.

What exists today

Current implementation (reviewed 2026-10-09)

The Current state page lists what exists by repository and revision, the capability matrix, and the rule for moving a page from Target to Current. In short, what exists in source: authored agent and skill assets (100 agent definitions, 84 skills), a scaffold agent host, an execution-lifecycle library with model and vector adapters, MCP governance, a messaging port with Orleans, MassTransit and NServiceBus adapters, the ConnectSoft template estate (microservice, worker, API gateway, authorization server, identity, SaaS services, Blazor shell and micro-frontends) with one production consumer, and the Config Platform design. There is no control plane, asset registry, durable run, approval workflow, sandbox broker or Studio in code. The ecosystem composition page says, component by component, what exists, what is extended and what must be developed.

Decisions and evidence

How to read this site

Page kind How it is produced What to trust
Plane index and platform narrative hand-written design, with generated sections the design intent and the generated lists
Service design page hand-written skeleton with generated identity, domain, API, event, worker, security and dependency sections both; the generated parts never contradict the catalogs
Catalogs, DDL appendices, traceability rendered from model/**/*.yaml during the build the model; edit the YAML, not the page
ADR a decision with a status binding when Accepted
Archive June-2026 pages kept for provenance nothing; read the replacement linked at the top

Conventions are in documentation standards; terms are in the glossary.

Reading paths

If you are Read
Deciding what the Factory is for Vision and strategy → Why an AI Software Factory → Final solution vision → Capability dependencies
Designing a plane, platform or service Meta-model → Platform map → the plane index → a service page such as Run Control → ADRs
Working on the software-engineering pack Agent system overview → Vision to Production workflow → Templates overview → Template catalog
Operating or reviewing runs Factory Studio → Control plane workflows → Control plane observability
Checking what is real What exists today → Ecosystem composition → Inconsistencies

Key concepts

  • Agent — a role and configuration: instructions, permitted skills, tools, model requirements and policies. Not a running process.
  • Skill — a reusable instructional or procedural asset; it grants no execution power by itself.
  • Tool / MCP server — executable capability with an input/output contract, scope and side-effect class.
  • Published release — a reviewed, immutable combination of agent, skills, tools, workflow, policy and model profile; a run pins one.
  • Run, step, attempt — one persisted execution of a workflow, its units of work and each try of a unit; approvals bind to an exact artifact or action version.
  • Model profile — a logical capability, privacy and budget requirement resolved to a provider, model and deployment at run time.
  • Knowledge, context, memory — approved sources; the subset assembled for one execution; reviewed reusable learning.
  • Solution pack — a domain's agents, workflows, templates and evaluation suites built on the platform; software engineering is the first.