Sensitivity Labels: Boost the Precision of Your AI Agents

AI Agent Governance: A Major Architectural Challenge

The large-scale deployment of AI agents and skills in Microsoft Fabric raises a fundamental question for cloud engineers and data architects: how does an agent know which data is relevant to answer a given query? Without an explicit guidance mechanism, an agent operates blind — it aggregates heterogeneous sources, mixes incompatible business contexts, and produces inaccurate or even compliance-problematic responses.

This challenge is not purely technical. It touches on data governance, separation of usage contexts, and the organization's ability to project its own classificatory intelligence into its AI systems. The good news: you probably already have the infrastructure needed to address it.

Sensitivity Labels: Much More Than a Protection Mechanism

Sensitivity labels are defined centrally in Microsoft Purview and can be applied to all Fabric artifacts: Power BI reports, Semantic Models, Lakehouses, Warehouses, and notebooks. Their traditional role is to classify data and enforce protection policies — encryption, export restrictions, watermarking, etc.

But their architecture also exposes an underexploited dimension: these labels are available via public APIs, which allows automated workflows and AI agents to access them programmatically. This point is central to understanding the pattern described in this article.

Architecture of Sensitivity Labels in Fabric

Here is how the classification system is organized in the Microsoft ecosystem:

• Microsoft Purview Information Protection: central point for defining labels (General, Confidential, Highly Confidential, or custom labels)
• Fabric REST API: exposes classification metadata on each artifact
• Power BI / Fabric SDK: allows programmatic reading and writing of labels
• AI Skills: orchestration layer where label-based rules are applied

Concrete Use Case: Report Analysis AI Skill

Let's consider a representative scenario from an enterprise environment. An organization deploys an AI Skill in Fabric whose mission is to analyze reports, extract insights, and answer business questions. The data corpus includes:

• Public reports (business performance metrics, operational dashboards) → General label
• Confidential reports (financial forecasts, client negotiations) → Confidential label
• Highly sensitive reports (executive strategy, M&A operations) → Highly Confidential label

Without integrated governance logic, the skill analyzes all reports indiscriminately. An employee asking the question "What are our Q3 projections?" could receive an answer mixing public and confidential data — which constitutes a real compliance risk.

Defining Processing Rules by Label

The target architecture consists of integrating explicit rules into the skill definition, based on sensitivity labels. Here is a structured representation of this logic:

1{
2  "skillName": "ReportAnalysisSkill",
3  "labelPolicies": [
4    {
5      "label": "General",
6      "actions": [
7        "full_analysis",
8        "include_charts",
9        "include_summaries",
10        "include_datapoints"
11      ],
12      "restrictions": []
13    },
14    {
15      "label": "Confidential",
16      "actions": [
17        "summary_only",
18        "extract_key_findings"
19      ],
20      "restrictions": [
21        "authorized_users_only",
22        "no_detail_exposure",
23        "log_access_audit"
24      ]
25    },
26    {
27      "label": "Highly Confidential",
28      "actions": [
29        "high_level_briefing_only"
30      ],
31      "restrictions": [
32        "executives_explicit_clearance",
33        "no_detailed_data",
34        "track_all_access",
35        "track_all_queries"
36      ]
37    }
38  ]
39}

Skill Behavior at Runtime

Here is how the skill behaves contextually depending on the nature of the query and the labels of the artifacts interrogated:

• General query ("What are our sales trends?") → The skill reads only reports labeled General and returns a complete analysis with visualizations and numerical data
• Query on budget forecasts → The skill verifies user permissions, accesses Confidential reports, and returns only a synthetic summary if the user is authorized
• Query on executive strategy → The skill declines the response or escalates to profiles with explicit authorization on Highly Confidential content

The employee retains access to all reports they are entitled to. What changes is the selection of inputs that the agent uses to construct its response.

Technical Implementation: Integration via the Fabric API

Programmatic retrieval of sensitivity labels to feed the logic of an AI Skill can be done via PowerShell or direct REST calls. Here is an example PowerShell script using the MicrosoftPowerBIMgmt module:

1# Install the module if necessary
2# Install-Module -Name MicrosoftPowerBIMgmt -Scope CurrentUser
3 
4# Authentication
5Connect-PowerBIServiceAccount
6 
7# Retrieve all datasets with their sensitivity labels (admin view)
8$datasets = Invoke-PowerBIRestMethod `
9  -Url "admin/datasets?\$expand=sensitivityLabel" `
10  -Method GET | ConvertFrom-Json
11 
12# Filter by label to identify Confidential artifacts
13$confidentialDatasets = $datasets.value | Where-Object {
14  $_.sensitivityLabel.labelId -ne $null -and
15  $_.sensitivityLabel.labelName -eq "Confidential"
16}
17 
18# Export the result for audit or ingestion by a skill
19$confidentialDatasets | Select-Object id, name, sensitivityLabel | 
20  ConvertTo-Json -Depth 3 | 
21  Out-File -FilePath ".\confidential_datasets_inventory.json" -Encoding UTF8
22 
23Write-Host "Inventory generated: $($confidentialDatasets.Count) Confidential datasets identified"

For more granular integration in a Fabric skill with direct REST call:

1# Retrieve access token via Azure CLI
2$token = (az account get-access-token --resource https://analysis.windows.net/powerbi/api | ConvertFrom-Json).accessToken
3 
4$headers = @{
5  "Authorization" = "Bearer $token"
6  "Content-Type"  = "application/json"
7}
8 
9# API call for a specific report
10$reportId = "<your-report-id>"
11$response = Invoke-RestMethod `
12  -Uri "https://api.powerbi.com/v1.0/myorg/reports/$reportId/sensitivityLabel" `
13  -Headers $headers `
14  -Method GET
15 
16$labelName = $response.sensitivityLabel.labelName
17Write-Host "Report label: $labelName"
18 
19# Routing logic based on label
20switch ($labelName) {
21  "General"           { Write-Host "Complete analysis authorized" }
22  "Confidential"      { Write-Host "Summary only - permission verification required" }
23  "Highly Confidential" { Write-Host "Restricted access - executive escalation required" }
24  default             { Write-Host "Unrecognized label - default processing applied" }
25}

Why Sensitivity Labels Improve AI Accuracy

A legitimate question arises: if the agent already has access to all authorized data, why worry about what it uses to construct its responses?

The answer is both technical and organizational. Large language models (LLMs) are sensitive to the context injected into their attention window. The broader and more heterogeneous the context, the greater the risk of semantic confusion — a phenomenon known as context pollution. By precisely selecting inputs according to their confidentiality label, you reduce noise and improve topical accuracy of responses.

From an organizational perspective, data classifications reflect accumulated business knowledge: the organization knows which data is generally useful, which is sensitive, and which belongs to specific contexts. Transmitting this classificatory intelligence to your AI agents gives them access to years of codified organizational experience.

Deployment Guide: Step-by-Step Implementation

1# Inventory of artifacts without sensitivity label
2Connect-PowerBIServiceAccount
3 
4$allDatasets = Invoke-PowerBIRestMethod `
5  -Url "admin/datasets?\$expand=sensitivityLabel" `
6  -Method GET | ConvertFrom-Json
7 
8$unlabeledDatasets = $allDatasets.value | Where-Object {
9  $null -eq $_.sensitivityLabel -or $null -eq $_.sensitivityLabel.labelId
10}
11 
12Write-Host "Unlabeled artifacts: $($unlabeledDatasets.Count)"
13$unlabeledDatasets | Select-Object id, name | ConvertTo-Json | Out-File ".\unlabeled_inventory.json"

1[KernelFunction("evaluate_sensitivity_label")]
2[Description("Evaluates the confidentiality label of an artifact and returns the authorized analysis level")]
3public async Task<string> EvaluateSensitivityLabelAsync(
4    [Description("ID of the Fabric artifact")] string artifactId,
5    [Description("Artifact type: report, dataset, lakehouse")] string artifactType)
6{
7    var label = await _fabricApiClient.GetSensitivityLabelAsync(artifactId, artifactType);
8    
9    return label?.LabelName switch
10    {
11        "General"             => "full_analysis",
12        "Confidential"        => "summary_only",
13        "Highly Confidential" => "restricted_executive_only",
14        _                     => "default_restricted"
15    };
16}

Reference Resources

To deepen your implementation of this pattern, consult the following official Microsoft resources:

• Information Protection in Microsoft Fabric — Official documentation on data protection architecture in Fabric
• Sensitivity Labels in Fabric — Complete guide on configuring and applying sensitivity labels
• Power BI REST API — SensitivityLabels — API reference for programmatic access to labels
• Microsoft Purview Information Protection — Portal for centralized label definition and management
• Semantic Kernel — Plugin development — Recommended framework for advanced AI agent integration with Fabric