📉 The one-in-five problem 0:00
The opening observation is one most people have hit without naming it. An agent will build an entire backend in minutes, then be asked for a single waterfall chart and hand back a hundred lines of Vega-Lite that renders a blank page. The instinct is to blame the model.
Microsoft Research's bet is that this is misdiagnosed. It is not a model problem, it is a language problem — and the fix is a new intermediate layer rather than a better prompt or a bigger model.
🧩 Meaning and geometry 0:35
The insight that makes the whole thing click: chart generation is secretly two jobs, and models are asymmetrically good at them.
| Job | What it involves | LLMs at it |
|---|---|---|
| Meaning | This column is a month, that one is revenue, that one is a percentage change | They nail it |
| Geometry | Axes, step sizes, scale domains, label spacing, colour ramps | Unreliable — and this is where charts die |
So Flint splits the work. The model writes about ten lines of JSON describing only meaning, using semantic types — quarter, price, rank, percentage change, and 70-plus others. Then a deterministic compiler takes over, makes every geometric decision, and emits a real Vega-Lite, ECharts or Chart.js specification.
Worth pausing on why that division is principled rather than convenient. Semantic classification is a judgement task with fuzzy inputs — exactly what language models are built for. Axis scaling is arithmetic with a correct answer, and a compiler that gets it right once gets it right every time. Flint routes each task to the machinery suited to it.
⚙️ Setup and first chart 1:45
Installation is a single line — claude mcp add flint. Pure TypeScript on Node 18, and the presenter notes nothing unusual on Apple silicon.
The demo: paste a CSV of monthly signups, ask for new users by month per game as a heatmap. Claude writes a ten-line Flint spec, calls render_chart, and the finished PNG lands in the chat within seconds — rendered locally, so the data never leaves the machine.
create_chart_view opens an interactive panel. No re-prompting, no additional tokens. The model has finished its job and the chart remains editable — which is a meaningfully different interaction model from "the agent hands you an image and you ask it to try again".🎨 What semantic types buy you 2:27
Everything hangs on the semantic types, and the demonstration is well chosen. Change one word — the column tagged quantity becomes percentage change — and the compiler:
- Flips the entire colour scheme to a diverging palette
- Rewrites the number formatting
- Rescales the axis
One word in, a dozen correct decisions out. The framing the presenter offers is the one to remember: you tell Flint what the data is, never where the pixels go.
The second consequence is portability. Because the output is a genuine Vega-Lite, ECharts or Chart.js spec, the same input works with whichever backend you already use. There is no Microsoft rendering island — the compiled spec is yours to hand-tune. Flint positions itself as an intermediate language that gets you 95% of the way, not a replacement for anything.
🆚 Why not just Vega-Lite? 3:12
The obvious objection from anyone in data science, and the video meets it directly: Flint is not fighting Vega-Lite. It compiles to it.
The argument is about where the abstraction leaks. Vega-Lite feels high-level right up until you want the chart to look good — at which point a waterfall balloons past a hundred lines of coupled parameters. The same waterfall in Flint is about ten lines, because the compiler owns all the awkward parts.
| Alternative | The video's position |
|---|---|
| Vega-Lite | Not a competitor — Flint's compile target. ~100 lines vs ~10 for a waterfall |
| Mermaid | Different job — flowcharts. "You don't ship Mermaid charts to customers" |
| Chart MCP servers | 26 separate tools, and they render your data on someone else's server |
| Flint | Five tools, one schema, all local |
⚠️ The caveats 3:56
To the video's credit, roughly a third of its running time is spent here rather than on the demo.
It is a research project, not a product
Around two months old, version 0.2.8 at time of filming, 8 contributors. They were still catching bugs that month where the same spec rendered differently in Vega-Lite and in ECharts — which, for a tool whose entire pitch is backend portability, is the bug that matters most.
The viral number has a cut in it
The claim doing the rounds — 100,000 tokens down to 200 per chart — is the author's own figure. Zero benchmarks, and at the time of filming the paper was still listed as coming soon.
The sharpest objection
That is the honest framing, and it narrows the case considerably. What is left: small or cheap models, composite charts such as waterfalls and sunbursts, and any product where an end user sees the chart and 80% is not good enough.
Missing pieces
No maps. No 3D. No network graphs. No layering. Accessibility described in the video as an empty GitHub issue. And for Python developers, no package yet — so do not go looking for one.
🎯 Who it is actually for 4:30
Two adoption signals are offered, and they are the strongest evidence in the video precisely because they are not the author's own numbers.
First, over 5,000 npm downloads a week for a two-month-old research drop. Second — and more telling — Flint is already used by Data Formulator, Microsoft's own analytics tool. Which means Flint has a customer inside the building keeping it alive.
🔭 The pattern underneath 5:13
The closing point is the one worth carrying away, and it is not about charts at all. The most-agreed-on reading was that agentic systems in general are converging on exactly this shape:
The justification is a single clean sentence: you can validate ten lines of JSON before it even renders. You cannot validate a hundred lines of generated D3.
That generalises well beyond visualisation. Any domain where a model currently emits a large, fragile artefact directly is a candidate for the same split — have the model produce a small semantic description, and let deterministic code expand it. The error surface shrinks to something you can actually check.
🔍 Claims checked
The video makes several checkable claims. Each was verified against the GitHub API, the npm registry, PyPI and arXiv:
| Claim | Result |
|---|---|
| Microsoft Research, open source, TypeScript | Confirmed — microsoft/flint-chart, MIT, TypeScript |
| Five MCP tools | Exactly five: render_chart, compile_chart, create_chart_view, validate_chart, list_chart_types |
| Over 70 semantic types | README states "70+" |
| Compiles to Vega-Lite, ECharts, Chart.js | Confirmed in the paper abstract |
| Used by Microsoft's Data Formulator | Confirmed — "flint-chart": "^0.2.1" in its dependencies |
| No Python package yet | pypi/flint-chart returns 404 (the unrelated flint maths package is a different project) |
| Over 5,000 npm downloads a week | Understated — 11,309 last week |
| About two months old, version 0.2.8, 8 contributors | Drifted — created 13 May 2026, now at 0.4.1 with 9 contributors |
| Accessibility is an empty GitHub issue | Not empty — issue #48 has a 579-character body, plus #62 on compiler-generated chart descriptions |
| Zero benchmarks; the paper is coming soon | Outdated — the paper is published: arXiv 2607.20775, 22 July 2026, five authors |
Version numbers, download counts and star counts move. Figures verified 28 July 2026.
💡 Key takeaways
- Chart generation is two jobs, not one. Meaning — which column is a date, which is a percentage — and geometry: axes, scales, spacing, colour. Models are reliable at the first and unreliable at the second.
- 80% success is a failing grade in production. One broken chart in five is fine in a demo and unshippable in a product with real users on the other end.
- The split is the whole design. The model emits ~10 lines of semantic JSON; a deterministic compiler makes every geometric decision. Each task goes to the machinery suited to it.
- You declare what the data is, never where the pixels go. Retagging one column from quantity to percentage change flips the palette, the formatting and the axis in one move.
- It compiles to what you already use. Genuine Vega-Lite, ECharts or Chart.js output — no proprietary rendering island, and the compiled spec is yours to hand-tune.
- It is not competing with Vega-Lite. A waterfall is ~100 lines of coupled parameters there and ~10 in Flint, because the compiler owns the awkward parts.
- Rendering is local. Five tools and one schema, versus chart MCP servers with 26 tools that render your data on someone else's machine.
- Frontier models already one-shot simple charts. If you are a power user on a large model, this solves a problem you do not have. The real case is small models, composite charts, and end-user-facing output.
- The paper is out, but the benchmark is not. Published 22 July 2026 — yet the abstract carries no success rates or comparative numbers. Mechanism documented, effect still unquantified.
- An internal customer beats a download count. Microsoft's own Data Formulator depends on
flint-chart. Downloads measure curiosity; a shipping dependency creates an obligation to keep it working. - Know what is missing before adopting. No maps, no 3D, no network graphs, no layering, no Python package, and accessibility still open.
- The generalisable idea has nothing to do with charts. Have the model emit a small validatable intermediate representation and let deterministic code expand it. You can check ten lines of JSON before it renders; you cannot check a hundred lines of generated D3.
🔗 Resources & links
- Microsoft Built a New Charting Language for AI AgentsSource video — Better Stack, 5:45
- microsoft/flint-chartThe repository — MIT, TypeScript
- Flint documentationMicrosoft Research project page
- Flint: A Semantics-Driven Data Visualization Intermediate LanguageThe paper the video says is still coming — published 22 July 2026
- microsoft/data-formulatorThe internal customer — depends on flint-chart
- flint-chart on npm11,309 downloads last week; latest 0.4.1
- Open issuesIncluding #48 and #62 on accessibility