AI Can Now Check Its Edits in Power BI

An AI agent can write a Power BI report’s files, but it couldn’t see what Power BI Desktop made of them. The Power BI Desktop Bridge, released in preview in June 2026, gives the agent a way in: it can reload the report it just edited, screenshot the page, and grade the picture before you look. This article sets the bridge up, explains each call, and follows one agent through 11 rounds of turning a plain table into a formatted matrix.

0:00The old write-and-hope editing loop

Save a report as a Power BI project (PBIP) and Desktop writes it to disk as text: the report as PBIR, with one JSON file per page and per visual, and the semantic model as TMDL. Power BI as Code walks through those files. An agent such as Claude Code can edit them directly.

Seeing the result was the hard part. Open an agent-edited project in Desktop and, half the time, it wouldn’t open correctly. You got a nondescript error message, copied it back to the agent, let it edit the files, closed and reopened Desktop, and maybe got a different error 0:12. Once the report opened, every change to a visual went around the same loop: the agent tried, you gave feedback, and you closed and reopened Desktop to see the next attempt 0:34. The agent wrote the files, and you did the reloading and the looking.

The loop before the bridge, and the loop with it.

0:48What the Desktop Bridge is

The Desktop Bridge is a small local server that runs inside the Power BI Desktop process, and it lets your AI agent of choice operate Desktop for you 0:48.

The model side already works this way. When you open Desktop, it starts a local Analysis Services engine for the semantic model, and tools such as Tabular Editor or the Power BI Modeling MCP server connect to it 1:01. The MCP server article works with that engine. The bridge gives the report side the same kind of entry point. You reach it through a command-line tool, the Power BI Desktop Bridge CLI, and your agent runs the CLI for you.

Microsoft Learn’s overview of the bridge lists how it works:

Fact	Detail
Transport	A named pipe on the local machine, pbi-desktop-bridge-{processId}
Protocol	JSON-RPC 2.0, with a Content-Length header before each message body
Remote access	Not supported
Several Desktop windows	Each window has its own pipe
Concurrency	Several clients can connect, but only one operation runs at a time; a request sent while another is running gets an error

Desktop runs only on Windows, so the bridge does too.

1:32Four calls, and the CLI commands over them

The bridge answers four methods 1:32. The CLI wraps each one in a command, and every command prints JSON to standard output, with progress messages on standard error, so an agent can read the result directly.

Bridge method	CLI command	What it does
bridge.manifest	powerbi-desktop manifest --pid <pid>	Lists the methods this Desktop build supports, each with its parameters and result schema
file.reload/v1	powerbi-desktop reload --pid <pid>	Rereads the open report from disk, without closing Desktop
application.state.get/v1	powerbi-desktop status	Returns the open file’s path (currentFilePath) and whether it has unsaved changes (hasUnsavedChanges)
report.snapshot.capture/v1	powerbi-desktop screenshot <page-id> --pid <pid>	Captures one report page as a PNG, found by its PBIR page ID

Manifest works like a ship’s manifest: it says what’s on board 1:38. The methods depend on the version of Desktop, and future versions may add more, so the agent reads the manifest to learn which ones it can call 1:48. Calling a method the build doesn’t have fails with a -32601 MethodNotFound error.

Reload short-circuits the close-and-reopen loop. Desktop rereads the project files from disk, and you don’t have to restart it 2:07. The bridge’s file.reload/v1 takes a reloadModelDefinition flag. The CLI’s reload sets it to false, so it rereads the report and leaves the semantic model alone; for model changes, the CLI’s README says to reopen the PBIP if they don’t show.

Status lets the agent see whether the report has changes in Desktop that haven’t been written to disk, so it doesn’t overwrite them 2:24. The section below on reading the state covers how to use it.

Screenshot is my favorite. As the agent builds or changes a report, it captures a page, looks at the image with its vision, and checks whether it’s getting the result it wants 2:36. The agent in the Fabric skills report article caught a year-over-year bug this way. The scale runs from 1.0 to 3.0; the bridge defaults to 1.0 and the CLI to 2. powerbi-desktop screenshot-all captures every page listed in the report’s pages.json.

The CLI adds one more command, powerbi-desktop open <path>, which opens a PBIP or PBIX file in Desktop and waits for the bridge.

3:12Check the setting and install the CLIs

The bridge is a preview feature, and it ships turned on by default in the June 2026 release of Power BI Desktop 3:13. To check it, go to File > Options and settings > Options > Preview features. Toward the end of the list is a setting called “Enable external tool access to Power BI Desktop through secure local APIs” 3:24. The name doesn’t mention the bridge, but that’s the setting.

Then install two command-line tools with npm (you need Node.js):

npm install -g @microsoft/powerbi-desktop-bridge-cli
npm install -g @microsoft/powerbi-report-authoring-cli

The first gives you the powerbi-desktop command. The second gives you powerbi-report-author, which works on the files rather than on Desktop: it looks up visual types and formatting properties, encodes PBIR values, and checks a report against the PBIR rules with powerbi-report-author validate <path>. Your agent edits the files, the authoring CLI checks them, and the bridge shows them in Desktop.

If you use the Power BI Report Authoring skill from Microsoft’s Skills for Fabric repository, it installs both the first time you use it 3:48. How to Install Microsoft’s Fabric Skills covers that repository. Watch the names if you install by hand: an older package called powerbi-report-authoring, with no @microsoft/ scope, is a library for embedded reports and has nothing to do with these CLIs.

To confirm the bridge CLI can see Desktop, open a report and run:

powerbi-desktop status

3:57Manifest first, every session

The first thing the agent does in a session is read the manifest 3:57. The prompt in the demo was one line:

Run the manifest command in the Power BI Desktop Bridge CLI to see what other commands are available.

Claude Code ran the manifest against the running Desktop, process ID 11888, and reported three methods besides the manifest itself 4:26:

The manifest, as the agent read it back: three methods on this Desktop build.

Each method arrives with its parameters and result schema, so the agent learns both the call and its arguments in one step. Your Desktop version decides which methods the bridge has, so run the manifest first, every time, and the agent knows what’s available before it calls anything 4:12.

If more than one Desktop window is open, powerbi-desktop status lists each one with its process ID, its open file and its pages. Pass the ID to the other commands with --pid.

Read the state before you reload

Status protects work you’ve done in Desktop but haven’t saved 2:24, and it only helps if the agent reads it before it reloads. A reload rereads the files on disk, and unsaved changes in Desktop aren’t on disk. The CLI’s reload doesn’t check for them first: it reloads the report open in the selected window, whatever its state.

An agent that goes straight from editing to reloading looks like this:

edit the PBIR files
powerbi-desktop reload --pid <pid>
powerbi-desktop screenshot <page-id> --pid <pid>

Put the check in front of every reload instead:

powerbi-desktop status
  hasUnsavedChanges is true: stop and ask me to save in Desktop
edit the PBIR files
powerbi-desktop reload --pid <pid>
powerbi-desktop screenshot <page-id> --pid <pid>

Add one line to your prompt: “Before every reload, run powerbi-desktop status, and if hasUnsavedChanges is true, stop and ask me to save.” The simplest habit is to save in Desktop before you hand the report to the agent.

4:40The demo: a table, a prompt, five criteria

The demo report is the Sales report an agent built in the Fabric skills report article. Its Product Performance page ends in a Top Products table, one row per product, and to me it looked a little bare 4:40.

Product Performance before the run, with the Top Products table at the bottom.

The task was to replace the table with a matrix carrying four kinds of conditional formatting. I wanted something hard that needs a lot of visual inspection, and conditional formatting does 5:06. A criterion such as “no data bar clipped or covering its number” can only be graded on the rendered page. I pasted this prompt into Claude Code 4:53:

Replace the "Top Products" table at the bottom of the Product Performance report page with a matrix. Same position, same footprint.

Matrix:
- Rows: Category, with Subcategory nested under it
- Values: Revenue, Units Sold, Gross Margin %, plus a sparkline of monthly Revenue (find the right date field in the model)

Format the columns as follows:
- Revenue: data bars
- Gross Margin %: red-yellow-green background gradient
- Units Sold: up / flat / down icons, thresholds picked from the actual data
- Keep the grand total row: bold, subtle fill, and conditional formatting on detail rows only (nothing bleeds into the totals)
- Match the fonts and header styling of the other visuals on the page

When you think you're done, verify your own work through the Desktop Bridge CLI: reload the report, take a screenshot, and grade it against these criteria:
1. Gradient readable against the light theme
2. No data bar clipped or covering its number
3. Icons aligned and pointing the right way
4. Sparklines show real variation, not flat lines
5. Totals row visually distinct, no formatting spill

If any criterion fails, fix it and screenshot again. Only report back when all five pass.

As you work, show your progress: after every Desktop reload, save the screenshot to C:\Demo\_progress (numbered), and maintain a single progress Artifact; publish it after the first screenshot and republish it after every iteration with a short caption of what changed, ending with the graded checklist.

The last paragraph asks for evidence: a numbered screenshot after every reload, and a progress page with a short summary of each round 5:27. The agent grades the screenshots; the progress page is for you.

5:48Eleven rounds, read from the agent’s log

The run took 11 rounds and about 27 minutes, with a screenshot in the progress folder for each round 5:48. The progress page tells the story in the agent’s words 6:10:

The progress page the agent kept, at its first round.

Round 1: three defects. The matrix replaced the table, and the sparklines, gradient and icons rendered. But the rows stayed collapsed at the Category level, Revenue had no data bars (“wrong host object”), and the icon thresholds came from “a silently truncated, unfiltered query”, while the page carries a saved Year = 2025 slicer.

Rounds 2 to 4: still collapsed. The data bars moved to columnFormatting, with a selector that names only the Revenue column, and rendered. The agent recomputed the icon thresholds on the full 2025 data, all 12 subcategories. To expand the rows, it rewrote the expansion state and gave the visual a new ID, so the reload couldn’t reuse the old drill state. The expand buttons appeared, and the subcategories still didn’t.

Round 5: one property. The agent found that matrices mark each Rows field "active": true, and without it only the first level takes part. Here is the Subcategory field in the finished visual.json:

{
  "field": {
    "Column": {
      "Expression": {
        "SourceRef": {
          "Entity": "Product"
        }
      },
      "Property": "Subcategory"
    }
  },
  "queryRef": "Product.Subcategory",
  "nativeQueryRef": "Subcategory",
  "active": true
}

The subcategories appeared, and the totals stayed clean: subtotal rows and the grand total carried no bars, icons or gradient. The agent credits its wildcard selectors for that. The gradient’s selector, for one:

"selector": {
  "data": [
    {
      "dataViewWildcard": {
        "matchingOption": 1
      }
    }
  ],
  "metadata": "Sales.Gross Margin %"
}

With every subcategory showing, the three rows under Accessories no longer fit in the visual’s 320 pixels.

Rounds 6 to 10: making it fit. The agent set row padding to zero, the text to 9 points and the sparklines to 12 pixels high, then trimmed the container padding from 8 to 0 and turned off the horizontal gridlines. Round 9 left Bottles clipped mid-bar, a criterion 2 failure, and the agent caught it in the screenshot. After round 10, all 17 rows and the header fit the original footprint with no scrollbar.

Round 11: the total row. The matrix ignored the formatting in the older total object. Styling rowTotal and columnTotal instead gave the Total row its bold text and its #E8EEF4 fill, which the agent checked by sampling the pixels in the screenshot.

The matrix after round 11, from the agent’s last screenshot.

Before rounds 5 and 11, Desktop loaded the files without an error. Only the rendered page showed that the subcategories were missing, and later that the total row’s formatting hadn’t applied.

I built the progress page mostly to show you the screenshots and the loop 6:29. You could also put the final screenshots into your change management or your requirements documentation 6:47.

7:00Write criteria the agent can grade

A looping prompt needs goals that are specific, measurable, attainable and detailed. “Make it better” doesn’t work, because the AI doesn’t know what to do with it 7:03. Each of the demo’s five criteria can be checked by looking at one screenshot:

1. Gradient readable against the light theme
2. No data bar clipped or covering its number
3. Icons aligned and pointing the right way
4. Sparklines show real variation, not flat lines
5. Totals row visually distinct, no formatting spill

Criterion 2 is the one that caught Bottles in round 9. Ask for the evidence as well, as this prompt did: numbered screenshots and a log of each round let you check the agent’s grading instead of taking its word for it.

7:25It’s preview, and it’s local only

The bridge is a preview feature, so I wouldn’t wire it into my CI/CD pipelines or anything load-bearing yet 7:28. Microsoft Learn notes that its features, behavior and API surface may change before general availability, which is one more reason for the agent to read the manifest every session.

It’s also local only. The bridge talks over a named pipe on your machine, with no remote access and no REST endpoint 7:35.

7:46Try it on your own report

Install the Desktop Bridge CLI, make sure you’re on the June 2026 release of Desktop or newer, and point your agent at a project you’ve been meaning to work on 7:46. Save in Desktop first, have the agent read the manifest, and give it criteria it can grade from a screenshot. The download has the demo’s starting report, the prompt, and the agent’s finished matrix to compare with your run. To set up an agent first, How To Use Claude Code for Power BI Development installs Claude Code in the VS Code terminal and covers its permission prompts and modes.