Key takeaways
- Agentic development means directing an AI agent to build and iterate Power BI models and reports — often from the terminal, not by clicking through Power BI Desktop.
- Practitioners are now building sophisticated reports in under an hour, using an agent (like Claude) with an MCP server, Tabular Editor and a report CLI.
- Report development is hard because three layers must harmonise — theme, semantic model and visual formatting — so the agent has to see the output and iterate.
- The human still owns the design and business logic. Stay in the loop with small, incremental changes; the agent is an executor of intent.
Something genuinely new is happening in Power BI development. Instead of building a semantic model and report by clicking through Power BI Desktop, experienced practitioners are starting to direct AI agents to do it — from the terminal, iterating in minutes, and reviewing the output as they go. A recent in-depth walkthrough showed a full, sophisticated report built in under an hour. Here is what agentic development in Power BI actually looks like, and what it means for how BI work gets done.
The breakthrough: from clicking to directing
The headline is a shift in where the work happens. Rather than the Power BI Desktop UI, the workflow moves to a terminal, where an AI agent edits the model and report as code and publishes changes for review. And it no longer requires elaborate, specialised prompts — the agents have become capable enough that clear direction and good inputs are usually enough. What used to take a skilled developer a day can be drafted in well under an hour.
The new stack
The setup in the walkthrough combined a few pieces, and it is worth understanding each:
- The agent — Claude, directing the whole workflow.
- An MCP (Model Context Protocol) server — the bridge that connects the agent to Tabular Editor (running on a remote VM), so it can clean up and organise the semantic model in a structured way.
- A report CLI — used to generate and edit the report metadata (the PBIR layer) as code.
- PBIP project files — the text-based project format that makes the model and report editable and reviewable in the first place.
Together, these let an agent do real BI work: reshape the model, write and organise DAX, and build report pages — all outside the traditional desktop tool.
Why report development is genuinely hard for an agent
Building a model with an agent is one thing; building a polished report is harder, and the walkthrough was honest about why. A Power BI report has to harmonise three layers at once:
- The report theme — colours, fonts and default styles.
- The semantic model — the DAX and dynamic format strings that decide what the numbers say and how they display.
- The visual formatting — the per-visual settings on the canvas.
Unlike a web app, there is no single tool that guarantees how it all renders together. That is the crucial insight: the agent cannot just write code and assume it looks right — it has to inspect the actual output (screenshots, or viewing the published report in a browser) and iterate against what it sees.
The workflow, step by step
- Model cleanup and organisation — the agent, connected through MCP to Tabular Editor, tidies and structures the semantic model: naming, folders, relationships, DAX.
- Report generation — using the report CLI, the agent builds the report metadata as code.
- Publish and inspect — the agent publishes the changes, then looks at the result via screenshots or the browser.
- Iterate in small steps — it makes incremental adjustments, re-publishes, and checks again — a tight visual feedback loop rather than one big generation.
The mindset shift: planning and documentation are the new inputs
Perhaps the most important takeaway for teams: the valuable work moves upstream. When an agent can execute quickly, the quality of the output depends on the quality of the documentation and user-oriented planning you feed it — the business questions, the definitions, the intended design. Thorough planning is no longer bureaucracy; it is the primary input that determines whether the agent builds the right thing.
Stay in the loop
Even with capable agents, the strong recommendation is to stay in the loop: make small, incremental changes and review each one, rather than handing over full control. Let the agent run unchecked and you risk subtle errors in calculation logic or unintended formatting drift — the kind of thing that is expensive to unpick later. The agent is fast; your judgement is what keeps it correct.
The honest limitations
- Design and business logic must come from the human. The agent is an executor of your intent, not a replacement for it.
- Precise visual alignment is still hard — agents can struggle with fine details like clipping and pixel-perfect layout.
- But the trajectory is steep: the ability to build a report from scratch this way is dramatically more advanced than it was even a few weeks earlier.
What this means for BI teams
Agentic development does not remove the need for skilled BI people — it changes what that skill looks like. The premium moves to directing agents well, judging their output, and owning the design and business logic. That is exactly the toolchain and discipline we teach in our Power BI in the Age of AI course — MCP, PBIP project files, Tabular Editor, GitHub and Copilot, with a strong emphasis on staying in the loop. If you are curious where to start, our guides to AI agents for Power BI and Power BI as code are a good next read.
This article draws on an in-depth community walkthrough of agentic Power BI development using Claude, an MCP server, Tabular Editor and a report CLI. (The presenter discloses that they work with Tabular Editor.)
Frequently Asked Questions
What is agentic development in Power BI?
Directing an AI agent, such as Claude, to build and iterate Power BI semantic models and reports — often from the terminal rather than clicking through Power BI Desktop — with the human steering and reviewing every step.
What tools make it possible?
An AI agent connected to the model through an MCP server, plus Tabular Editor for the semantic model and a report CLI for the report metadata. The work is done on text-based PBIP files, so every change is editable and reviewable.
Can AI really build a Power BI report from scratch?
Increasingly, yes — practitioners now draft sophisticated reports in around an hour. But the agent still needs a human to define the design and business logic; it executes intent rather than inventing it.
Why does the agent need to see the report?
Because a Power BI report harmonises three layers — the theme, the semantic model (DAX and format strings) and visual formatting — and no single tool guarantees the final look. The agent inspects screenshots or the published report and iterates.
What is the biggest risk with agentic development?
Handing over too much control. Best practice is to stay in the loop with small, incremental changes so calculation logic and formatting do not drift. Clear documentation and planning are now the most valuable inputs.
