In Microsoft Fabric, AI is not a separate sidecar experience bolted onto the platform. It is woven into the tools that teams already use: Power BI for semantic modeling and reporting, notebooks for code authoring, pipelines for orchestration, SQL experiences for warehousing, and Data Agents for natural-language question answering over governed data.

It helps to think about Fabric AI in two categories:

• Copilot: the interactive AI assistant that helps authors generate code, visuals, queries, summaries, and pipeline logic.
• AI features: built-in platform capabilities such as Data Agents and reusable AI Skill items that let you operationalize AI inside analytics workflows.

What Copilot helps with

Prepare your data for AI

Copilot quality is strongly tied to semantic model quality. Keep this page focused on the essentials, then use the full guide in Best Practices → Preparing Data for AI for implementation detail.

• AI data schema: expose the most meaningful fields and hide noisy internal columns.
• AI instructions: add business context, preferred measures, terminology, and analysis rules.
• Verified answers: curate trusted responses for common executive or operational questions.

Prompts that usually work well

Limitations to keep in mind

• Copilot does not transform or repair your underlying data; it works with the model it is given.
• Results are better when measures, hierarchies, and descriptions are well defined.
• Generic or ambiguous models often produce vague visuals or incorrect metric choices.
• Generated output should be reviewed by a report author before publication.

Notebook Copilot is especially useful when you know the transformation you want but do not want to spend time writing boilerplate PySpark, fixing syntax, or documenting every step by hand. It can work across authoring, explanation, and debugging loops.

Best practices for better notebook results

• Use clear variable and dataframe names: names like sales_df and customer_dim provide far more context than df1 and tmp.
• Break work into logical cells: ingestion, cleansing, enrichment, and publish steps are easier for Copilot to understand than one monolithic script.
• Show intent in markdown cells: short headings and notes help both humans and Copilot follow the flow.
• Ask for one transformation at a time: iterative prompting usually produces better code than a giant multi-step prompt.
• Validate generated code against your runtime and libraries: Copilot can still suggest patterns that need adaptation.

Context awareness and cell behavior

Copilot can use the surrounding notebook context — prior cells, variable names, dataframe references, and markdown explanations — to generate more relevant code. It is particularly effective when your notebook has a clean narrative structure.

It can also help with IPython magic commands and notebook-specific behavior, such as working with %run, switching between Python and Spark SQL contexts, or explaining how a cell's output feeds the next step. Still, you should verify that generated magic commands and session assumptions match your Fabric runtime.

Generate PySpark code to read the bronze_orders Delta table,
filter to the current month, and aggregate revenue by sales region.

Explain why this merge statement fails with a duplicate key error.

Add markdown documentation for this notebook section in a concise,
team-friendly style.

Refactor this cell so it writes a partitioned Delta table and includes
basic error handling.

Where it helps most

• Natural language to pipeline creation: describe the source, transformation step, and destination to scaffold a pipeline.
• Activity suggestions: get recommendations for copy, notebook, dataflow, wait, condition, loop, and notification patterns.
• Expression generation: generate dynamic content for file paths, parameters, dates, branching logic, and output references.

Example prompts

Create a pipeline that copies daily CSV files from ADLS into a bronze
lakehouse folder and then runs a notebook to convert them to Delta.

Generate a dynamic expression that writes files to /raw/year=YYYY/month=MM/day=DD.

Suggest activities to retry a failed API extract, log the error, and send
an alert if the retry count is exceeded.

Current limitations

• Copilot is best used to create a starting point, not a fully production-hardened orchestration pattern.
• You still need to validate connection references, parameters, credentials, and environment-specific settings.
• Complex branching, custom expressions, and enterprise error handling usually need manual refinement.
• Generated logic should be tested in realistic failure scenarios before release.

Copilot for SQL is valuable when analysts or engineers understand the question they want answered but need help turning that requirement into valid T-SQL. It can also help explain legacy code, generate comments, and suggest improvements when a query is hard to maintain.

Where it works

These capabilities are most relevant in Fabric Warehouse and the SQL analytics endpoint, where teams author and review SQL over governed Fabric data.

Prompt patterns that work well

• Write a T-SQL query that returns the top 10 customers by net revenue in the last rolling 90 days.
• Explain what this query is doing and identify why it may return duplicate rows.
• Refactor this nested query into CTEs with comments for each step.
• Suggest a more efficient way to calculate monthly active users by product line.

What Data Agents are

Fabric Data Agents are AI agents designed to answer questions over organizational data. Rather than treating the entire workspace as one undifferentiated corpus, an agent is configured with selected sources, instructions, and examples so it can respond with more domain awareness.

How they work

• Select the data sources the agent can use, such as semantic models and other Fabric data assets.
• Provide instructions that define terminology, analytical priorities, and how answers should be framed.
• Add example questions and validate responses so the agent learns the shape of high-value business queries.
• Rely on the platform's existing permissions so users only see answers based on data they are authorized to access.

Integration with Microsoft 365 Copilot

Data Agents can extend beyond the Fabric authoring surface. When integrated with Microsoft 365 Copilot, they allow business users to ask questions in familiar productivity experiences while still grounding responses in Fabric-governed data and semantic definitions.

Building a custom Data Agent

1. Start with a high-value domain and a curated data source, not an everything agent.
2. Choose models and tables with good naming, descriptions, and stable business logic.
3. Add concise instructions that define KPI meaning, business calendar, and preferred measures.
4. Test common executive and analyst prompts, then refine instructions where answers drift.
5. Publish only after security, labels, and expected usage patterns are reviewed.

Common use cases

What AI Skill is

An AI Skill is a Fabric item pattern for wrapping an AI capability behind a reusable interface. Instead of duplicating prompt logic or model invocation code in every notebook and pipeline, you define the skill once and reuse it across the workspace.

How it works

• Define the contract: specify the expected input and output shape for the task.
• Connect to a model: point the skill at the underlying AI model or inference endpoint used for the operation.
• Publish as a Fabric item: make the skill discoverable and reusable by downstream solutions.
• Invoke from workflows: call it from notebooks, orchestration flows, or other automation steps that need the same AI behavior.

The main architectural value is standardization: centralize prompts, inputs, outputs, and guardrails once, then reference that skill from multiple solutions instead of re-implementing AI logic repeatedly.

• Copilot respects existing permissions: workspace roles, semantic model permissions, and data-level controls still matter.
• Sensitivity labels still apply: if content is protected and the user is not authorized, Copilot should not become a bypass route.
• Admin controls matter: review tenant settings and workspace/capacity rollout strategy before broad enablement.
• Audit logging is essential: monitor Copilot activity and AI-related access patterns as part of your compliance and support model.
• Human-in-the-loop remains required: Copilot can summarize and generate, but business owners must review high-impact outputs.

For deeper guidance on protection controls, labeling, audit, and defense-in-depth architecture, see the full Security guide.

Quick self-check

• Copilot tenant settings reviewed and approvedStart with a pilot if governance maturity is still low.
• Supported capacity confirmedValidate that the target workspaces use supported paid capacity.
• Key semantic models prepared for AIUse AI schema, descriptions, and stable measure definitions.
• AI instructions and verified answers addedFocus on the most common executive and analyst questions first.
• Security and labeling reviewedPermissions, labels, and DLP should be correct before broader rollout.
• Audit and support process definedKnow who monitors usage and who handles issue escalation.

Recommended companion pages in this guide

• Best Practices — Preparing Data for AI
• Security — defense-in-depth and AI protection controls
• Architecture — designing Fabric platforms for scale