What Claude Actually Automates in Power BI
Quick answer: Claude automates the file layer. Reports and semantic models saved as a Power BI Project are plain text: PBIR JSON for the report, TMDL for the model. An agent edits those files directly. It does not drive the Power BI Desktop interface.
This is the distinction that decides whether AI-assisted Power BI development is a demo or a delivery process. A chat assistant produces an answer you paste somewhere. An agent editing PBIR produces a diff: a set of changed files with a before and an after, which can be reviewed, rejected, and deployed by something other than a person clicking Publish.
Microsoft shipped the tooling for the second version in mid-2026, and it names Claude Code as a supported client. What Microsoft did not ship is the surrounding process. Its entire published guidance on source control for agent-generated reports is one sentence: "Commit a baseline before you allow the agent to modify PBIR files so you can revert changes." That is rollback. It is not review, and it is not deployment.
This post covers the part that sits between them. It assumes you already have Claude connected to Power BI through MCP and that you have seen what Claude does with DAX. The question here is what happens to the files afterwards.
Which Tools Does Microsoft Ship for Agentic Power BI Development?
Quick answer: Five layers: the Power BI Authoring MCP server for semantic models, Fabric IQ for answering questions over them, the Power BI Report skill for PBIR files, the Desktop Bridge for visual verification, and the planning and design modules of the same skill for greenfield work. As of October 2026 the local Authoring MCP server, PBIP and PBIR are generally available; the hosted Authoring server is in preview.
The Power BI Report skill overview sets out the division of labour:
| Layer | Tool | Responsibility |
|---|---|---|
| Semantic model (tables, columns, measures, DAX) | Power BI Authoring MCP server | Create and update the data model |
| Data queries and insights | Fabric IQ | Answer questions over governed models |
| Report layer (PBIR/PBIP files) | Power BI Report skill | Edit pages, visuals, filters, formatting, themes |
| Live Desktop verification | Power BI Desktop Bridge | Open, reload, status, screenshot |
| Greenfield planning and design | Planning and design modules of the Power BI Report skill | Requirements, layout, colour, typography |
The Power BI Report skill does not touch semantic models. Microsoft's scope note is explicit: the skill is for the report layer, and for semantic-model work including "tables, columns, relationships, measures, and DAX" you use the Power BI MCP servers instead.
The skill works with PBIR definitions in PBIP files, or with reports hosted in Fabric. A .pbix is opaque to it. The conversion is a Save As in Power BI Desktop, and it is not scriptable. Microsoft's own FAQ answers "Can I convert PBIX into PBIP and vice-versa programmatically?" with a flat "No."
Installing the skills in Claude Code
The skills ship in microsoft/skills-for-fabric, Microsoft's first-party, MIT-licensed catalogue, as a plugin called powerbi-authoring. In Claude Code, add the marketplace first, then install the plugin:
/plugin marketplace add microsoft/skills-for-fabric
/plugin install powerbi-authoring@fabric-collection
That brings in powerbi-report-cli, one skill that covers report planning, design, authoring and management, and semantic-model-authoring. It also registers the local Authoring MCP server for you, which is otherwise a manual step. The separate fabric-skills bundle covers the wider platform (Lakehouse, Spark, KQL, Eventstreams, Dataflows Gen2 and warehouse work) and does not include the Power BI plugin.
The skill drives two command-line tools, which install from npm and need Node.js 20 or later:
npm install -g @microsoft/powerbi-report-authoring-cli@latest @microsoft/powerbi-desktop-bridge-cli@latest
Most Fabric operations authenticate through the Azure CLI:
az login
az account get-access-token --resource https://api.fabric.microsoft.com
The skill is "optimized for GitHub Copilot CLI with cross-tool compatibility for VS Code Copilot, Claude Code, Cursor, Codex/Jules, and Windsurf." Read that as written: the primary target is Copilot CLI, and the Claude Code path is supported rather than tuned.
The loop Microsoft describes
Microsoft's documented end-to-end flow runs in five steps: use the Authoring MCP server to make sure the semantic model has what the report needs; use the Power BI Report skill to edit PBIR files; run validate-report to catch structural problems; use the Desktop Bridge to reload Desktop and capture screenshots; then "delegate review to an independent design-reviewer pass and iterate until both validation and visual checks pass."
The Power BI Desktop Bridge is the piece with no equivalent in ordinary automation. It is a local JSON-RPC 2.0 server running inside a live Power BI Desktop process, exposing methods including bridge.manifest, application.state.get/v1, file.reload/v1 and report.snapshot.capture/v1. It lets an agent look at what it built instead of trusting that valid JSON renders correctly. It is governed by the Security option "Enable external tool access to Power BI Desktop through secure local APIs," which is on by default rather than opt-in. Remote access is not supported: the pipe is local to the machine, each Desktop window gets its own, and only one operation runs at a time.
That loop closes the correctness gap. It does nothing about the governance one, because every step happens on one developer's machine.
What Do PBIR and TMDL Look Like on Disk?
Quick answer: One JSON file per visual, one JSON per page, one TMDL file per table. Almost everything is text and diffable; the exceptions are a binary data cache and four files whose schemas Microsoft has not documented.
Saving as a Power BI Project produces a folder per item rather than a single file:
Project/
├── AdventureWorks.Report/
│ ├── definition.pbir
│ └── definition/
│ ├── pages/
│ │ ├── pages.json
│ │ └── ReportSection1/
│ │ ├── page.json
│ │ └── visuals/
│ │ └── 3a1f9c/
│ │ └── visual.json
│ ├── report.json
│ └── version.json
├── AdventureWorks.SemanticModel/
│ ├── definition.pbism
│ └── definition/
│ ├── model.tmdl
│ ├── relationships.tmdl
│ ├── expressions.tmdl
│ └── tables/
│ └── Sales.tmdl
├── .gitignore
└── AdventureWorks.pbip
Each JSON file declares a public schema, following the pattern https://developer.microsoft.com/json-schemas/fabric/item/report/definition/<fileType>/<version>/schema.json. The full set is published in microsoft/json-schemas, covering visualContainer, page, report, bookmark, semanticQuery, filterConfiguration and the rest. That is what makes agent-generated output checkable rather than merely plausible.
The semantic model side is TMDL, one file per table plus files for relationships, roles, cultures and expressions. TMDL view in Power BI Desktop is generally available; TMDL view on the web is still preview.
What does not diff. Power BI Desktop writes a .gitignore on first save containing exactly two entries:
**/.pbi/localSettings.json
**/.pbi/cache.abf
cache.abf is an Analysis Services backup, the actual cached data, in binary. A repository that has lost that .gitignore is committing data rows into source control.
Four more files are text but out of bounds. Microsoft states that schema details for the report's report.json (the legacy root-level one), mobileState.json, semanticModelDiagramLayout.json and the model's diagramLayout.json "aren't documented," and that changes to these files outside of Power BI Desktop aren't supported. An agent that edits them is working without a contract.
The service also enforces hard ceilings on PBIR reports: 1,000 pages per report, 1,000 visuals per page, 300 MB total report size, and 300 MB of resource package files. Generation makes it easier to reach those numbers than hand-authoring ever did.
How Should You Review Agent-Generated PBIR?
Quick answer: As code. The diff is the artefact, and four PBIP-specific mechanics will corrupt it before a reviewer ever reads it: line endings, path length, encoding, and a schema version that is not published.
Microsoft's advice to commit a baseline gets you a working undo. It does not get you a second pair of eyes, which is what actually stops a generated report reaching production with a broken filter.
Set up the mechanics first, because each of these produces a diff that is either unreadable or wrong.
Line endings. Power BI Desktop writes CRLF. Microsoft's own instruction is to configure Git's autocrlf "to avoid problems in your diffs." Skip it and the first commit from a machine with different settings rewrites every line of every file, and the real change disappears inside thousands of phantom ones.
Path length. PBIP explodes a report into nested folders, and Windows caps paths at 260 characters by default. Microsoft's mitigation is blunt: "use a short folder path as the root location for your PBIP." Long table names are the usual cause. This fails at save time, not review time, but it fails during a generation run more often than during manual authoring because agents produce more files at once.
Encoding. Files edited outside Power BI Desktop "should be saved using UTF-8 without BOM." A BOM introduced by an editor or a script breaks the file for Desktop.
Schema versions can outrun the published schemas. Issue #573 in the json-schemas repository, opened 12 May 2026 and closed on 14 September 2026, reported that visualContainer schema version 2.8.0 was emitted by Power BI Desktop but was not published. The gap has been closed once and can reopen with the next Desktop release. Validation tooling that resolves $schema over the network will fail on files that are perfectly valid when it does. Pin the schema version you validate against rather than trusting the URL in the file.
What to look for in the diff
Once the diff is readable, the review is specific to what these agents get wrong:
- Query bindings, not appearance. Microsoft lists diagnosing "a visual rendering as an error icon or empty frame" and fixing "the underlying queryState or role bindings" as a use case for the skill, which tells you where the failure mode lives. A visual can be structurally valid, pass
validate-report, and be bound to nothing. - Deprecated visual types. Microsoft warns that "some visuals, including Q&A, Bing maps, and filled maps, will be deprecated soon" and recommends not prompting agents to create them. A model trained on years of Power BI examples will reach for them unprompted.
- Legacy versus modern visuals.
cardand matrix are the old forms;cardVisualandpivotTableare current. Converting between them changes how selector-based formatting applies. - Filter values. Slicer selections and filter values persist into
visual.jsonas plain text. They are metadata by file type and data by content. A diff can leak a customer name or an account number into a pull request that a wider group can read. - Unsaved Desktop state. "The PBIR file is the source of truth." If a developer has unsaved changes open in Desktop and asks the agent to iterate, the agent reads the file and silently discards that work.
A useful gate on the pull request runs validate-report, checks the schema, and blocks deprecated visualType values. None of that needs a model; it is a script. The human review is then free to be about whether the report answers the question it was built for.
Can You Deploy PBIP Without Opening Power BI Desktop?
Quick answer: Yes. fabric-cicd, Fabric git integration, or the Fabric item-definition REST APIs all deploy a PBIP folder to a workspace, and all three move metadata only.
Microsoft documents three publishing routes for a Power BI Project: Fabric git integration, the Fabric APIs, and Power BI Desktop's own Publish button. They are not equivalent, and the difference matters beyond convenience.
Desktop Publish moves more than the other two. Microsoft's note is unambiguous: publishing from Desktop "uses a temporary PBIX file," and "unlike other PBIP deployment options that only deploy metadata, this publishing method deploys both the metadata and the local data cache of the semantic model being edited." Deploy from CI and you ship definitions. Deploy from a laptop and you ship whatever that laptop had cached.
fabric-cicd is the path Microsoft documents for automated deployment: an open-source Python library it maintains. pip install fabric-cicd, point it at a source directory, and it sequences dependencies so the semantic model lands before the report that binds to it. Environment differences go in a parameter.yml find-and-replace, which is how the same commit targets a development and a production workspace without editing definitions. It authenticates through the Azure Identity SDK, so a service principal in GitHub Actions or Azure DevOps works.
The item-definition APIs are the layer underneath. POST /v1/workspaces/{workspaceId}/items/{itemId}/getDefinition and the matching update calls take every file as a base64 part:
{
"definition": {
"parts": [
{
"path": "definition/pages/ReportSection1/page.json",
"payload": "ewogICIkc2NoZW1hIjogLi4u",
"payloadType": "InlineBase64"
}
]
}
}These are long-running operations: a 202 Accepted with Location, x-ms-operation-id and Retry-After headers means poll, not retry. Reports default to PBIR and semantic models to TMDL. Rebinding a report to a different semantic model is a property of definition.pbir rather than a separate API call.
Three constraints that shape the pipeline
Throttling is a fixed window, not a leaky bucket. Fabric's unified quota model gives each identity three independent buckets (500 calls per minute for platform APIs, 200 for job scheduler APIs and 500 for long-running operations), evaluated on a 60-second window that refills all at once. Burst through it and you are blocked for the remainder of the window rather than gradually slowed. A deployment that pushes a few hundred files as individual calls will hit this; batch the parts into one definition call. Note also that a 429 carrying CapacityLimitExceeded is a different problem from one carrying RequestBlocked. The first needs more capacity, not a retry.
Service principals need a tenant switch and are not universal. The admin setting "Service principals can use Fabric APIs" must be on. Even then, support is per item type: Microsoft's Get Item Definition reference notes support applies "when the item type in the call is supported," so do not assume report behaviour matches semantic model behaviour. The local Authoring MCP server supports service principals; the hosted server and Fabric IQ sign in as a user, which rules them out of headless CI.
Two things cannot be automated through the Fabric REST API at all. Microsoft lists both as PBIP limitations: it is not possible to get or set row-level security role members, and it is not possible to get or set incremental refresh partitions. On a governed deployment those are exactly the two settings you would most want in code, so a pipeline claiming to be fully automated is either not using RLS or not telling the truth.
Git integration supports reports and semantic models in preview, through Azure DevOps or GitHub. Two exclusions matter before you plan around it: reports connected to Azure Analysis Services or SQL Server Analysis Services models, and reports exported by Power BI Desktop that depend on a semantic model in My Workspace.
What in This Stack Is Still Preview?
Quick answer: The file formats and the local tooling are generally available. The hosted and web-based pieces, the Desktop Bridge, Git integration for Power BI items and the Power BI items in deployment pipelines are still preview as of October 2026.
Status decides where an agent's output can safely depend on a feature. Each row below is taken from Microsoft Learn.
| Piece | Status | Practical effect |
|---|---|---|
| PBIP and PBIR | Generally available | PBIR is the default report format. Build on it. |
| Power BI Authoring MCP server, local | Generally available | The only deployment that reaches Desktop, PBIP files on disk and service principals. |
| Power BI Authoring MCP server, hosted | Preview | Signs in as the user, so it is not an option for headless CI. |
| Fabric IQ MCP server | Generally available | Read-only. It answers questions over models; it does not author them. |
| DAX user-defined functions | Generally available | General availability came with the June 2026 release. Functions are stored in functions.tmdl in a PBIP. |
| TMDL view in Power BI Desktop | Generally available | Script and review semantic model changes as text in Desktop. |
| TMDL view on the web | Preview | Scripts are not persisted there. |
Fabric CLI (fab) | Generally available | Its Azure DevOps pipeline task is still preview. |
| Detecting and reloading external PBIP changes in Desktop | Preview | Needs the August 2026 Desktop release and a preview feature switch. |
| Power BI Desktop Bridge | Preview | The screenshot and reload steps of the loop above depend on it. |
| Git integration for reports and semantic models | Preview | Compare and commit Git changes and branch workspaces are generally available. |
| Deployment pipelines for reports and semantic models | Preview | The new pipeline interface is also preview. |
Two points in that table change how you build.
The loop still rests on preview pieces. The authoring and file layers are generally available, but the Desktop Bridge and external change reload are not. If your process requires an agent to reload Desktop and capture a screenshot, that step carries preview terms. The PBIR and TMDL files do not, so a pipeline that stops at validation and a pull request is built entirely on generally available parts.
Deployment has a split status. Git integration and deployment pipelines support Power BI reports and semantic models as preview items, while the bulk item definition APIs are generally available. Check the status of the specific API and item type before you commit a pipeline to it. Microsoft's fabric-cicd tool lists a bulk publish mode as preview in its v1.2.0 release.
Three consequences follow for anything you build now.
The format changes in one direction. A PBIR-Legacy report is converted to PBIR when you edit and save it in Power BI Desktop or the Power BI service. Conversion is one-way, though a backup is kept.
Undocumented files stay off limits. The four files listed earlier are not supported for external editing.
Third-party tooling carries its own clock. Tabular Editor's CLI, which includes a pbir-cli for programmatic PBIR editing, carries the vendor's own preview and licensing terms; check its current status before relying on it in production CI/CD. semantic-link-labs is a Microsoft repository but labs-grade, supported through GitHub issues rather than an SLA.
None of that is a reason to stay away. It is a reason to keep the agent's output in your repository, where you control it, rather than in a workspace where a format migration reaches it first. For the semantic model side of the same decision, see how the Authoring MCP server connects to Claude.
What Leaves Your Tenant When an Agent Builds a Report?
Quick answer: PBIR and TMDL are metadata: table names, measure expressions, layout, and any filter values baked into the report. Screenshots captured through the Desktop Bridge are something else entirely: rendered report data.
For regulated work in the UAE and Saudi Arabia this is the question that decides whether the pipeline is usable, and it deserves a more precise answer than "AI sees your data" or "it's only metadata."
Model and report definitions are metadata, and metadata is disclosive. A TMDL file carries table names, column names, DAX expressions and relationships. That is a schema, and for a bank or a government entity a schema is frequently confidential even when no row of data is attached. Treat it as you would treat source code leaving the building, because that is the same category of thing.
Screenshots are data. A report.snapshot.capture call returns a picture of a rendered report: real numbers, real customer names, whatever the visuals show. If those images go to a model for a visual review pass, actual data has left the tenant, not metadata. Microsoft's Desktop Bridge documentation covers the mechanics and does not address this; it is a conclusion you have to draw yourself, and it is the single most overlooked step in the loop. Run visual verification against a development semantic model with non-production data and the problem disappears.
Anthropic's commitment is specific and worth quoting accurately. Per Anthropic's API data retention documentation, retained data "is never used for model training without your express permission," and Zero Data Retention is available to qualifying enterprise customers. That is a stronger commitment than most enterprise reviewers assume, and it is also not the same as data never leaving your control, a distinction worth putting in front of a security team in writing rather than paraphrasing.
One governance gap is Microsoft's, not the agent's. Sensitivity labels are not supported with Power BI projects. A report that carries a Microsoft Purview label in the service loses it on the round trip through PBIP. For an organisation whose PDPL or NDMO controls depend on labelling, that is a hole in the process that no amount of careful prompting closes. It is also an argument for deploying through git and the APIs, where the label is applied in the service and never round-tripped.
Region availability constrains where the deployed content can live. Microsoft's Fabric region availability list names three Middle East regions as of October 2026. UAE North supports all Fabric workloads. UAE Central and Qatar Central are marked "Power BI only region," so the wider Fabric platform is not available there. No Saudi Arabia region appears in the table at all. For an in-region Fabric capacity in the Gulf, UAE North remains the only answer, the same conclusion reached in our Power BI data residency guide, and unchanged by anything in the agentic stack.
Frequently Asked Questions
Q: Can Claude build a complete Power BI report?
Yes, within limits. With Microsoft's Power BI Report skill installed, Claude Code can create and modify pages, visuals, filters, slicers, bookmarks, themes and formatting by editing PBIR JSON directly, then verify the result by reloading Power BI Desktop and capturing a screenshot through the Desktop Bridge. It cannot work on a .pbix file. The project must be saved as PBIP first, which is a manual Save As in Power BI Desktop. It also does not build the semantic model; tables, columns, measures and DAX are handled by the separate Power BI Authoring MCP server.
Q: What is PBIR in Power BI?
PBIR (Power BI Enhanced Report Format) is the text-based format a report takes inside a Power BI Project. Instead of one opaque file, the report becomes a folder tree under definition/ with one JSON file per page and one per visual, each declaring a public JSON schema. That structure is what makes reports diffable in git and editable by tooling other than Power BI Desktop. As of October 2026 PBIR and PBIP are both generally available.
Q: Is Power BI Project (PBIP) generally available yet?
Yes. Microsoft's Power BI Desktop projects documentation now states that Power BI Desktop projects (PBIP) and PBIR are generally available. Detecting and reloading external PBIP changes in Power BI Desktop is still in preview.
Q: How do you install Microsoft's Power BI skills in Claude Code?
The skills ship in the MIT-licensed microsoft/skills-for-fabric repository as a plugin. In Claude Code, add the fabric-collection marketplace through the /plugin command, then run /plugin install powerbi-authoring@fabric-collection. That installs the Power BI Report skill and the semantic model authoring skill together. Most Fabric operations then authenticate through the Azure CLI with az login. Microsoft describes the skills as optimised for GitHub Copilot CLI with cross-tool compatibility for Claude Code.
Q: Can you deploy Power BI reports to Fabric from a CI/CD pipeline?
Yes. fabric-cicd, an open-source Python library maintained by Microsoft, deploys PBIP source directories to a Fabric workspace, sequences semantic models ahead of the reports that depend on them, and parameterises workspace and lakehouse identifiers per environment through a parameter.yml file. It authenticates with a service principal via the Azure Identity SDK, so it runs unattended in GitHub Actions or Azure DevOps. Two things stay manual: row-level security role members and incremental refresh partitions cannot be set through the Fabric REST API.
Q: Does the Power BI Authoring MCP server work with reports?
No. The Authoring MCP server is scoped to semantic models: creating and updating tables, columns, measures and relationships, validating DAX, and editing TMDL. It does not author report pages or visuals. That is the Power BI Report skill's job. Fabric IQ is different again: it answers questions over governed data and authenticates as a signed-in user, so it cannot be used from an unattended pipeline.
Q: Is it safe to let an AI agent write Power BI files for regulated data?
It depends on which step you mean. Editing PBIR and TMDL exposes metadata: table names, DAX expressions, layout, and any filter values saved into the report. Many GCC financial and government entities already classify that as confidential. Screenshot verification through the Desktop Bridge is a different matter, because a screenshot contains rendered data rather than metadata; run that step against a development model with non-production data. Note also that sensitivity labels are not supported with Power BI projects, so a Purview label does not survive a round trip through PBIP.








