Architecture

In-tenant. Azure-native. Governed by design.
AI Fabrix runs entirely inside your Azure tenant, using your identity, network, and security boundaries.

CIP enforces identity and policy at the dataplane boundary, before data ever reaches AI.

Getting Started
  • Deploy from Azure Marketplace – Provision baseline stack in your Azure tenant.
  • Integrate Data Sources – Connect SharePoint, Teams, CRM, ERP, HR, Finance.
  • Configure Identity & Governance – Enable Entra ID SSO, RBAC, audit controls.
  • Build Workflows & Applications – Use Flowise and OpenWebUI to create use cases.
  • Scale Securely – Move from Dev → Test → Prod environments with predictable ROI.
    Document Single Image
    Platform Overview

    AI Fabrix is an enterprise AI control and execution fabric that runs entirely inside your Azure tenant. It extends Microsoft’s cloud and AI services with the governance, identity, and environment control required to move AI from pilots to production — safely and predictably.

    Unlike external SaaS AI platforms, AI Fabrix does not copy data, bypass identity systems, or introduce hidden control planes. All AI agents, workflows, and integrations operate using your existing Azure infrastructure, Entra ID identities, and security boundaries.

    At the center of the platform is Miso Controller — the enterprise control plane that governs identity, access, environments, policies, and audit across all AI workloads.

    Document Single Image
    Miso Controller – Enterprise AI Control Plane

    Miso Controller is the governance layer of AI Fabrix. It separates control from execution, ensuring that AI runtimes remain lightweight while all enterprise rules are enforced consistently.

    Miso centrally manages:

    • Identity and group-based access
    • Environment lifecycle (Dev → Test → Prod)
    • Application roles and permissions
    • Policy evaluation and audit logging

      This allows AI to operate under the same identity, permission, and compliance rules as human users — without duplicating RBAC logic across tools.

      Environment-Aware Authorization

      AI Fabrix introduces an environment-first authorization model designed for enterprise delivery.

      Applications define their roles and permissions once. Miso binds those roles to enterprise identity groups per environment, allowing different access levels in Development, Test, and Production.

      This enables:

      • Full experimentation in Dev
      • Controlled validation in Test
      • Least-privilege execution in Production

      —all without rewriting access logic or maintaining separate identity models per tool.

      Identity-First, Standards-Based by Design

      AI Fabrix integrates with enterprise identity providers using open standards:

      • OpenAPI (via CIP) – Standardized System Integration
      • OIDC (OpenID Connect) – Enterprise Authentication
      • SCIM – Automated Identity & Group Provisioning
      • MCP (Model Context Protocol) – Governed AI Actions
      Governed AI Agents & Actions

      AI Fabrix enables AI to perform real enterprise actions — safely.

      AI agents cannot directly modify enterprise systems. All write actions are routed through Miso’s governed execution layer, where permissions are evaluated and every action is logged.

      This ensures:

      • Approved actions only
      • Full auditability
      • No uncontrolled automation

      AI doesn’t bypass governance — it enforces it.

      Metadata-Driven AI & Permission-Aware RAG

      AI Fabrix enables attribute-based access control (ABAC) using business metadata.Labels derived from CRM, collaboration, and HR systems are used to enforce permission-aware retrieval across documents and vectors. AI responses are generated using only the data the user is allowed to see — in context.

      This enables safe, explainable Retrieval-Augmented Generation at enterprise scale.

      Production Readiness

      AI Fabrix is designed for production deployment, not experimentation.

      • Environment lifecycle management
      • Controlled promotion of agents and workflows
      • Consistent identity and policy enforcement
      • Predictable scaling and infrastructure-based costs

      What works in pilot works in production — without redesign.

      Compliance & Trust

      Every AI action is logged, auditable, and traceable.

      AI Fabrix aligns with ISO-27001 principles and supports regulated industries by providing centralized audit logs, policy decision tracking, and environment-level observability — all inside the customer tenant.

      Open Standards. No Lock-In. Full Control.

      AI Fabrix is built on open, proven standards such as OpenAPI, OIDC, SCIM, and MCP. Customers retain full ownership of their infrastructure, data, and exit strategy — always.

      Document Single Image
      Architectural Principles
      • In-tenant by default: no shared SaaS control plane, no external data boundarycrossings.
      • Separation of concerns:
        - Control Plane (Miso) governs identity, policy, lifecycle, audit
        - Dataplane supplies AI-ready data through CIP (ComposableIntegration Pipelines).
        - Orchestration builds workflows/agents using governed tools.
        - Enterprise UX provides secure user interaction and collaboration.
      • Open standards only:
        - OpenAPI for system-to-system integration contracts
        - MCP for agent-to-pipeline tool access
      • No proprietary SDK lock-in: integrations remain inspectable and portable.
      Core Building Blocks

      Control Plane — MisoCIP

      Controls who can do what, where, and under which policies:

      • Entra ID SSO, RBAC/ABAC enforcement, policy packs (egress, quotas,compliance)
      • Environment lifecycle: Dev Test Prod
      • Audit, observability, governance reporting

      Dataplane — CIP + Retrieval

      Supplies governed, contextual data to AI:

      • CIP executes integrations inside the tenant (no service accounts)
      • Metadata normalization + lineage
      • Permission-aware retrieval (vector + metadata filtering)

      Orchestration — Microsoft Copilot, Flowise

      • Builds agents and workflows
      • Uses Dataplane outputs as governed tools and data sources
      • Versioned deployment through platform governance (via Miso)

      Orchestration — Microsoft Copilot, Flowise

      • Builds agents and workflows
      • Uses Dataplane outputs as governed tools and data sources
      • Versioned deployment through platform governance (via Miso)

      Enterprise UX — Microsoft Copilot, OpenWebUI

      • Secure chat + collaboration
      • Workspace controls, RBAC, audit logs
      • Safe human-in-the-loop interaction
      Reference Architecture Diagram

      Existing one

      How a Typical Request Flows

      1. User signs in via Entra ID (identity + groups + conditional access).
      2. OpenWebUI starts a governed interaction (workspace + role context).
      3. Flowise orchestrates the request and calls tools via MCP/OpenAPI contracts.
      4. Dataplane (CIP + Retrieval) supplies only permission-appropriate data, withmetadata filtering and lineage.
      5. Miso enforces policy consistently (egress, quotas, environment controls) andrecords audit/telemetry.
      6. Result is returned with governed context, suitable for regulated workflows.
      What Architects Usually Validate
      • Data never leaves the tenant unless explicitly allowed by policy.
      • No service accounts as the default integration model.
      • Per-user authorization is enforced at the dataplane boundary (not in appcode).
      • Auditing is deterministic (who accessed what, via which pipeline, underwhich policy).
      • OpenAPI + MCP provide standard, portable tool contracts.
      Diagram showing a governed AI dataplane where users and systems connect through CIP pipelines, enabling identity-aware access, policy enforcement, and audit-controlled execution across enterprise data and AI agents.
      How to Read This Diagram

      1. Identity Is Established First

      • Authentication happens via Entra ID
      • Identity claims travel with the request
      • No anonymous or system-level access paths exist

      2. Policy Is Evaluated Centrally

      • Miso evaluates RBAC, ABAC, environment, and egress rules
      • Decisions are deterministic and auditable
      • No policy logic is embedded in applications or workflows

      3. CIP Supplies Data, Not Systems

      • CIP executes inside the tenant
      • Integrations do not bypass identity
      • No service accounts are used as a default pattern

      4. Retrieval Is Permission-Aware

      • Filtering happens using metadata + identity context
      • AI never sees data it should not see
      • Lineage and scope are preserved

      5. Response Is Governed by Design

      • The response reflects what the user is allowed to know
      • Audit records already exist — no reconstruction required
      • Same flow applies to humans, APIs, and AI agents
      Complementing Microsoft, Not Competing

      Microsoft delivers powerful AI services such as Microsoft Copilot, Azure OpenAI, and Azure AI Search. These are essential building blocks — but by themselves, they do not provide the full enterprise AI fabric.
      AI Fabrix is not a competitor to Microsoft. Instead, it complements Microsoft by adding the missing enterprise control layer: governance, metadata-aware retrieval, and predictable economics — all running in your own Azure tenant.

      Document Single Image
      Why This Matters

      - Copilot is user-facing: It provides productivity features inside Office, Teams, and Dynamics, but it is limited to those applications.

      - Fabrix is platform-level: It governs, orchestrates, and secures all enterprise AI workloads across Microsoft 365 and beyond.

      This distinction allows enterprises to use Copilot for personal productivity while relying on Fabrix for governed, organization-wide AI adoption.

      The Work Gap Without Fabrix

      Many CIOs report that using Copilot alone requires a lot of manual work:

      - Custom connectors must be coded and maintained separately.
      - Compliance, audit, and quota enforcement are missing.
      - No central governance across AI pipelines.
      - Cross-system knowledge retrieval needs heavy custom development.

      Fabrix fills these gaps out of the box, turning Microsoft’s AI services into an enterprise-ready platform.

      Complementing Microsoft
      Feature / Dimension
      Microsoft Copilot
      AI Fabrix (Inside Azure)
      Deployment
      Microsoft CopilotSaaS, hosted by Microsoft
      AI Fabrix (Inside Azure)Runs fully inside customer’s Azure tenant (no external SaaS)
      Scope
      Microsoft CopilotProductivity apps (Word, Excel, Outlook, Teams, Dynamics)
      AI Fabrix (Inside Azure)Enterprise-wide platform: connectors, RAG pipelines, multi-app integration
      Data Control
      Microsoft CopilotData flows through Microsoft SaaS services
      AI Fabrix (Inside Azure)Data stays in customer’s tenant, stored in Azure resources (Key Vault, VNet, Storage)
      Identity & Permissions
      Microsoft CopilotTied to Microsoft 365 apps; limited cross-system inheritance
      AI Fabrix (Inside Azure)Entra ID integration, SCIM, RBAC across apps, connectors, and custom workflows
      Retrieval (RAG)
      Microsoft CopilotPre-built, app-specific retrieval only
      AI Fabrix (Inside Azure)Metadata-aware, policy-aware retrieval across SharePoint, Teams, CRM, ERP, DBs, files
      Governance & Compliance
      Microsoft CopilotBasic tenant settings, but no AI-specific policy packs
      AI Fabrix (Inside Azure)Full governance: audit trails, quotas, policy-as-code, ISO-27001 aligned
      Customization & Extensibility
      Microsoft CopilotLimited to Microsoft app ecosystem
      AI Fabrix (Inside Azure)SDK & plugin framework; extensible connectors and workflows; no vendor lock-in
      Observability
      Microsoft CopilotMinimal insights into usage/cost
      AI Fabrix (Inside Azure)Centralized logs, metrics, traces, cost telemetry, correlation IDs
      Economics
      Microsoft CopilotPer-license SaaS subscription
      AI Fabrix (Inside Azure)Predictable tiers + direct Azure billing (transparent cost control)
      Use Case Fit
      Microsoft CopilotIndividual productivity boost
      AI Fabrix (Inside Azure)Enterprise AI fabric: business cases, policy-aware assistants, cross-system orchestration

      Use Cases

      AI Fabrix enables enterprises to build secure, policy-aware AI solutions on top of Microsoft services. Its in-tenant design, metadata-aware retrieval, and governance features make it ideal for scenarios where compliance and business value must go hand in hand.

      Document Single Image
      Microsoft 365 Knowledge Retrieval

      Fabrix integrates with SharePoint, Teams, and OneDrive to deliver permission-aware retrieval. Users only access the documents and messages they are entitled to, reducing compliance risks.

      This allows organizations to create internal knowledge assistants that scale across departments while maintaining security and access integrity.

      Policy-Aware Assistants

      OpenWebUI provides a space for teams to build cases collaboratively. Users can attach evidence from SharePoint, Teams, CRM, or ERP systems, while Fabrix enforces audit logging and access controls.

      This turns conversational AI into a secure workspace for compliance-driven processes like investigations, audits, and legal reviews.

      Unlike generic chatbots, Fabrix enables the creation of assistants with built-in policy enforcement. These assistants apply enterprise rules to every interaction, ensuring outputs comply with governance, security, and regulatory standards.

      They are particularly valuable in regulated industries such as finance, healthcare, and the public sector.

      Secure Case Building & Collaboration
      Sales & Project Workspaces

      Fabrix can support sales and delivery teams by creating workspace assistants linked to deals or projects. These workspaces aggregate documents, meeting transcripts, and evidence, making it easier to collaborate and prepare business cases.

      Integration with CRM systems ensures that AI-powered insights are contextualized and policy-aware.

      Generic Chatbots vs. Fabrix Use Cases
      Document Single Image

      This diagram shows the contrast:

      Generic chatbots answer questions but lack governance, policy, or compliance guarantees.

      Fabrix use cases are structured, governed, and directly tied to enterprise processes.

      Use Cases — Summary & Enterprise Outcomes

      AI Fabrix extends Microsoft 365 and Azure with enterprise-ready AI use cases that are secure, policy-aware, and directly tied to business outcomes.
      By combining metadata-aware retrieval, governance enforcement, and collaborative workspaces, Fabrix moves AI adoption beyond pilots and into production-grade solutions.

      Why This Matters (Architect View)

      This sequence shows why AI Fabrix scales safely:

      • Governance is structural, not procedural
      • Identity is never dropped
      • Data access is contextual, not static
      • AI does not introduce exception paths

      This is the difference between using AI and deploying AI at enterprise scale.

      Traditional Enterprise AI Stacks vs AI Fabrix.

      The difference between AI Fabrix and traditional stacks is not capability.It is where failure modes are allowed to exist.

      Traditional stacks allow failure by design.AI Fabrix removes failure structurally.

      1. Identity Loss

      Traditional AI Stacks
      AI Fabrix
      User identity is dropped early in the request flow
      Identity is preserved end-to-end
      Service accounts and API keys represent many users
      Every request carries user context
      AI operates as a privileged system actor
      AI acts strictly on behalf of an authenticated identity

      What breaks traditionally

      • Over-exposure of data
      • Impossible audits
      • “Who accessed this?” cannot be answered

      Why Fabrix holds

      • Identity is the primary execution context
      • No default system-level access exists

      2. Permission Leakage

      Traditional AI Stacks
      AI Fabrix
      Permissions enforced in application code
      Permissions enforced in the data plane
      Filtering logic duplicated per app
      One structural enforcement model
      Edge cases create data leaks
      No exception paths exist

      What breaks traditionally

      • Security bugs scale with integrations
      • AI answers expose sensitive data

      Why Fabrix holds

      • Data is supplied already filtered
      • AI never sees unauthorized content

      3. Governance Drift

      Traditional AI Stacks
      AI Fabrix
      Governance configured manually per system
      Governance embedded by design
      Policies differ across tools
      One policy model everywhere
      Compliance requires negotiation
      Compliance is deterministic

      What breaks traditionally

      • AI pilots stall at security review
      • Production differs from approved design

      Why Fabrix holds

      • Governance is not optional or repeatable — it is structural

      4. Audit Reconstruction

      Traditional AI Stacks
      AI Fabrix
      Audit trails are incomplete
      Auditability is automatic
      Data lineage must be reconstructed
      Lineage exists by default
      Compliance reviews are forensic
      Compliance is explainable

      What breaks traditionally

      • Audits become expensive investigations
      • Trust in AI outputs erodes

      Why Fabrix holds

      • Every interaction is already logged, scoped, and traceable

      5. Service Account Sprawl

      Traditional AI Stacks
      AI Fabrix
      Integrations rely on service accounts
      No default service accounts
      Privileges are static and over-scoped
      Access is contextual and dynamic
      Credentials become high-value targets
      Identity is delegated per request

      What breaks traditionally

      • Elevated access persists indefinitely
      • Breach impact is systemic

      Why Fabrix holds

      • Execution always occurs within user authority

      6. AI Exception Paths

      Traditional AI Stacks
      AI Fabrix
      AI requires special access rules
      AI follows the same rules as humans
      “Temporary” exceptions become permanent
      No exception paths exist
      Risk scales with intelligence
      Risk remains bounded

      What breaks traditionally

      • AI deployments are blocked by security
      • Or worse, approved with unsafe exceptions

      Why Fabrix holds

      • AI is a first-class governed actor

      7. Integration Fragility

      Traditional AI Stacks
      AI Fabrix
      Custom code per integration
      Declarative, standardized pipelines
      Changes break downstream systems
      Changes are isolated structurally
      Integrations are opaque
      Integrations are inspectable and auditable

      What breaks traditionally

      • Integration maintenance dominates cost
      • AI initiatives slow over time

      Why Fabrix holds

      • Integrations are part of the governed dataplane

      8. Platform Sprawl

      Traditional AI Stacks
      AI Fabrix
      Each team adopts its own AI tooling
      One enterprise AI operating model
      Governance differs by team
      Governance scales automatically
      Costs and risk multiply
      Costs and risk are predictable

      What breaks traditionally

      • AI becomes unmanageable at scale
      • Enterprise architecture fragments

      Why Fabrix holds

      • Standardization is structural, not enforced by policy
      Summary: Where Failure Is Allowed

      Traditional stacks fail because they allow failure to exist:

      • In identity handling
      • In permissions
      • In integrations
      • In governance enforcement

      AI Fabrix succeeds because those failure modes are removed by design.

      This is not an implementation choice.It is an architectural one.

      Traditional AI stacks ask teams to avoid failure.
      AI Fabrix makes failure structurally impossible.