Microsoft Research Releases Flint-interactive: AI Agents Draw Clickable Charts
AI agents can draw charts in chat, but they almost always produce static ones: you can't zoom in or highlight a group of points. Microsoft Research has released Flint-interactive, a language in which the agent describes an event ("countries selected") and a reaction ("highlight"), and the compiler handles the clicks and rendering itself. Interactive charts come out more reliable and cheaper in tokens than when code is generated from scratch. Agent developers find it easier to take ready-made presets than to debug hand-written JS.
AI-processed from Microsoft Research; edited by Hamidun News
Ask an AI agent to analyze data, and it will most likely return a neat but static chart. To work through the details, a user needs something else: zoom into a region, compare two diagrams, highlight a group of countries, and see where they are mentioned in the report text. Microsoft Research researchers have proposed Flint-interactive for this purpose. It builds on their Flint library and is meant to make interactive charts a normal output of agent work.
Why agents struggle with interactive charts
The authors describe two problems. The first is cost. An agent rarely produces a successful interactive visualization on the first try. It reasons, writes code, catches errors, fixes them, and runs again. Each cycle costs tokens and time. The second is reliability. In an interactive chart, it is easy to get a broken layout or faulty interaction, and fixing one bug often creates another.
Built-in features of popular visualization libraries are not enough either. They cover typical cases like tooltips, but unusual mechanics, such as those in data journalists' work, have to be written by hand. According to the authors, the root cause is the lack of a convenient language for briefly describing chart behavior.
How it works, by example
The idea is to split two layers. The Flint compiler handles the visual logic. It turns raw actions such as a click, a drag, or a key press into "semantic events", meaning a clear record: the user selected these countries or this point. It also determines which element the cursor hit and redraws the canvas.
The user or the agent defines the interaction logic. To do this, you link an event to an update operation. The operations are simple: highlight data, label a point, shift or zoom the viewport. For example, on two linked charts you can draw a frame around several countries, and the same groups will light up in the adjacent view. A ready-made linked-brush preset exists for this case.
The same principle works beyond a single chart. An event can be sent to an external element: filter a table, update another diagram, or change the application state. The reverse direction works too. In one example, clicking a table row highlights points on the chart, and vice versa. The Flint Canvas is structured as a finite-state machine: it tracks user actions and stores the rendering state.
For non-standard scenarios, Flint offers a programmatic API. The developer defines a trigger and a handler function that turns an event into a chain of updates. The handler might, for instance, highlight the clicked country and label it by name, combining style and annotation operations without touching the details of a specific renderer. As a more complex example, the authors show DimpVis: the user drags a point along a time trajectory, and the temperature and precipitation for all cities change.
How to try it and what to keep in mind
There are three ways to use it. The first is for chat users: Flint connects through Flint-MCP and MCP Apps, following the instructions in the guide. After that, the agent generates an interaction specification (interaction_spec) alongside the chart specification and draws the result right in the conversation. Elements the user selects can be passed into follow-up questions, so a click can refine the query.
The second is for those building applications: dashboards, data stories, and linked views are assembled on the Flint Interactive Canvas. The application receives semantic events through handlers and sends update operations to the canvas, for example from its own widgets. The third is for interaction designers: you can invent new behavior and propose it as a preset on GitHub.
For developers, the takeaway is practical. If you are building an agent that shows data to clients, don't force the model to write interactive code from scratch every time. It is better for the model to describe intent at a high level, while a proven layer handles rendering and dependencies. The authors also suggest handing the coding agent an interaction-author skill so it can add presets to your application.
There are limitations too. The announcement contains no benchmarks: there are no figures on token savings, the share of successful generations, or speed. Claims about reliability and low cost currently rest on demonstrations and the architecture description. Expressiveness is limited by the vocabulary of Flint's operations and presets, and unusual scenarios will still require the programmatic API. Whether such a language can meaningfully reduce the number of agent iterations will become clear from real-world use.
- Nov 21, 2026Microsoft outage: nearly 83,000 Outlook complaints on Downdetector, Teams and Copilot down too
- Nov 21, 2026MLPerf Training Adds Nvidia Rubin and TPU Ironwood in First Appearance: 153 Systems
- Nov 21, 2026Microsoft Turns Copilot Into an "Operating System for Work": Word and Excel Become Agent Plugins
- Nov 21, 2026Google to split Gemini chat history from model training, so you can opt out without losing your history
Key Questions Answered
Why agents struggle with interactive charts?
The authors describe two problems. The first is cost. An agent rarely produces a successful interactive visualization on the first try. It reasons, writes code, catches errors, fixes them, and runs again. Each cycle costs tokens and time. The second is reliability. In an interactive chart, it is easy to get a broken layout or faulty interaction, and fixing one bug often creates another. Built-in features of popular visualization libraries are not enough either.
How it works, by example?
The idea is to split two layers. The Flint compiler handles the visual logic. It turns raw actions such as a click, a drag, or a key press into "semantic events", meaning a clear record: the user selected these countries or this point. It also determines which element the cursor hit and redraws the canvas. The user or the agent defines the interaction logic. To do this, you link an event to an update operation. The operations are simple: highlight data, label a point, shift or zoom the viewport.
How to try it and what to keep in mind?
There are three ways to use it. The first is for chat users: Flint connects through Flint-MCP and MCP Apps, following the instructions in the guide. After that, the agent generates an interaction specification (interaction_spec) alongside the chart specification and draws the result right in the conversation. Elements the user selects can be passed into follow-up questions, so a click can refine the query.
Build & Ship Production AI Agents Without Boilerplate Code
Start your free 72-hour trial at Hamidun Academy (academy.hamidun.com) — interactive lessons on Claude Code & Cursor, live Tech Radar, and production agent templates.
The AI world, distilled — once a week
Seven stories that actually mattered, hand-picked. No noise, no reposts, no press releases.
Done! Check your inbox for a confirmation.