Skip to content

Factory Studio Overview

Target Architecture — Final-State Design

This page describes the final-state target architecture of the Factory Studio / Experience Platform. Capabilities that already exist in the codebase (the Blazor MFE shell, microfrontend library, UI Kit, SignalR real-time stack, and OpenIddict auth) are marked separately; everything else is the designed end state the factory converges to.

The Factory Studio — canonically the Experience Platform — is the command center of the ConnectSoft AI Software Factory. It is the single, multi-tenant web experience through which humans observe, steer, review, and govern an otherwise autonomous software factory. It is not a chatbot and not an IDE; it is the AI-native software factory platform's human interface — the cockpit from which an operator can watch agents design, build, test, and ship SaaS products, and intervene with authority where human judgement is required.

Where the Control Plane supplies orchestration, the Agent Mesh supplies reasoning, and the Knowledge Platform supplies grounded memory, the Factory Studio supplies situational awareness and human authority. Every other platform is API-first and event-driven; the Studio is the place where those APIs and events become legible to people — rendered as live dashboards, lineage graphs, review queues, and governance gates.

Purpose

The Factory Studio exists to keep an autonomous factory observable, steerable, and accountable at multi-tenant scale:

  • Make autonomy observable. Surface what every agent, workflow, pipeline, and running SaaS product is doing right now, correlated end to end by the canonical event envelope traceId.
  • Put a human in the loop where it matters. Provide governed review and approval surfaces so a person can approve, reject, escalate, or override agent decisions without slowing the factory down elsewhere.
  • Expose traceability and lineage. Let anyone walk from business intent → blueprint → agent task → artifact → commit → deployment → runtime signal, and back, through the Artifact Lineage Browser and Knowledge Graph Explorer.
  • Govern at the edge. Enforce RBAC, tenant isolation, and audit on every action, so the experience layer is itself a control surface, not just a viewer.
  • Stay aggregation-only. The Studio owns presentation, review state, and user workspace state; it never owns factory truth. All domain data is read through Backend-for-Frontend (BFF) services that aggregate the source-of-truth platforms.

Role in the AI Software Factory

flowchart LR
    User["Factory Operator / Architect / Reviewer"] --> Shell["Factory Studio<br/>Blazor MFE Shell"]
    Shell --> BFF["Studio BFF Services"]
    BFF --> CP["Control Plane"]
    BFF --> AM["Agent Mesh"]
    BFF --> KP["Knowledge Platform"]
    BFF --> OBS["Observability &amp; Feedback"]
    BFF --> GOV["Governance, Security &amp; Compliance"]
    BFF --> MKT["Marketplace"]
    CP -->|lifecycle events| RTG["Studio Realtime Gateway"]
    AM -->|task events| RTG
    OBS -->|runtime signals| RTG
    RTG -->|"SignalR push"| Shell
    Shell -->|"ReviewDecision (human authority)"| BFF
    BFF -->|"commands"| CP
Hold "Alt" / "Option" to enable pan & zoom

The Studio is a read-mostly, command-on-intent participant. It reads aggregated state from every platform through its BFF tier, streams live change through the realtime gateway, and writes back only the small set of decisions that represent human authority — review approvals, overrides, escalations, saved views, and workspace preferences. Those decisions are emitted as domain events (ReviewApproved, AgentDecisionOverridden) that the Control Plane and Agent Mesh consume to unblock or redirect autonomous work.

Core Responsibilities

Responsibility Description
Experience shell Host the Blazor microfrontend shell, compose 13 UI modules, manage routing, layout, theming, and session.
BFF aggregation Aggregate Control Plane, Agent Mesh, Knowledge, Observability, Governance, and Marketplace APIs into view-shaped, tenant-scoped read models.
Real-time fan-out Subscribe to factory events and push live updates to connected browsers over SignalR with per-tenant, per-user authorization.
Human review Manage the review queue, capture ReviewRequest/ReviewDecision lifecycle, and emit human-authority events back to the factory.
Dashboard composition Assemble dashboard views from multiple platform sources, cache hot dashboards, and refresh on event or interval.
Artifact preview & lineage Render artifact bodies, diffs, and content-addressable lineage via a dedicated preview service.
Knowledge graph visualization Project the Knowledge Platform graph into interactive, access-checked visual neighbourhoods.
Notifications Deliver in-app, digest, and escalation notifications scoped to tenant, project, and role.
User workspace state Persist saved views, filters, layouts, and preferences per user and tenant.
Experience governance Enforce RBAC, tenant isolation, and audit on every page, query, command, and stream.

Key Capabilities

  • Single command center — one Blazor MFE experience for the whole factory, from blueprint design to running-SaaS health, instead of a fragmented tool sprawl.
  • Live, correlated awareness — SignalR-pushed updates keyed by traceId/correlationId, so the screen reflects factory reality within seconds and every tile links back to its source trace.
  • Governed human-in-the-loop — review and override surfaces that are first-class, audited control actions, not side channels.
  • Aggregation without ownership — BFF read models keep the Studio thin: source platforms remain the single source of truth, the Studio never forks domain state.
  • Multi-tenant by construction — tenantId is an isolation boundary on every BFF query, SignalR group, cache key, and stored Studio aggregate.
  • Composable microfrontends — modules ship independently as microfrontends loaded by the shell, so the experience evolves per platform without a monolithic redeploy.
  • Full traceability — every user action emits an audited event in the canonical envelope, making the experience layer itself observable.

High-Level Component Diagram

flowchart TB
    subgraph Client["Client Tier — Blazor MFE"]
        ShellHost["ShellTemplate Host<br/>routing + layout + auth"]
        UIKit["Blazor.UIKit<br/>shared components"]
        subgraph MFEs["Microfrontends (13 modules)"]
            CommandCenter["Project Command Center"]
            ReviewCenter["Human Review Center"]
            Lineage["Artifact Lineage Browser"]
            GraphExp["Knowledge Graph Explorer"]
            More["... + 9 modules"]
        end
        Mobile["MAUI Companion<br/>(optional)"]
    end

    subgraph Edge["Studio Platform — ConnectSoft.Factory.Studio.*"]
        StudioBff["StudioBff"]
        RTG["StudioRealtimeGateway"]
        Notif["StudioNotificationService"]
        Review["ReviewCenterService"]
        Dash["DashboardAggregationService"]
        Preview["ArtifactPreviewService"]
        KExp["KnowledgeExplorerBff"]
        AgentFlow["AgentFlowVisualizationService"]
    end

    subgraph Sources["Source-of-Truth Platforms"]
        CP["Control Plane"]
        AM["Agent Mesh"]
        KP["Knowledge Platform"]
        OBS["Observability &amp; Feedback"]
        GOV["Governance, Security &amp; Compliance"]
        MKT["Marketplace"]
    end

    subgraph StudioStores["Studio State"]
        SQL[("Azure SQL / PostgreSQL<br/>review, workspace, saved views")]
        Redis[("Redis<br/>sessions + hot dashboards")]
    end

    ShellHost --> UIKit
    MFEs --> ShellHost
    Mobile --> StudioBff
    ShellHost -->|"REST/gRPC"| StudioBff
    ShellHost -->|"SignalR"| RTG

    StudioBff --> Dash
    StudioBff --> Review
    StudioBff --> Preview
    StudioBff --> KExp
    StudioBff --> AgentFlow
    StudioBff --> Notif

    Dash --> CP
    Dash --> OBS
    AgentFlow --> AM
    KExp --> KP
    Preview --> KP
    Review --> CP
    Review --> GOV
    StudioBff --> MKT

    RTG -->|subscribes| CP
    RTG -->|subscribes| AM
    RTG -->|subscribes| OBS

    Review --> SQL
    Notif --> SQL
    Dash --> Redis
    RTG --> Redis
Hold "Alt" / "Option" to enable pan & zoom

Implemented

The client foundation is real today and is the basis of the final-state experience:

  • Host shell — ConnectSoft.Blazor.ShellTemplate composes microfrontends, owns routing, layout, and the authenticated session.
  • Microfrontends — ConnectSoft.Blazor.MicrofrontendLibraryTemplate plus shipped MFEs Blazor.Mfe.AIChat, Identity.Admin, Identity.SelfService, AuthorizationServer.Admin, and Logistics.
  • Components — ConnectSoft.Blazor.UIKit provides the shared component system.
  • Real-time — ConnectSoft.Extensions.Saas.AspNetCore.SignalR provides the multi-tenant SignalR substrate behind the realtime gateway.
  • Auth — ConnectSoft.AuthorizationServerTemplate (OpenIddict) issues the tokens the Studio and its BFFs validate.
  • Mobile — ConnectSoft.MauiBaseTemplate is the basis for an optional mobile companion.

The 13 final-state factory modules and the 8 ConnectSoft.Factory.Studio.* BFF services are the designed extension of this proven foundation. See the current implementation under AI Software Factory Studio.

Integration with Other Platforms

flowchart LR
    Studio["Factory Studio"] -->|"read models, commands"| CP["Control Plane"]
    Studio -->|"flow + execution queries"| AM["Agent Mesh"]
    Studio -->|"lineage, graph, artifact bodies"| KP["Knowledge Platform"]
    Studio -->|"metrics, traces, signals"| OBS["Observability &amp; Feedback"]
    Studio -->|"policy checks, audit"| GOV["Governance, Security &amp; Compliance"]
    Studio -->|"asset browse + install intent"| MKT["Marketplace"]
    CP -->|"lifecycle events"| Studio
    AM -->|"task + decision events"| Studio
    OBS -->|"runtime signals"| Studio
    Studio -->|"ReviewApproved, AgentDecisionOverridden"| CP
Hold "Alt" / "Option" to enable pan & zoom
Platform Studio receives Studio provides
Control Plane Project, blueprint, workflow, and task lifecycle state and events Human review decisions, overrides, escalations as commands/events
Agent Mesh Agent task graphs, execution traces, skill runs Operator pause/resume/redirect intents on flows
Knowledge Platform Artifact bodies, lineage, knowledge graph neighbourhoods View/query telemetry (which knowledge is consulted by humans)
Observability & Feedback Metrics, traces, runtime signals, cost data Human feedback items and annotations
Governance, Security & Compliance Policy decisions, classification, audit sink Audited user actions and review outcomes
Marketplace Installable assets, plans, entitlements Install/configure intents from the Install Center

Final-State Summary

The Factory Studio is the multi-tenant command center of the ConnectSoft AI Software Factory. In its final state it comprises a Blazor microfrontend experience of 13 UI modules over 8 ConnectSoft.Factory.Studio.* BFF and gateway services and 7 aggregate roots, persisting Studio-owned state in Azure SQL/PostgreSQL and Redis, streaming live change over SignalR, and authenticated by OpenIddict. It deliberately owns no factory truth — it aggregates the source-of-truth platforms into governed, tenant-scoped read models, and writes back only the human-authority decisions that keep an autonomous factory accountable. It is the surface that turns traceability, reusability, autonomy, governance, observability, and multi-tenant scale into something a person can see and act on.