Before You Put a Fabric AI Agent in Production, Steal This Checklist

use case.

2. Define Bounded Operational Scope

An agent must have a clearly defined operational boundary. "Answer questions about data" is not a valid scope. The scope should be restricted to specific business workflows and curated data assets.

Implementation Rationale:

• Risk Containment: Limiting the agent to a specific Semantic Model or a subset of tables reduces the impact of prompt injection or misinterpretation.
• Performance: Narrow scopes reduce context window overhead and improve response latency.

3. Enforce Data Source Inventory and Mapping

Every data source accessible by the agent must be cataloged. This includes the workspace, asset type, access level, and business owner. This inventory defines the agent's blast radius.

Implementation Rationale:

• Compliance: Regulators require knowledge of which systems AI workloads can access.
• Change Impact: When a data source changes, the inventory allows you to identify affected agents immediately.

4. Isolate Environments

Development, testing, and production must use distinct workspaces and identities. Sharing resources across environments leads to data leakage and configuration drift.

Implementation Rationale:

• Safety: Experiments in dev cannot corrupt production data or consume production quotas.
• Validation: Test environments allow for regression testing of agent behavior against known datasets.

5. Codify Governance with TypeScript

The following code example demonstrates a governance validation framework. This tool enforces the rules above during the deployment pipeline, preventing non-compliant configurations from reaching production.

// governance/types.ts

export type FabricAssetType = 'SemanticModel' | 'Eventhouse' | 'Lakehouse' | 'Warehouse';
export type AccessLevel = 'ReadOnly' | 'Operational';

export interface ServicePrincipalIdentity {
    type: 'ServicePrincipal';
    appId: string;
    tenantId: string;
    secretRotationDays: number; // Must be <= 90
}

export interface DataAssetBinding {
    workspaceId: string;
    assetType: FabricAssetType;
    assetId: string;
    accessLevel: AccessLevel;
    businessOwnerEmail: string;
    lastReviewDate: string; // ISO date string
}

export interface AgentConfiguration {
    agentId: string;
    identity: ServicePrincipalIdentity;
    scope: {
        useCase: string; // e.g., "Sales Variance Analysis"
        allowedAssets: DataAssetBinding[];
    };
    environment: 'Dev' | 'Test' | 'Production';
    auditConfig: {
        enabled: boolean;
        logLevel: 'Info' | 'Debug' | 'Trace';
    };
}

// governance/validator.ts

export class AgentGovernanceValidator {
    
    validate(config: AgentConfiguration): ValidationResult {
        const errors: string[] = [];
        const warnings: string[] = [];

        // 1. Identity Validation
        if (config.identity.type !== 'ServicePrincipal') {
            errors.push('CRITICAL: Agent must use ServicePrincipal identity. User accounts are prohibited in production.');
        }
        if (config.identity.secretRotationDays > 90) {
            errors.push('CRITICAL: Secret rotation policy exceeds 90 days.');
        }

        // 2. Scope Validation
        if (!config.scope.useCase || config.scope.useCase.length < 10) {
            errors.push('CRITICAL: Use case must be a specific, bounded description.');
        }
        
        if (config.scope.allowedAssets.length === 0) {
            errors.push('CRITICAL: Agent must have at least one allowed data asset.');
        }

        // 3. Data Asset Validation
        for (const asset of config.scope.allowedAssets) {
            if (asset.accessLevel === 'Operational' && config.environment === 'Production') {
                warnings.push('WARNING: Operational access in Production requires explicit approval.');
            }
            
            const daysSinceReview = this.daysSince(asset.lastReviewDate);
            if (daysSinceReview > 180) {
                warnings.push(`WARNING: Asset ${asset.assetId} has not been reviewed in ${daysSinceReview} days.`);
            }
        }

        // 4. Environment Validation
        if (config.environment === 'Production' && !config.auditConfig.enabled) {
            errors.push('CRITICAL: Audit logging must be enabled for Production agents.');
        }

        return {
            isValid: errors.length === 0,
            errors,
            warnings
        };
    }

    private daysSince(dateStr: string): number {
        const date = new Date(dateStr);
        const now = new Date();
        return Math.floor((now.getTime() - date.getTime()) / (1000 * 3600 * 24));
    }
}

export interface ValidationResult {
    isValid: boolean;
    errors: string[];
    warnings: string[];
}

Architecture Decisions:

• Strict Typing: The AgentConfiguration interface forces developers to define identity, scope, and audit settings explicitly.
• Pipeline Integration: The AgentGovernanceValidator should run as a step in the CI/CD pipeline. If isValid is false, deployment is blocked.
• Review Tracking: The lastReviewDate field ensures data access is periodically re-validated, addressing the "set and forget" anti-pattern.

Pitfall Guide

Production AI agents fail due to operational oversights, not just model inaccuracies. The following pitfalls are common in Fabric deployments and their mitigations.

Pitfall	Explanation	Fix
Human Credential Dependency	Agent uses a developer's account. When the developer leaves or changes roles, the agent breaks or retains excessive access.	Enforce Service Principal usage via governance validation. Bind permissions to the SPN, not the user.
Scope Creep	Stakeholders request additional data sources without review. The agent's blast radius expands uncontrollably.	Treat every new data source as a change request. Re-run governance validation and update the asset inventory.
Audit Blackout	No logs exist to trace which data source provided context for a specific answer. Root-cause analysis is impossible.	Enable structured audit logging. Include trace IDs, asset IDs, and identity used in every telemetry event.
Environment Bleed	Dev and Prod share a workspace or identity. Experimental prompts or test data leak into production.	Enforce strict workspace isolation. Use distinct SPNs per environment. Validate environment tags in config.
Static Permissions	Permissions are granted once and never reviewed. Over time, the agent accumulates access to deprecated or sensitive data.	Implement periodic access reviews (e.g., quarterly). Use the lastReviewDate field to trigger alerts for stale permissions.
Blast Radius Ignorance	Agent has access to a Lakehouse containing PII, but the use case only requires aggregated metrics.	Map data classification to assets. Restrict agent access to curated views or Semantic Models that enforce row-level security.
Cost Drift	Agent queries are unbounded, leading to unexpected capacity unit consumption in Eventhouse or Warehouse.	Implement query quotas and rate limiting. Monitor capacity unit usage per agent and set alerts for anomalies.

Production Bundle

Action Checklist

Use this checklist to validate readiness before promoting a Fabric AI Agent to production.

• Provision Service Principal: Create a dedicated SPN for the agent. Ensure secret rotation policy is ≤90 days.
• Define Bounded Use Case: Document a specific operational scope (e.g., "Inventory Reconciliation for Region A"). Reject vague scopes.
• Map Data Sources: List all accessible assets (Semantic Models, Eventhouse, Lakehouse, Warehouse). Record workspace, asset ID, access level, and business owner.
• Enforce Least Privilege: Grant the SPN only the permissions required for the defined scope. Avoid workspace-level admin roles.
• Isolate Environments: Deploy to a dedicated Production workspace. Ensure Dev/Test workspaces are separate.
• Enable Audit Logging: Configure telemetry to capture identity, asset access, query details, and response metadata.
• Establish Change Process: Define a workflow for adding new data sources. Require governance re-validation for all changes.
• Review Cost Controls: Set capacity unit budgets and alerts. Monitor query patterns for anomalies.

Decision Matrix

Select the appropriate governance approach based on deployment characteristics.

Scenario	Recommended Approach	Why	Cost Impact
Read-Only Analytics Agent	Service Principal + Semantic Model Access	Semantic Models enforce RLS and aggregation. Low risk of data modification.	Low. Semantic Model queries are optimized.
Operational Agent (Write-Back)	Service Principal + Warehouse/Lakehouse + Strict Scope	Write access requires higher scrutiny. Limit to specific tables and operations.	Medium. Operational queries may consume more CU.
Multi-Workspace Agent	Cross-Workspace SPN + Centralized Audit	Agents spanning workspaces need unified identity and logging.	High. Complexity increases; audit storage costs rise.
High-Volume Consumer	Dedicated Capacity + Rate Limiting	Shared capacity may throttle high-usage agents. Dedicated ensures SLA.	High. Dedicated capacity incurs fixed costs.

Configuration Template

Copy this YAML template to define your agent's governance configuration. This file should be version-controlled and validated by your CI/CD pipeline.

agent:
  id: "fabric-agent-sales-variance-prod"
  environment: "Production"
  
identity:
  type: "ServicePrincipal"
  appId: "${AGENT_SPN_APP_ID}"
  tenantId: "${TENANT_ID}"
  secretRotationDays: 90

scope:
  useCase: "Explain sales variance for Q3 using governed Semantic Model"
  allowedAssets:
    - workspaceId: "ws-sales-prod"
      assetType: "SemanticModel"
      assetId: "sm-sales-curated"
      accessLevel: "ReadOnly"
      businessOwnerEmail: "finance-lead@company.com"
      lastReviewDate: "2024-09-15"

audit:
  enabled: true
  logLevel: "Info"
  destination: "LogAnalyticsWorkspace"
  retentionDays: 365

governance:
  changeRequestRequired: true
  maxAssets: 3
  requireBusinessOwnerApproval: true

Quick Start Guide

Get a governed Fabric AI Agent running in under 5 minutes.

1. Create Service Principal: Register an app in Entra ID. Generate a client secret. Note the App ID and Tenant ID.
2. Define Scope: Identify one narrow use case and one curated data source (e.g., a Semantic Model).
3. Generate Config: Use the Configuration Template above. Fill in your IDs and scope details.
4. Validate: Run the AgentGovernanceValidator against your config. Fix any errors or warnings.
5. Deploy: Assign the SPN to the Fabric workspace and data assets. Deploy the agent configuration. Enable audit logging.

By adhering to this framework, you transform the Fabric AI Agent from a fragile demo into a reliable, auditable, and secure production workload. The goal is not to impede innovation but to ensure that AI capabilities can be deployed with the confidence required for enterprise data operations.