Free Intensive Nov 21–22Free 2-day hands-on Vibecoding Intensive on Nov 21–22 at 16:00 MSK (Sat–Sun) · Live Cohort 3 starts Nov 23Join Free →Cohort 3 (Nov 23)
ReleaseAPI / Product · ActionableMicrosoft Research→ original

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
Microsoft Research Releases Flint-interactive: AI Agents Draw Clickable Charts
Source: Microsoft Research. Collage: Hamidun News.
Listen to article
Article Fact Sheet & Key Figures
ParameterDetails
Primary sourceMicrosoft Research ↗
Editor-in-Chief
Key metric #1Connects to chat through Flint-MCP and MCP Apps
Key metric #2Charts link to tables, text, and application widgets
Key metric #3For non-standard scenarios, there is a programmatic API and event handlers

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.

Story

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.

ZK
Zhemal Khamidun — CPO at Alpina Digital, product manager of AlpinaGPT. Building AI products since 2019. Hamidun News is a pet project that grew into a production aggregator with 6,000+ readers.
✦ Hands-On AI Engineering · Hamidun Academy

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.

Start 72h Free Trial →Vibe-Coding Intensive
What do you think?
Loading comments…