DEV Community: Tabgen

What is TabGen? A free local app that turns a prompt into a Tableau dashboard — and why it's not just another MCP server

Tabgen — Sun, 20 Sep 2026 08:07:56 +0000

If you've ever opened Tableau Desktop with a clean CSV and then lost an hour to clicking — dragging pills onto shelves, fixing an axis, rebuilding the same profit-ratio calc for the hundredth time — this post is for you.

TabGen is a small, free Windows app that closes the gap between "the data is ready" and "the dashboard is ready." Drop in your data, describe what you want in plain English, click Generate, and you get a real, editable Tableau .twbx workbook. You can grab it at tableaugen.com.

What is TabGen, exactly?

TabGen turns your data — a CSV, an Excel file, or a database connection — into a packaged Tableau workbook using AI. The important details:

It runs 100% locally. It's a self-contained app (it bundles its own Python runtime) that opens in your browser at localhost:8000. Nothing to configure.
You bring your own AI key. Use your own Claude (Anthropic) or ChatGPT (OpenAI) key. It's held in memory for the session only — never written to disk.
Your data stays put. Only a compact schema and a small sample of rows go to the model. Your actual rows never leave your machine.
The output is a normal .twbx. Open it in Tableau Desktop or the free Tableau Public and edit everything — swap a mark type, restyle, publish. TabGen writes the first draft; Tableau is where you finish.

You describe the dashboard the way you'd describe it to a colleague:

Executive sales overview: KPIs for total sales and profit,
sales trend over time, top 10 products, and sales by region.

…and TabGen builds the KPI cards, the time-series line, the top-N bar chart, and the regional map — arranged on one dashboard. No special syntax. See more examples on the site.

"But there's already a Tableau MCP server…"

True — and I built one of those too (it's called Twilize). The Model Context Protocol is great. So why build an app on top of it? Because an MCP server and a tool like TabGen solve genuinely different problems, and it's worth being clear about which one you actually need.

An MCP server exposes a set of tools to a language model — list_datasources, run_query, get_workbook — and the model decides, turn by turn, which to call. It's a conversation. That's fantastic for exploration and Q&A over data that's already in Tableau: "which region is dragging down Q3 margin?" is a perfect MCP question.

But building a polished dashboard isn't a Q&A task — it's a construction task with dozens of interdependent decisions. That's where the bare-MCP approach starts to strain:

1. An MCP server needs a live, connected Tableau. TabGen doesn't.

MCP operates on a running Tableau Server/Cloud site with credentials and published sources. TabGen starts from a file or a database on your own machine and hands you a .twbx. No site, no admin rights.

2. Non-determinism is great for chat, rough for delivery.

Ask an MCP agent to "build a sales dashboard" twice and you may get two different tool-call sequences — or a half-built result when the model loses the thread. TabGen wraps the model in a deterministic pipeline: profile the data → parse intent → validate against the real schema → assemble from a proven template → package the file. The model makes the design choices; the scaffolding guarantees a complete, openable workbook every time.

3. Someone has to validate the output. With raw MCP, that's you.

Models hallucinate field names, invent calcs that don't compile, and cheerfully build a map for data with no geography. TabGen checks every step against your actual schema and silently drops anything that fails — so nothing malformed reaches the file.

4. MCP assumes you can drive an AI agent.

Editing JSON config, managing a client, handling tokens, prompting an agent through a multi-step build — fine for developers, a wall for the analyst who just has a spreadsheet and a deadline. TabGen is a double-click installer and a text box.

An MCP server gives a model access. TabGen gives you an artifact. One is a protocol for AI-to-tool conversation; the other is a product with a job to finish.

I wrote this up in more depth here: Why TabGen beats a raw Tableau MCP server.

When you should reach for the MCP server

I'm not burying MCP — it's the right layer for conversational analytics over governed Tableau environments, and for agentic workflows you're building yourself. But none of those is "I have a CSV and I want a good dashboard in two minutes." That's the gap TabGen fills.

Try it

TabGen is free to download, runs locally, and works with your own Claude or ChatGPT key. Point it at your data, type a sentence, and see what the first draft looks like — you'll know in a minute whether it fits.

👉 Download TabGen at tableaugen.com

If you want to go deeper first:

One prompt, one working Tableau dashboard — how the generation actually works
Inside the .twbx: building a Tableau workbook from scratch — the internals
AI won't replace Tableau developers — the honest take on what changes

What would you point it at first? Let me know in the comments.

I Generated a Tableau Dashboard Using Gemma 4 — Locally, No API Key, No Cloud

Tabgen — Thu, 28 May 2026 11:39:28 +0000

Why I Wanted to Try This With Gemma 4

I’ve been building Twilize — a tool that generates Tableau workbooks from natural language — for a while now. Most of my own testing uses the Anthropic API because Claude gives the sharpest schema reasoning. But I kept getting the same question from enterprise users: “We can’t send data to a third-party API. Can this work entirely offline?”
So I decided to actually do it myself, document every step, and share what the output quality looks like when Gemma 4 is doing the thinking. No API key. No internet after the initial model download. Just a CSV, a local model, and Twilize.

Here is exactly what I did.

What You Need Before You Start
• Windows 10 or 11, 64-bit
• Python 3.10+ installed and on PATH — tick “Add Python to PATH” in the installer
• Twilize Standalone v1.01 — download at twilize.com
• Around 6 GB of free disk space for the Gemma 4 model weights
• 8 GB RAM minimum; 16 GB recommended for comfortable performance
• A CSV to visualise — I used the classic Superstore sales dataset

First-time internet access is needed once to pull the model weights. After that, everything runs air-gapped.

1 Install Twilize and Launch the Dashboard Builder

Run the installer (Twilize-Standalone-Setup-1.01.exe). Accept the defaults. At the end of the wizard you’ll see an optional checkbox: “Download Ollama + Gemma 4”. I left this unchecked — I wanted to control the download timing myself.
After install, launch via: Start Menu → Twilize → Twilize Dashboard Builder
A console window opens. On first launch, Twilize self-installs Python packages into %LOCALAPPDATA%\Twilize\packages — about 30 seconds. Then the browser opens at http://localhost:8000 automatically.

⚠️ Important: Keep the console window open. Closing it stops the server. Minimise it and leave it running.

2 Download Gemma 4 Through the AI Provider Panel

In the Twilize UI, open the AI Provider panel. Select Gemma 4 (Local) and click Download.
What happens automatically:
1.Twilize checks whether Ollama is already installed on your machine
2.If not, it runs winget install Ollama.Ollama — no separate installer needed
3.Once Ollama is confirmed, it pulls the model weights: ollama pull gemma4
4.The download is roughly 6 GB — expect 5 to 15 minutes depending on your connection
5.When done, the panel shows a green “ready” badge next to Gemma 4

💡 Verify at any time: Open a new PowerShell window and run ollama list. You should see gemma4 in the model list.

# Verify Ollama sees the model
PS> ollama list

NAME ID SIZE MODIFIED
gemma4:latest a1b2c3d4e5f6 6.1 GB 2 minutes ago

3Load the CSV Into the Data Source Panel

Click the Data Source panel and choose the File Upload tab. Drag and drop your CSV. I used the Superstore Sales file — 9,994 rows with fields like Order Date, Region, Category, Sales, Profit, and Discount.
Twilize immediately shows you:

•Inferred field types — measure (numeric) vs dimension (categorical or date)
•A sample of the first few rows
•Row and column counts

Spend 30 seconds reviewing the type inference. In my test, Postal Code was correctly flagged as a dimension despite being numeric — a small but important detail that affects how Tableau handles it on maps.

4 Write the Prompt

This step is optional but meaningfully shapes the output. I wanted a regional sales dashboard with a profit breakdown, so I typed:

Executive summary focused on regional sales trends and profit by
category. Include a year-over-year comparison and highlight the top 5
sub-categories by sales. KPI tiles at the top for total sales,
total profit, and profit margin.

You don’t need to specify chart types — Gemma 4 infers appropriate charts from the schema and your intent. But the more specific your prompt, the closer the first draft lands.

🔍 What works well in prompts: Business objectives ('executive summary'), specific fields to feature, layout hints like 'KPI tiles at top', and constraints like 'focus on 2023 data only'.

5 Run Suggest and Review the Dashboard Plan

Click Suggest. Gemma 4 analyses the schema and your prompt, then returns a proposed dashboard plan. On my machine (16 GB RAM, no GPU) this took about 45 seconds — noticeably slower than the Anthropic API but entirely acceptable for a one-time suggestion step.
The plan Gemma 4 returned proposed six charts:

KPI tiles — Total Sales, Total Profit, Profit Margin (calculated field)
Bar chart — Sales by Region, sorted descending
Line chart — Monthly Sales trend, coloured by Year for year-over-year overlay
Bar chart — Profit by Category with a reference line at zero
Treemap — Sales by Sub-Category, Top 5 highlighted
Scatter plot — Sales vs. Profit by Sub-Category, sized by Discount

This was better than I expected. Gemma 4 identified the date field correctly, proposed a year-over-year line rather than a flat trend, included the zero-reference line on the profit bar — a nuance that matters for any P&L-style chart — and added a scatter plot I hadn’t asked for but which made perfect sense given the three numeric fields.

🔄 If the plan isn’t right: Edit your prompt and click Suggest again. Each run is independent. I iterated once, adding 'show discount impact', and the scatter plot appeared in the revised plan.

6Generate the Workbook

Click Generate. The backend builds the .twbx file from the approved plan and your data. A progress indicator runs. With the Superstore file and six charts, generation completed in about 18 seconds.
The browser downloads the file automatically. The generation manifest:

{
  "dashboards": 1,
  "charts": 6,
  "required_charts_requested": 3,
  "required_charts_fulfilled": 3,
  "warnings": [],
  "style_reference": "none"
}

Zero warnings. All three pinned charts (KPI tiles, regional bar, YoY line) confirmed fulfilled.

7Open in Tableau Desktop or Tableau Public

Double-click the .twbx file. Tableau Desktop or the free Tableau Public opens it directly. The data is embedded — no reconnection required.
What I found already in place:

•All six sheets present and correctly named
•Profit Margin calculated field pre-built: SUM([Profit]) / SUM([Sales])
•Year-over-year line correctly split by Year (discrete), not continuous
•Zero-reference line on the profit bar, formatted in grey
•Treemap Top-5 filter using a Top N set — exactly the right approach

What needed a quick manual touch:

•Axis number format — Gemma used full integers; I switched Sales to abbreviated (K/M)
•Dashboard tiled layout needed minor resize to fit a 16:9 widescreen
•Colour palette — swapped Tableau’s default blue to a brand palette in about 2 minutes

Honest Assessment: Gemma 4 vs Claude for This Task
Dimension Gemma 4 (Local) Claude (API)
Suggest speed ~45 sec ~8 sec
Chart quality Very good Excellent
Calculated fields Good Excellent
Schema inference Good Excellent
Data privacy 100% local Sent to Anthropic
Cost per run Free ~$0.02–0.05
Needs internet One-time only Every run

The honest verdict: for most standard business dashboards, Gemma 4 gets you 85–90% of the way there. The remaining polish — axis formatting, layout tuning, brand colours — takes the same 10 to 15 minutes it would take to polish any first draft. What Gemma eliminates is the 45 to 60 minutes of blank-canvas chart setup and calculated field wrangling.
For complex schemas with nested LOD calculations or non-obvious field relationships, Claude gives meaningfully better first drafts. But for the volume of BI work that is “show me regional sales performance”, Gemma 4 offline is a serious option.

The Takeaway
Running a local LLM for dashboard generation isn’t a fallback anymore. It’s a legitimate first-choice for data teams with privacy constraints, air-gapped environments, or a desire to stop paying per-token for routine BI work.
The full stack I used:
• Twilize Standalone v1.01 — twilize.com
• Gemma 4 via Ollama — installed automatically by Twilize
• Superstore CSV — free from Tableau’s sample data page
• Tableau Public — free desktop app to open the .twbx

Total time from installer to open workbook in Tableau: under 20 minutes, including the 6 GB model download. Without the download, closer to 4.

💬 Have you tried local LLMs for any part of your analytics workflow? I’m curious whether the latency trade-off feels worth it at your scale — drop your experience in the comments.

Tags: Tableau · Gemma 4 · Local AI · Data Visualisation · Ollama · Business Intelligence · Twilize

PBIFORGE: The First AI Tool to Generate Full Power BI Dashboards from a Text Prompt

Tabgen — Mon, 18 May 2026 06:08:29 +0000

Until now, "AI-assisted" Power BI tools stopped at suggestions. PBIFORGE is the first to take a plain-English sentence and output a complete, working .pbix file — with visuals assembled, DAX written, relationships modeled, and formatting applied.

Why this is a bigger deal than it sounds
Power BI dashboard creation has always been a multi-stage technical process. You need to understand data modeling to create a BIM file. You need to know DAX to write measures. You need to understand the visual container format to position charts correctly. And all of this has to be wired together before a single report page renders.

Existing tools help at individual stages. Copilot in Power BI suggests DAX expressions. AI tools in Power Query help transform data. But none of them close the gap between "I want a revenue dashboard by region" and an actually downloadable .pbix file that opens in Power BI Desktop.

PBIFORGE(www.pbiforge.com) closes that gap entirely.

How the pipeline works
PBIFORGE(www.pbiforge.com) runs a four-stage pipeline every time you submit a prompt. Each stage feeds the next, and the whole thing completes in seconds.

Stage 1: Intent extraction
The prompt is parsed by a large language model trained to understand analytical intent. It extracts:

Which metrics matter (revenue, churn, headcount, NPA ratio)
Which dimensions to slice by (region, product, time, branch)
What time grain is implied (monthly, quarterly, YTD)
Which visual types fit the analysis (bar chart, line chart, KPI card, matrix)
Whether conditional logic is needed (alerts, thresholds, variance)
The result is a structured ReportIntent object — a typed representation of what the report should contain, not a free-form description.

Stage 2: Schema binding and BIM generation
From the intent object, PBIFORGE generates a full Business Intelligence Model (BIM) — the tabular model that Power BI uses to define tables, columns, data types, relationships, and measures.

This is where most "AI BI" tools stop. Writing valid BIM JSON is not trivial. The compatibility level must be exactly 1550. Partition expressions in the BIM must exactly match the table names used in the Power Query M code. Relationships must reference columns that actually exist. PBIFORGE handles all of this automatically.

{`
  "name": "SemanticModel",
  "compatibilityLevel": 1550,
  "model": {
    "tables": [
      {
        "name": "Sales",
        "columns": [...],
        "measures": [
          {
            "name": "Total Revenue",
            "expression": "SUM(Sales[Revenue])",
            "formatString": "$#,0.00"
          }
        ],
        "partitions": [{ "source": { "type": "m", "expression": "Sales" } }]
      }
    ]
  }
}`

Stage 3: Power Query M generation
Every table defined in the BIM needs a corresponding M query in a Section1.m file. PBIFORGE generates these automatically, using placeholder data sources that you swap for real connections once you open the file in Power BI Desktop.

The names in the M file must match the partition expressions in the BIM — character for character, case-sensitive. This is one of the most common reasons Power BI projects fail to compile. PBIFORGE validates this before writing a single file to disk.

Stage 4: Visual layout assembly
The final stage generates the report layout — the JSON files that tell Power BI Desktop how to render each page, where each visual sits, and how it connects to the data model.

Visual layout is the most finicky part of the .pbix format. The config, filters, query, and dataTransforms fields inside each visual container must be double-serialized JSON strings, not nested objects. Getting this wrong produces visuals that render as blank white boxes. PBIFORGE handles serialization automatically.

The three breaking points PBIFORGE solves automatically: (1) BIM compatibility level must be exactly 1550. (2) BIM partition names must exactly match M query names. (3) Visual config fields must be JSON-encoded strings, not nested objects. Every PBIFORGE output is validated against all three before the file is written.

What you actually get out
The output of a PBIFORGE(www.pbiforge.com) prompt is a real .pbix file. Not a screenshot. Not a JSON spec. Not a template you fill in by hand. A downloadable, openable Power BI Desktop file with:

A full data model with tables, columns, data types, and relationships
DAX measures for every metric implied by the prompt
Report pages with positioned visual containers wired to the right fields
A consistent theme applied across all visuals
Power Query M code for each table (with placeholder sources you update once)
The first draft is not production-ready in every case — you will likely refine the DAX, update the data sources, and adjust the layout. But you start from a working scaffold that would otherwise take hours to build by hand.

Why this is "the first"
The claim is specific: PBIFORGE is the first tool to generate a complete .pbix file from a text prompt. This means all four components — the data model, the M code, the DAX, and the layout — produced together, validated against each other, compiled into a single file.

Microsoft's Copilot features inside Power BI Desktop assist with individual steps. Third-party tools generate DAX suggestions or Power Query transformations. But none of them produce a downloadable .pbix from a sentence. PBIFORGE does.

How to try it
PBIFORGE is available as a one-time $10 local package. You download the ZIP, run it locally with your own Anthropic API key, and generate as many reports as you need. There is no subscription, no per-report fee, and no cloud dependency for the generation pipeline.

The local architecture also means your data schema stays on your machine. The only thing that leaves is the natural language prompt — and even that can be kept generic until you have a baseline report to refine.

I Built a Tableau Dashboard with an AI Agent. Here’s Every Step That Actually Happened.

Tabgen — Sun, 05 Apr 2026 16:08:26 +0000

Every Tableau developer knows the gap. The data is clean, the CSV is sitting in a folder, the stakeholder already knows what they want to see, and yet the next hour disappears into clicking. You drag pills onto shelves. You fix an axis that insists on starting at zero. You rebuild the same profit-ratio calculation you've written a hundred times before. None of it is hard. All of it is slow.

I've spent more than a decade in enterprise presales, and a large part of that time has been spent in exactly that gap: taking data that's ready and turning it into a dashboard that's ready. So when AI agents became genuinely capable, the obvious question was whether an agent could close that gap for me.

The short answer is yes, but not the way I first expected. Here's the full story, step by step.

Step 1: I started with an MCP server

My first attempt was the approach everyone reaches for today: a Model Context Protocol server. I built one called Twilize, which exposes Tableau operations as tools a language model can call.

MCP is a great protocol. The model gets a set of tools (listing data sources, running queries, fetching workbooks) and decides, turn by turn, which one to call next. It's a conversation between the AI and your tools.

For certain jobs, that conversation is exactly right. Ask "which region is dragging down Q3 margin?" against a governed Tableau environment and an MCP-connected agent shines. It explores, queries, and reasons its way to an answer.

Then I asked it to build a complete sales dashboard, and I started noticing the cracks.

Step 2: I found out that building isn't the same as answering

A polished dashboard isn't a Q&A task. It's a construction task with dozens of interdependent decisions: which fields become KPIs, what the time grain should be, which chart suits which measure, how everything fits on one canvas, which calculations are needed and whether they'll actually compile.

When you give that job to a free-running agent, four problems show up quickly.

It needs a live Tableau connection. MCP works on a running Tableau Server or Cloud site, with credentials and published data sources. If you're an analyst holding a spreadsheet, you usually don't have that, and you certainly don't have admin rights to set it up.

It's non-deterministic. Ask the same agent to "build a sales dashboard" twice and you can get two different sequences of tool calls. Sometimes you get a half-built result because the model lost track partway through. That's fine in a chat. It's a real problem when you need something you can hand over.

Someone has to check the output, and that someone is you. Models invent field names that don't exist. They write calculations that won't compile. They'll happily build a map for a dataset with no geographic fields at all. With a raw MCP setup, catching all of that is your job.

It assumes you know how to drive an agent. Editing JSON config, managing a client, handling API tokens, guiding a model through a multi-step build: developers are fine with this. For the analyst with a deadline, it's a wall.

None of this means MCP is bad. It means I was using a conversational protocol for a manufacturing job.

Step 3: I wrapped the model in a pipeline

The shift in my thinking was simple. The AI should make the design decisions. It should not be responsible for the scaffolding.

So I built TabGen, a small, free Windows app that places the model inside a deterministic pipeline. Every run follows the same five stages.

Profile the data. TabGen reads your CSV, Excel file, or database connection and builds a compact profile: field names, data types, which columns are dimensions and which are measures, and whether there's anything date-like or geographic.
Parse the intent. You describe the dashboard in plain English, the way you'd explain it to a colleague. For example:

Executive sales overview: KPIs for total sales and profit, sales trend over time, top 10 products, and sales by region.

The model turns that sentence into a structured plan: two KPI cards, a time-series line, a top-N bar chart, and a regional map.

Validate against the real schema. This is the stage raw agents skip. Every field the model references is checked against the actual data. Every calculation is checked. If the model proposes a map and there's no geography, that element is dropped. Anything that fails validation never reaches the file.
Assemble from proven templates. The validated plan is built using workbook structures I know open correctly in Tableau, not XML the model improvised on the spot.
Package the workbook. The output is a standard .twbx file. You open it in Tableau Desktop or the free Tableau Public and everything is editable.

For the prompt above, what comes out is exactly what was described: KPI cards at the top, the sales trend, the top-10 products bar chart, and the regional map, laid out on a single dashboard. And because the pipeline is fixed, you get a complete, openable workbook every time, not just when the model happens to have a good run.

Step 4: I made privacy and setup non-issues

Two concerns come up in every enterprise conversation I've had in presales: Where does my data go? and How painful is this to install? I designed TabGen to answer both before anyone asks.

It runs entirely on your machine. The app bundles its own Python runtime and opens in your browser on localhost. There's nothing to configure.

You bring your own AI key. TabGen works with your own Anthropic (Claude) or OpenAI (ChatGPT) key. The key stays in memory for the session and is never written to disk.

Your rows stay local. Only a compact schema and a small sample of rows are sent to the model, which is enough for it to understand the shape of the data. The full dataset never leaves your computer.

Installation is a double-click, and the interface is a text box and a Generate button.

Step 5: I let Tableau do the finishing

This is the part I most want people to understand: TabGen doesn't try to replace Tableau or the person using it.

It writes the first draft. Tableau is still where you finish. Change a mark type, adjust the colour palette, tweak a tooltip, add the one custom calculation only your business understands, then publish. The tedious 80% is done, and you spend your time on the 20% that actually requires judgement.

That's also why I don't believe AI will replace Tableau developers. It will replace the clicking. The thinking stays with you.

So when should you use which?

After building both, here's how I'd summarize it:

An MCP server gives a model access. TabGen gives you an artifact.

Use an MCP server for conversational analytics over a governed Tableau environment, or when you're building your own agentic workflows and want the model to explore freely.

Use TabGen when you have a file or a database, a clear idea of what you want to see, and no interest in spending the next hour clicking. "I have a CSV and I want a good dashboard in two minutes" is exactly the problem it was built to solve.

Try it yourself

TabGen can be downloaded at tableaugen.com. It runs locally and works with your own Claude or ChatGPT key. Point it at a dataset, type a sentence, and look at the first draft. Within a minute you'll know whether it fits the way you work.

If you try it, I'd love to hear what you point it at first. Leave a comment and tell me what worked and what broke. Those reports are how the pipeline gets better.

The AI Agent That Builds Tableau Dashboards for You — Meet Twilize

Tabgen — Fri, 27 Mar 2026 04:13:06 +0000

You describe the dashboard. The AI builds the file. You open it in Tableau Desktop and it’s done.

If you’ve ever spent an afternoon rebuilding a Tableau dashboard because the underlying data source changed, or waited on an analyst to create “just one more chart,” or tried to explain to a developer exactly how you want a layout to look — this article is for you.

Twilize lets AI agents — including Claude, Cursor, and VSCode — build complete, ready-to-open Tableau workbook files (.twb and .twbx) from scratch, automatically. No clicking. No dragging. No formatting. The AI generates a real Tableau file that you open directly in Tableau Desktop.

It may be the world’s first AI agent purpose-built for Tableau workbook generation.

Why Tableau Dashboard Creation Is Still Broken
Tableau is powerful. But anyone who works with it regularly knows the hidden time tax:

Every new dashboard means starting from scratch, manually configuring charts, wiring up data sources, arranging layouts, and formatting everything to match brand standards. Multiply that across a team, across quarterly updates, across business units asking for “basically the same dashboard but for their region” — and the hours add up fast.

The promise of AI-assisted analytics has mostly delivered chat interfaces that talk about your data. Twilize does something different: it builds the actual Tableau file.

What Twilize Actually Does
At its core, Twilize is two things:

An MCP (Model Context Protocol) server that connects directly to AI tools like Claude Desktop, Cursor IDE, and VSCode. This means you can describe a dashboard to Claude in plain English and Claude uses Twilize under the hood to construct the actual workbook file — chart types, layouts, calculated fields, interactions, and all.

A tableau desktop based extension a .trex file than can create no click dashboards in .twb/.twbx format

The output in both cases is the same: a real .twb or .twbx file that opens directly in Tableau Desktop, fully formed.

The Workflow in Plain English
Here’s how a typical Twilize session works when used with an AI assistant like Claude:

You connect Twilize to your AI tool of choice (one config file change — see setup below).
You describe what you want: “Build me a sales overview dashboard with a bar chart of revenue by category, a pie chart showing customer segments, and a KPI card showing total profit.”
The AI calls Twilize’s tools behind the scenes — adding worksheets, configuring chart types, wiring up fields, building the dashboard layout.
Twilize generates and validates the .twb file.
You open it in Tableau Desktop. It’s ready.
The entire process that used to take an analyst two to four hours can happen in minutes.

What Kinds of Dashboards Can It Build?
Twilize supports a broad range of chart types and dashboard patterns out of the box:

Core charts — the stable, reliable building blocks: Bar charts, Line charts, Area charts, Pie charts, Maps, Text/KPI cards.

Advanced patterns — supported for more complex analytical needs: Scatterplots, Heatmaps, Tree Maps, Bubble Charts, Dual-Axis compositions, Table Calculations (running sums, rankings, window aggregations), KPI difference badges, Donut charts, and rich-text label cards.

Showcase recipes — high-impact visual patterns for executive and presentation dashboards: Lollipop charts, Butterfly (diverging bar) charts, Bullet charts, Calendar heatmaps, and Bump charts.

Beyond charts, Twilize handles the things that usually eat up the most analyst time: calculated fields, parameters for what-if analysis, dashboard filter and highlight actions, and multi-pane layout composition.

The Feature That Will Save Your Team the Most Time: Workbook Migration
Here’s one of Twilize’s most underappreciated capabilities, and probably the one with the highest immediate business value.

Write on Medium
The problem: You have a Tableau dashboard that works beautifully — but the underlying data source has changed. Maybe it’s a new Excel file with slightly different column names. Maybe it’s a database that was restructured. Maybe you’re rolling out a localized version for another market. Normally, this means manually remapping every field in every worksheet. On a complex dashboard, that’s a half-day task prone to errors.

Twilize’s solution: An automated workbook migration workflow. You point Twilize at the existing .twb workbook and the new data source, and it:

Scans the new data source and maps its columns.
Inventories every field the existing workbook uses.
Proposes a field-by-field mapping between old and new (using fuzzy matching).
Shows you a preview of what will change before touching anything.
Writes the migrated workbook, plus a JSON audit report of every field mapping decision.
If any mappings are uncertain, it pauses and asks for human confirmation before proceeding. The output is three files: the migrated .twb, a migration_report.json with the status of every field, and a field_mapping.json for audit trails.

For teams that manage dashboards across regions, business units, or fiscal year data refreshes — this single feature could save dozens of hours per year.

Built-In Quality Control
One thing that distinguishes Twilize from a “generate and hope” tool is its built-in validation layer. Before any workbook is saved, Twilize automatically checks the XML structure for fatal errors and warns about potential issues. It also supports full schema validation against the official Tableau TWB XSD specification (version 2026.1) — the same structural standard Tableau itself publishes.

This matters for enterprise contexts where bad workbooks waste analyst time and erode trust in automated tooling. Twilize won’t quietly hand you a broken file.

Setting It Up: Simpler Than You’d Expect
Getting Twilize connected to Claude Desktop takes about two minutes. Install it with a single pip command, then add one entry to your Claude configuration file:

json

{
"mcpServers": {
"twilize": {
"command": "uvx",
"args": ["twilize"]
}
}
}
The same one-line command works for Cursor IDE, VSCode, and Claude Code. After that, your AI assistant has the full power of Twilize available as a set of tools it can call on demand — no additional setup, no API keys for Twilize itself.

Who Should Be Paying Attention to This?
Tableau developers and analysts who spend significant time rebuilding similar dashboards for different teams, regions, or reporting cycles. Twilize turns that work into a repeatable, automatable workflow.

BI managers and data team leads looking to standardize dashboard templates across their organization. With Twilize, you can define a “golden template” and generate compliant variants programmatically — with validation built in.

Business users who know what they want to see but don’t have the Tableau skills to build it. If you can describe a dashboard to an AI assistant, Twilize can build it.

Developers building data products who want to generate Tableau content as part of an automated pipeline — think: automatically generating client-specific dashboards from a SaaS platform, or building Tableau reports as part of a data delivery workflow.

What Makes Twilize Different from Tableau’s Own AI Features
Tableau has invested heavily in its own AI capabilities (Tableau Agent, powered by Salesforce’s Einstein Trust Layer). It’s excellent for interactive, in-product exploration — asking questions, getting chart suggestions, adjusting visualizations in the browser.

But Tableau’s AI operates inside the Tableau interface. It requires a licensed Tableau Cloud or Tableau Server session. It doesn’t generate standalone workbook files you can version-control, share, or deploy programmatically. And it can’t automate workflows that need to run without a human in the loop.

Twilize operates entirely outside Tableau. It generates static .twb/.twbx files that work with Tableau Desktop, Server, and Online — no special license tier required. This makes it complementary to Tableau's native AI, not a replacement: use Twilize to build the workbook, use Tableau's AI to explore it.

The Bigger Picture: Why This Matters Now
The emergence of MCP (Model Context Protocol) as a standard for connecting AI models to external tools is changing what’s possible in enterprise software. Twilize is one of the first serious examples of MCP being applied to a major BI platform — and it’s a preview of what’s coming.

As more tools expose MCP interfaces, AI assistants will be able to operate across your entire data stack: pulling from databases, generating Tableau workbooks, pushing to Slack, updating records in Salesforce — all from a single natural language instruction. Twilize is an early but technically grounded step in that direction for the Tableau ecosystem.

The dashboard bottleneck is a solvable problem. Twilize is starting to solve it.

Have you tried Twilize? Building on top of it? I’d love to hear what use cases you’re exploring — drop a comment below.

Tags: Tableau, Business Intelligence, AI Agents, Data Visualization, MCP, Claude, Dashboard Automation, Data Analytics, Low-Code, Open Source