Preparing Semantic Models for AI in Microsoft Fabric

Executive Summary

Microsoft Fabric is evolving from a unified analytics platform into an intelligence platform. At FabCon Atlanta 2026, Microsoft announced that Fabric now serves over 31,000 customers, including 90% of the Fortune 500, and its AI capabilities have moved from experimental bolt-ons to platform-integrated features.

The core message is clear: your semantic model is the foundation for AI. Whether you're enabling Copilot for Power BI, deploying Fabric Data Agents, leveraging AI Functions in notebooks, or preparing for Fabric IQ Ontology, the quality and structure of your semantic layer directly determines the quality of AI-generated outputs.

This guide provides a phased, practical framework for organizations at any stage of Fabric maturity to prepare their data estate for AI workloads.

Part 1: The AI Readiness Landscape in Microsoft Fabric

1.1 What "AI-Ready" Means in Fabric

AI readiness in Fabric is not a single feature toggle. It is the cumulative result of how well your data is modeled, described, governed, and exposed to AI services. Microsoft's architecture routes AI workloads through several pathways, each of which depends on semantic clarity.

Copilot in Power BI uses the semantic model's metadata (schema, descriptions, synonyms, relationships) plus "Prep for AI" configurations to generate DAX queries and answer natural language questions. The quality of Copilot's output is directly proportional to how well your model communicates its own structure.

Fabric Data Agents go further. They are standalone AI items that translate natural language into SQL, DAX, or KQL queries across lakehouses, warehouses, semantic models, KQL databases, and — as of recent updates — Ontology (Ignite 2025), Azure AI Search indexes for unstructured data (November 2025), and Graph for relationship-aware queries (March 2026). Data Agents reached general availability at FabCon Atlanta 2026, marking their transition from experimental to production-ready. They use a layered architecture where an Orchestrator evaluates which data source to query, then invokes specialized tools (DAX generation, NL2SQL) to produce answers. Critically, Data Agents generate only read-only queries — they cannot create, update, or delete data, which is an important security property. Since November 2025, Data Agents fully respect all "Prep for AI" customizations defined in semantic models.

Fabric IQ and Ontology, announced at Microsoft Ignite 2025 and expanded at FabCon Atlanta 2026, represent the next evolution: a shared semantic foundation that models business concepts, relationships, rules, and actions at the OneLake level. Ontologies enable AI agents to operate on shared business meaning rather than raw tables and schemas. At FabCon Atlanta, Microsoft announced that Ontology will become accessible through public MCP (Model Context Protocol) endpoints, enabling agents across the broader ecosystem to ground reasoning in a unified semantic layer.

1.2 The AI Workload Spectrum: Beyond Data Agents

Organizations often equate "AI in Fabric" with Data Agents alone. The actual landscape is substantially broader.

Copilot Experiences Across Workloads

Copilot is embedded across Data Factory (pipeline authoring), Data Engineering (notebook code generation), Data Warehouse (T-SQL authoring), Real-Time Intelligence (KQL generation), and Power BI (report creation, DAX explanation, data summarization). Each Copilot experience draws on item-level metadata for grounding.

Fabric AI Functions (Generally Available)

AI Functions provide single-line-of-code LLM-powered enrichments in notebooks. They work across both pandas and PySpark DataFrames. The GA functions include:

• ai.analyze_sentiment() — emotional state detection
• ai.classify() — custom label categorization
• ai.embed() — vector embedding generation
• ai.extract() — entity extraction
• ai.fix_grammar() — grammar correction
• ai.generate_response() — custom prompt responses
• ai.similarity() — semantic similarity scoring
• ai.summarize() — text summarization
• ai.translate() — language translation

At FabCon Atlanta 2026, Microsoft announced multimodal support (preview) enabling AI Functions to process images, PDFs, and text files, plus evaluation notebooks using LLM-as-a-Judge techniques with metrics like accuracy, precision, recall, and F1 score.

AI Functions consumption is now tracked as a separate operation in the Fabric Capacity Metrics app (as of March 17, 2026), billed under the Copilot and AI meter, distinct from Spark compute.

AI Functions in Data Warehouse (T-SQL)

The March 2026 release introduced built-in AI functions directly in Fabric Data Warehouse using T-SQL, enabling text extraction, classification, sentiment analysis, and transformation without leaving SQL. This is significant for organizations whose analysts operate primarily in SQL rather than notebooks.

GraphQL API with MCP Integration

Fabric's API for GraphQL exposes lakehouses, warehouses, and databases to AI agents through a standardized interface. Combined with MCP servers, AI assistants like GitHub Copilot, Claude, and other agents can discover schema structures via introspection and query Fabric data using natural language. At FabCon Atlanta 2026, the Fabric Local MCP server received production-grade enhancements including integrated authentication, automatic retry, production SLAs, and telemetry. It can be installed via npx @microsoft/fabric-mcp in any MCP-compatible client including VS Code, Claude Desktop, and Cursor.

Data Science Workload: ML Models and AutoML

The Data Science experience in Fabric supports full ML lifecycle management through MLflow integration, including experiment tracking, model registry, and deployment. AutoML reached a production-ready state with the March 2026 update, providing automated model selection, feature engineering, and hyperparameter optimization through a low-code UI. ML Model endpoints serve real-time predictions with Fabric-managed container infrastructure.

Fabric IQ: Ontology, Graph, Planning, and Operations Agents

Fabric IQ is the newest and most strategic workload, comprising Ontology (semantic business entity modeling), Fabric Graph (relationship-aware data modeling), Planning (budgets, forecasts, scenario models on semantic models), Data Agents, and Operations Agents (real-time business monitoring). While still in preview, Ontology represents Microsoft's long-term direction for unifying business semantics across analytics and AI. At FabCon Atlanta, Microsoft also announced a strategic partnership with NVIDIA to integrate Real-Time Intelligence and Fabric IQ with NVIDIA Omniverse for Physical AI scenarios.

Microsoft Foundry Integration

Fabric integrates with Microsoft Foundry (formerly Azure AI) for prebuilt models, custom model development, and inference. Foundry Tools are accessible directly from Fabric notebooks, with authentication handled automatically through the workspace.

Copilot Studio Multi-Agent Orchestration

Fabric Data Agents can be embedded as connected agents in Microsoft Copilot Studio, enabling multi-agent orchestration. One agent pulls data from Fabric, another drafts documents in M365, another schedules meetings. This agent-to-agent collaboration uses MCP for shared context and reasoning.

Purview Data Security Posture Management (DSPM) for AI

Introduced in the March 2026 release, DSPM for AI provides visibility into AI interactions, monitoring prompts and responses for sensitive data exposure, risky behavior, and compliance adherence across Copilot and Data Agent usage.

Power BI Modeling MCP Server

Released at Microsoft Ignite 2025 and currently in public preview, the Power BI Modeling MCP Server enables AI agents (GitHub Copilot, Claude, Cursor) to interact directly with semantic model definitions via TMDL. It supports bulk operations (renaming measures, generating descriptions, adding translations), DAX query execution and validation, and TMDL import/export for Git-based workflows. This is a significant productivity tool for AI-assisted semantic model development, though complex DAX generation remains unreliable and requires human review.

Part 2: Brownfield vs. Greenfield — What Changes

2.1 Brownfield: Preparing Existing Semantic Models for AI

Brownfield implementations face a fundamentally different challenge than greenfield: the models already exist, reports depend on them, and users have established workflows. The goal is to make existing models AI-ready without breaking current functionality.

Phase 1: Assessment and Inventory (Weeks 1–2)

Start with an honest assessment of your model estate.

Catalog all semantic models across workspaces. Identify which are Import, DirectQuery, DirectLake, or Composite. All Prep for AI features — including Verified Answers — support DirectLake mode. The real constraint for Fabric-native architectures is the 24-hour indexing cycle that governs when AI-facing metadata updates take effect.

For each model, evaluate the following AI-readiness dimensions:

• Naming Quality: Are table and column names business-friendly? DIM_GEO_01 fails; Sales Region succeeds. AI systems rely on names to interpret intent.
• Description Coverage: What percentage of tables, columns, and measures have descriptions? Descriptions are the single highest-impact metadata element for AI grounding.
• Measure Clarity: Are measure names self-explanatory? Does TR_AMT mean Total Revenue Amount, or something else entirely?
• Relationship Completeness: Are all join paths defined? Missing relationships force AI to guess at data connections.
• Schema Scope: How many tables and columns exist? Large, unfocused models degrade AI accuracy. The AI performs best on focused, domain-specific subsets.
• Synonym Coverage: Have you defined synonyms and linguistic relationships? These help Copilot understand alternative phrasings.

Phase 2: Metadata Enrichment (Weeks 2–4)

This is the highest-ROI activity for brownfield AI readiness.

Add descriptions to every table, column, and measure that will be exposed to AI. Descriptions should be written for a business user, not a developer. For measures, describe what the calculation returns, what filters it respects, and any important caveats.

Rename cryptic columns and tables where feasible. For columns where renaming would break downstream reports, use synonyms instead. Synonyms can be configured in the semantic model and are consumed by both Copilot and Data Agents.

Configure display folders to organize measures logically. While display folders don't directly impact AI query generation, they improve the human curation process and make schema review more manageable.

Review relationships for completeness and correctness. Ambiguous or missing relationships are a common source of incorrect AI-generated DAX.

Phase 3: Prep for AI Configuration (Weeks 3–5)

"Prep for AI" is the primary control surface for tuning how AI interprets your semantic model. Access it from the Home ribbon in Power BI Desktop or in the Power BI Service.

Configure the AI Data Schema by selecting only the tables, columns, and measures that AI should use. This is critical: reducing the schema scope improves accuracy and reduces response latency. Exclude internal-use tables, staging columns, and deprecated measures. The DAX generation tool used by Data Agents relies solely on this schema; unselected items are invisible to AI.

Write AI Instructions that describe how the data should be interpreted. Include business terminology definitions, abbreviations, preferred analysis patterns, and which tables/columns map to which types of questions. Include example DAX queries that return correct results for common questions. Test these in DAX Query View first to validate correctness, then embed them in AI Instructions.

Create Verified Answers for your most common and most critical questions. Verified Answers link specific questions to specific visuals, providing a deterministic fallback for high-stakes queries. The Data Agent uses the visual's metadata (columns, measures, filters) to influence DAX generation when a verified answer matches.

Phase 4: Tag, Endorse, and Publish (Week 5)

After configuring Prep for AI, publish the model to the Power BI Service. In the semantic model settings, tag it as AI-prepared. Consider adopting a formal endorsement workflow: models that pass AI readiness criteria receive "Promoted" or "Certified" status, signaling to consumers that the model produces reliable AI-driven answers.

2.2 Greenfield: Designing Semantic Models for AI from Day One

Greenfield implementations have the advantage of designing with AI as a first-class requirement from the start. The architectural decisions are different.

Design Principle 1: Domain-Scoped Models

Instead of building a single monolithic semantic model that spans every business domain, design focused, domain-specific models. A model dedicated to Sales Analytics with 15–25 relevant tables will produce dramatically better AI results than a 200-table enterprise model. Data Agents can connect to multiple data sources (up to five), so composability replaces comprehensiveness.

Design Principle 2: Business-First Naming Convention

Establish naming conventions that prioritize AI interpretability. Table names should be singular, descriptive nouns (e.g., Customer, Sales Order, Product). Column names should be self-documenting (e.g., Order Date, Total Revenue, Customer Region). Measures should include the aggregation type and business context (e.g., Total Revenue YTD, Average Order Value).

Design Principle 3: Description-Driven Development

Treat descriptions as required, not optional. Build description authoring into your development workflow. Every table, column, and measure should have a description before the model is published. Use Copilot in DAX Query View to generate initial descriptions, then refine them manually.

Design Principle 4: DirectLake AI Optimization

For Fabric-native architectures, DirectLake is the preferred storage mode — all Prep for AI features, including Verified Answers, are fully supported. Maximize AI accuracy by combining Verified Answers with detailed AI Instructions and highly specific example DAX queries covering your most critical business questions. Account for the 24-hour indexing cycle when planning metadata update rollouts.

Design Principle 5: Ontology-Forward Architecture

Even though Fabric IQ Ontology is in preview, greenfield implementations should architect with ontology in mind. This means: defining clear business entities and their relationships at the conceptual level (before physical modeling), establishing consistent terminology across models, and documenting business rules that could eventually be encoded as ontology constraints. When Ontology reaches GA, models designed with these principles will map cleanly to the ontology framework.

Design Principle 6: Multi-Surface Consumption Design

Design your semantic model knowing it will be consumed by Power BI reports, Copilot, Data Agents, Copilot Studio agents, and potentially Ontology-grounded experiences simultaneously. This means: hide internal-use columns, ensure all user-facing elements have descriptions, and validate that your model works well for both visual-based (report) and text-based (natural language Q&A) consumption patterns.

Part 3: The Step-by-Step Data Readiness Framework

Step 1: Foundation — Data Quality and Governance

AI amplifies whatever is in your data, including errors. Before any AI enablement, ensure your data foundation is solid.

Data Quality in Fabric is managed through Microsoft Purview Unified Catalog, which supports AI-powered data profiling, no-code rule creation across six dimensions (completeness, consistency, conformity, accuracy, freshness, uniqueness), and multi-level scoring. Custom SQL expression rules reached GA in March 2026, and incremental scanning entered preview in February 2026. Error record publishing (GA as of February 2026) enables review and correction of quality failures.

At minimum, validate: referential integrity across fact-dimension relationships, completeness of key business columns (no unexpected NULLs in dimensions used for filtering), freshness of data (stale data produces stale AI answers), and uniqueness of business keys.

Step 2: Semantic Layer — Model Structure and Metadata

This is where the previous section's brownfield/greenfield guidance applies. The semantic model is the translation layer between raw data and AI comprehension. Key actions:

• Ensure star schema compliance. AI systems reason more effectively over well-defined fact and dimension tables with clear grain.
• Add comprehensive descriptions, synonyms, and linguistic relationships.
• Configure Prep for AI: schema simplification, AI Instructions, and Verified Answers.
• Validate in Power BI Desktop before publishing. Use the Copilot chat pane to test questions against your model.

Step 3: Agent Layer — Data Agent Configuration

With the semantic model prepared, configure your Data Agents.

Create a Data Agent in your Fabric workspace. Add your semantic model as a data source, selecting the same tables you defined in Prep for AI's AI Data Schema. Alignment between these two selection surfaces is critical for consistent behavior. Data Agents now support a broad range of data sources including lakehouses, warehouses, semantic models, KQL databases, SQL databases, Ontology, Azure AI Search indexes (for unstructured data), and Graph (for relationship-aware queries).

Write agent-level instructions that define the agent's scope, tone, and routing logic. Agent instructions guide the Orchestrator in selecting the right data source when multiple sources are connected. They are distinct from Prep for AI's AI Instructions, which guide the DAX generation tool.

For lakehouse and warehouse data sources, configure data source instructions and example queries directly in the Fabric service. For semantic models, the configuration flows through Prep for AI.

Add example queries (few-shot examples) to improve deterministic responses to common questions. Use the Data Agent SDK's evaluate_few_shots() function to validate that each natural-language/SQL pair is clear, correct, and schema-aligned. The SDK returns clarity, relatedness, and mapping scores, plus automatic conflict detection across examples.

Step 4: Integration Layer — Multi-Surface Deployment

Deploy your AI capabilities across consumption surfaces:

Power BI Reports: Copilot pane integration, Narrative visual for automated summaries, and the standalone Copilot experience for cross-report Q&A.

Microsoft Teams: Publish Data Agents through Copilot Studio for consumption in Teams chat. Users ask natural language questions without leaving their collaboration environment.

Microsoft 365 Copilot: Data Agents integrate with M365 Copilot, enabling enterprise-wide access to Fabric-grounded answers from any M365 surface.

Custom Applications: Use the Data Agent's public API endpoints or the GraphQL MCP server to embed Fabric intelligence into custom applications.

Multi-Agent Orchestration: Combine Fabric Data Agents with other agents in Copilot Studio for complex workflows spanning data analysis, document generation, and process automation.

Step 5: Governance and Security

AI enablement introduces new governance requirements.

Capacity Planning: Copilot and Data Agent consumption is billed under the Copilot and AI meter, processed as background operations with 24-hour smoothing. Monitor usage through the Fabric Capacity Metrics app, filtering on "Copilot in Fabric" and "Data Agent" operations. For organizations below F64, consider deploying a dedicated Fabric Copilot Capacity (FCC) to isolate AI compute from data workloads, preventing Copilot token consumption from competing with pipeline and query operations on the same capacity.

Access Control: Data Agents enforce the querying user's permissions, including Row-Level Security (RLS) and Column-Level Security (CLS) on underlying data sources. Data Agents generate only read-only queries (SELECT) — they cannot create, update, or delete data. For semantic model data sources, users need at minimum "Build" permission. For lakehouses and warehouses, "Read" (SELECT) permissions. For KQL databases, the "Reader" role.

Selective Enablement: Copilot in Fabric cannot be enabled or disabled for specific experiences (e.g., you cannot enable Copilot for DAX Query View while disabling it for report creation). Control is at the workload level only. Plan your rollout accordingly — enabling Copilot for Power BI enables all Power BI Copilot experiences for authorized users.

XMLA Endpoint: Power BI semantic models used as Data Agent data sources require the "Power BI semantic models via XMLA endpoints" tenant switch to be enabled.

Purview DSPM for AI: Enable this to monitor prompt and response telemetry, detect sensitive data in AI interactions, and enforce compliance policies across Copilot and Data Agent usage.

Outbound Access Protection: The March 2026 release introduced outbound access protection for Data Agent artifacts, helping mitigate sensitive data exfiltration risks at the workspace level.

Part 4: Validation and Accuracy Framework

4.1 Why Validation Is Non-Negotiable

AI-generated responses in Fabric are probabilistic. Even with well-configured semantic models, the DAX generation tool can produce incorrect queries, especially for complex questions involving multiple measures, time intelligence, or context transitions. Organizations must implement systematic validation before deploying AI experiences to business users.

4.2 The Validation Toolkit

Manual Testing in Sandbox

Data Agents support a "sandbox" stage for testing before publishing to production. Use the sandbox environment to test questions across your expected query patterns. Inspect the generated DAX/SQL/KQL for each response. The Data Agent UI includes a "run steps" view that shows which data source was selected, which tool was invoked, and the exact query generated.

Programmatic Evaluation with the Fabric SDK (Preview)

The Data Agent Python SDK provides systematic evaluation capabilities, currently in preview. Despite preview status, this is the recommended approach for systematic validation. Define a ground truth dataset of question-answer pairs:

from fabric.dataagent.evaluation import evaluate_data_agent

# Define ground truth as a DataFrame with columns:
# - question: the natural language question
# - expected_answer: the known correct answer
evaluation_id = evaluate_data_agent(
    df=ground_truth_df,
    data_agent_name="Sales Analytics Agent",
    data_agent_stage="production",
    table_name="evaluation_results"
)

The SDK compares the agent's responses against expected answers and stores metrics including the count of correct, incorrect, and unclear responses. Use get_evaluation_summary() for aggregate metrics and get_evaluation_details() for per-question breakdowns including links to evaluation threads.

Few-Shot Example Validation

For SQL-based data sources, use the evaluate_few_shots() function to validate your example queries:

result = datasource.evaluate_few_shots(batch_size=20)
print(f"Success rate: {result.success_rate:.2f}%")

The validator scores each example on Clarity (is the question unambiguous?), Relatedness (does the SQL match the question's intent?), and Mapping (do columns and tables align with the schema?). It also performs automatic conflict detection, identifying cases where similar questions map to different SQL logic.

AI Functions Evaluation Notebooks

For AI Functions (sentiment, classification, extraction), Microsoft provides evaluation notebooks using LLM-as-a-Judge. The workflow: run an AI function on your data using an executor model, evaluate each output using a judge model to generate ground truth labels, then calculate accuracy, precision, recall, F1, coherence, consistency, and relevance scores.

4.3 The Validation Cadence

Pre-Deployment: Validate every Data Agent configuration against a minimum of 50 ground truth question-answer pairs covering your critical business questions, edge cases, and known-tricky formulations.

Post-Deployment (Weekly): Run automated evaluation against the same ground truth set to detect accuracy drift. Schema changes, data refreshes, and measure modifications can all impact AI response quality.

On-Change: Re-validate whenever the underlying semantic model changes (new measures, renamed columns, modified relationships) or when Prep for AI configurations are updated.

Stakeholder Review: Involve business users in the evaluation process. Automated metrics catch technical errors; business users catch semantic errors (technically correct DAX that answers the wrong business question).

4.4 Consistency Validation Across Surfaces

Ensure that the same question produces consistent answers across different AI surfaces:

• Test the same question via Copilot in a Power BI report, the standalone Copilot, a Data Agent directly, and a Data Agent consumed through Copilot Studio in Teams.
• Differences may arise because each surface includes different grounding context (report metadata, conversation history, agent instructions).
• Document expected variations and configure AI Instructions to minimize divergence.

Part 5: Doing This with Grace and Elegance

5.1 The Phased Rollout Model

Elegance in enterprise AI enablement means avoiding the "big bang" deployment. Instead:

Phase 1 — Prove Value (4–6 weeks): Select one well-structured semantic model in a single business domain. Apply the full readiness framework. Deploy a Data Agent to a pilot group of 10–15 users. Measure accuracy, adoption, and user satisfaction. This phase establishes the pattern and builds organizational confidence.

Phase 2 — Expand Horizontally (2–3 months): Apply the proven pattern to 3–5 additional domains. Establish a reusable playbook: metadata enrichment checklist, Prep for AI configuration template, validation test suite, and deployment runbook. Train BI developers on AI readiness practices.

Phase 3 — Platform Integration (3–6 months): Deploy multi-agent orchestration through Copilot Studio. Integrate Data Agents into Teams and M365 Copilot. Enable AI Functions in data engineering pipelines for enrichment workflows. Begin planning for Ontology adoption as it matures toward GA.

5.2 Organizational Design for AI Readiness

AI readiness is not a one-time project. It requires sustained ownership.

Assign Semantic Model Stewards who are responsible for maintaining model quality, descriptions, Prep for AI configurations, and validation test suites. This is typically an extension of the existing model developer role.

Establish an AI Readiness Review as part of your model promotion workflow. Before a semantic model receives "Certified" endorsement, it must pass AI readiness criteria: description coverage above 90%, Prep for AI configured, validation suite passing above 85% accuracy.

Create a Center of Excellence (CoE) function for AI enablement that maintains patterns, shares learnings, monitors capacity consumption, and coordinates with Microsoft's feature roadmap.

5.3 The Metadata-as-Code Discipline

The most elegant implementations treat semantic model metadata as code. Use Tabular Editor or TMDL (Tabular Model Definition Language) with Git integration to version-control descriptions, synonyms, relationships, perspectives, and model structure. Fabric Git integration now exports semantic models as TMDL by default instead of a single JSON file, enabling granular change tracking and merge conflict resolution at the object level.

The Power BI Modeling MCP Server can be used to accelerate metadata enrichment by enabling AI agents to bulk-generate descriptions, synonyms, and translations directly against TMDL definitions in a Git-reviewed workflow.

5.4 Cost Governance

Monitor AI workload costs proactively through the Fabric Capacity Metrics app. As of March 2026, AI Functions and AI Services appear as separate operations, giving clear visibility into consumption. Copilot operations are smoothed over 24 hours as background operations, which prevents spike-driven throttling but can accumulate costs over time. Establish consumption alerts and review AI-specific billing weekly during initial rollout.

Part 6: Reference Architecture

Part 7: Quick-Reference Checklists

Brownfield AI Readiness Checklist

• Inventory all semantic models: mode (Import/DQ/DirectLake), table count, description coverage
• Rename cryptic tables and columns to business-friendly names (or add synonyms)
• Add descriptions to 90%+ of tables, columns, and measures
• Define synonyms and linguistic relationships for natural language interpretation
• Configure Prep for AI: simplify schema, write AI Instructions, create Verified Answers
• Test in Copilot chat pane in Power BI Desktop before publishing
• Publish model and tag as AI-prepared in PBI Service settings
• Create Data Agent, align table selection with Prep for AI schema
• Write agent instructions for scope, routing, and tone
• Add example queries; validate with evaluate_few_shots()
• Run programmatic evaluation with 50+ ground truth QA pairs (SDK is in preview — plan accordingly)
• Configure RLS/CLS and validate that Data Agent respects permissions
• Enable XMLA endpoints tenant switch
• Enable cross-geo processing/storing for AI tenant settings if capacity is outside US/EU
• Evaluate Fabric Copilot Capacity (FCC) for AI compute isolation below F64
• Monitor Copilot and AI meter consumption in Capacity Metrics app
• Establish ongoing validation cadence (weekly automated, on-change manual)

Greenfield Design Checklist

• Design domain-scoped models (15–25 tables per business domain)
• Establish business-first naming conventions before development begins
• Require descriptions for all tables, columns, and measures in development workflow
• Choose DirectLake as preferred mode; all Prep for AI features supported
• Combine Verified Answers with AI Instructions for maximum AI accuracy
• Document business entities and relationships for future Ontology mapping
• Configure CI/CD with TMDL/Tabular Editor and Git for model metadata version control
• Document Prep for AI configurations separately (AI Instructions, Verified Answers are not in TMDL)
• Include AI accuracy validation in promotion gates (dev → test → prod)
• Design for multi-surface consumption (reports + NL Q&A simultaneously)
• Plan capacity for Copilot and AI meter billing from day one

Sources and References

Microsoft Official Documentation

1. Copilot in Fabric Overview — Architecture, cost model, and workload-specific capabilities
2. Use Copilot with Semantic Models — Prep for AI configuration, development and consumption experiences
3. Semantic Model Best Practices for Data Agent — Schema configuration, AI Instructions, Verified Answers, validation workflow
4. Add Semantic Model as Data Source to Data Agent — Prep for AI integration, table alignment, example DAX
5. Evaluate Your Data Agent — Python SDK for programmatic evaluation, ground truth testing, accuracy metrics
6. Data Agent Example Queries — Few-shot validation, clarity/relatedness/mapping scores, conflict detection
7. AI Functions Overview — Sentiment, classification, embedding, extraction, summarization, translation
8. Fabric IQ: Introducing Ontology — Ontology concepts, business entities, rules, and actions
9. How Copilot in Fabric Works — Grounding, RAG process, token consumption, capacity billing
10. Connect AI Agents to Fabric with GraphQL MCP — MCP server setup, schema introspection, natural language querying
11. Fabric Operations and Consumption Rates — Billing meters for AI Functions, Data Agents, Copilot, GraphQL
12. Data Agent in Copilot Studio — Multi-agent orchestration, Teams publishing, authentication modes
13. Foundry Tools in Fabric — Prebuilt AI services, capacity reporting separation

FabCon Atlanta 2026 and Feature Summaries

14. FabCon and SQLCon 2026 Hero Blog (Arun Ulag) — 31,000+ customers, Fabric IQ expansion, MCP endpoints, NVIDIA partnership, Planning in Fabric IQ
15. What's Next for Fabric IQ Ontology — MCP endpoints for Ontology, new IQ capabilities announced at FabCon Atlanta
16. Fabric March 2026 Feature Summary — Multimodal AI Functions, T-SQL AI functions, DSPM for AI, Fabric Local MCP production enhancements, branched workspaces, Graph as Data Agent data source
17. Fabric November 2025 Feature Summary — Prep for AI integration with Data Agents, SQL Database artifacts, AI Search connectivity
18. AI Functions Enhancements (GA) — Configurable labels, ExtractLabel, new classify and embed capabilities
19. Multimodal AI Functions (Preview) — Image/PDF processing, evaluation notebooks, progress bar cost calculator
20. Data Agents at Ignite 2025 — Ontology as knowledge source, M365 Copilot integration, unstructured data support

This guide reflects the state of Microsoft Fabric as of March 30, 2026, incorporating FabCon Atlanta 2026 announcements. Feature availability and preview status are subject to change. Always verify against current Microsoft documentation before production implementation decisions.