Antigravity Now Builds Interactive Generative UI Artifacts Inside Your IDE

On August 26, 2026, the Antigravity team published a short post titled "Visualizing with the help of Antigravity." Early the next morning, the @antigravity account made it a launch: "Introducing Interactive Generative UI Artifacts!" — a tweet that cleared 91,600 views within hours. The pitch is one sentence long and unusually honest for a launch: "Sometimes markdown, images, and Mermaid diagrams aren't enough for the agent to fully express an idea."

That is the whole story, and it is bigger than one IDE feature. Every serious agent harness has independently arrived at the same conclusion in the last twelve months — that a text stream is a lossy channel for an agent that has genuinely understood something. Anthropic shipped Artifacts in Claude and then publishable HTML pages in Claude Code. Google shipped generative UI in Gemini and Search's AI Mode. explainx.ai built Melo's real-time visual layer for teaching. Antigravity is the version that lands inside the agent-manager loop — with a slash command, an artifacts panel, and a standalone HTML export.

TL;DR

What actually shipped

Google's framing in the blog post starts from the terminal: "As developers, we often work in terminal user interfaces (TUIs) and text-first environments. While text interfaces are great for everyday development, they do not always convey complex architectural relationships or content in ways that are easily digestible."

The capability list is three items:

1. Interactive visual artifacts — "from interactive HTML/CSS/JS components to live charts and diagrams," inspectable directly in the artifact preview panel rather than imagined from a description.
2. Zero-dependency visualizations — rendered locally "without requiring the download of additional packages or dependencies," able to run offline.
3. Complex data visualization — the tabular-data-is-hard-to-read argument, solved by having the agent render the data rather than print it.

The launch tweet adds the range: "Explore everything from dynamic data visualizations to 3D explanatory simulations, rendered seamlessly inline and in your artifacts panel." The demo videos in the thread show interactive dependency graphs, a quadtree explorer, and a solar-system simulation with togglable display layers.

The version detail matters and the announcement post skips it. Antigravity's changelog dates 2.11.0 to August 26, 2026, headlined "Generative UI and UI improvements," and the entry that tells you the most is this one: "Added support for KaTeX math formatting, Chart.js, and Plotly charts in generative UI." The same release also added @path/to/file inlining, YAML frontmatter rendering as metadata cards, side-by-side terminal splits, and the Darcula theme. Generative UI is the headline; it shipped in a normal weekly release train, two days after Remote Control's 2.9.1 and 2.10.0's embedded terminals.

Is it free? Which tier do I need?

The honest answer: Google did not say, and that is itself informative.

When Antigravity shipped Remote Control on August 21, the announcement was explicit that rollout began with Google AI Ultra subscribers. The Generative UI announcement carries no equivalent sentence, and the 2.11.0 changelog lists it as a plain improvement alongside a theme preset and a terminal split. Features that ship in an ordinary release entry with no gating language are normally app-level capabilities, available to whoever is running that build.

What Google has published, in its own plans post from May 19, 2026, is the tier structure: Google AI Pro at $20/month, Google AI Ultra at $100/month, and a top Ultra tier at $200/month (reduced from the earlier $250). Enterprise access routes through Google Cloud's Gemini Enterprise Agent Platform.

The practical constraint is not the feature flag, it is quota. Generative UI artifacts are model output — a 3D simulation is a few hundred lines of generated JavaScript, billed like any other generation. If you are on a metered plan, "can I use it" and "can I use it forty times a day" are different questions. Third-party trackers have logged repeated tightening of Antigravity's free quotas since the November 2025 launch, so check the in-app usage meter rather than trusting a number you read in a roundup, this one included.

How is this different from Claude Artifacts? And from Mermaid?

This is the question the launch tweet invites and does not answer. Three things are genuinely being conflated right now.

The distinction worth internalizing is the last row. Claude Code's Artifacts are oriented around producing something you hand to someone else — a page with a URL. Antigravity's are oriented around understanding the repository open in front of you: Google's canonical example prompt is "Help me visualize the dependencies in my project," and the stated benefit is that it "reduces the amount of context switching between screens when we can get a visual representation of data directly in our agent manager." Same primitive, opposite direction of travel.

Antigravity has had an artifacts system since well before this — its docs define an Artifact as "a structured deliverable created by the agent to accomplish its task and communicate its progress and thinking to the human user," covering implementation plans, code diffs, architecture diagrams, images, and browser recordings. What changed on August 26 is that the artifact can now be a running program rather than a rendered document. If you want the surrounding machinery, explainx.ai's Antigravity CLI reference covers the sandbox, plugins, and subagent panel that this drops into.

And no, it does not retire Mermaid. Google's own sentence is "aren't enough" — additive, not a replacement. A dependency tree with forty nodes is still better as a Mermaid graph than as a bespoke canvas widget, because Mermaid is deterministic and diffs cleanly in Git. Reach for generative UI when the thing you need is a behavior, not a picture.

Does "zero-dependency" really mean no CDN?

Read Google's sentence precisely: "Visualizations are rendered on your machine without requiring the download of additional packages or dependencies and can run offline so you can export the artifact and load it later."

That is a claim about package installs — no npm install, no pip install, nothing added to your project's lockfile to view a chart. It is a real and useful property; the alternative is an agent that helpfully adds d3 to your package.json so it can draw you one graph.

It is not, by itself, a guarantee that every generated artifact is network-free. The strongest evidence that Google is doing the right thing here is the 2.11.0 changelog line adding Chart.js, Plotly, and KaTeX support in generative UI. Naming three specific libraries as first-class capabilities of the renderer strongly implies the runtimes are supplied by Antigravity's preview environment rather than fetched per artifact — which is exactly what makes "runs offline" true.

The practical test takes ten seconds, and you should run it before you trust an export in an air-gapped or compliance-sensitive setting:

# Export the artifact, then check what it actually reaches for
grep -oE 'src="https?://[^"]+"|href="https?://[^"]+"' exported-artifact.html

An empty result means it is genuinely self-contained. A cdn.jsdelivr.net or unpkg.com hit means the artifact renders fine on your machine today because the library is cached, and breaks on a plane. Google has not published a guarantee either way, so verify per artifact rather than per feature.

Can I export it and self-host?

Yes, and this is the underrated part of the release. Step 3 of Google's getting-started instructions: "Review the generated artifact preview, click to inspect elements, and you can even export the artifact to a standalone HTML file using the sidepanel and artifact viewer."

A single HTML file is a portable, boring, extremely useful output format. It can be committed next to the code it documents, attached to a pull request as a reviewable visualization of what a refactor did to your module graph, dropped into a wiki, or served from any static host. It survives Antigravity being uninstalled — which is more than can be said for most in-IDE visualizations.

This is the same bet Anthropic engineer Thariq Shihipar made in the argument explainx.ai covered as the unreasonable effectiveness of HTML for coding agents: HTML is the one output format that every agent already knows how to write, every human already knows how to open, and no runtime needs to be installed to view. Google shipping a one-click export to exactly that format is a stronger signal about where agent output is heading than the 3D simulations in the demo video.

The security question Google has not answered yet

Here is the part a launch tweet will never cover. An agent generating arbitrary JavaScript, then executing it in a panel inside your IDE, is a new execution surface — and Antigravity's published documentation does not currently describe an isolation boundary for it.

What is documented is adjacent but different. Antigravity's sandbox docs cover kernel-level isolation for terminal commands the agent executes, with restricted filesystem and network access. Its Strict Mode locks terminal execution to Request Review and requires review for browser JavaScript execution. Neither of those is a statement about how the artifact preview renders model-authored HTML. There is no antigravity.google/docs/generative-ui/ page at the time of writing — it returns a 404 — and the Artifacts overview page does not mention sandboxing.

Why this matters concretely: the flagship use case is "help me visualize the dependencies in my project." To do that, the agent reads your repository — including README files, dependency metadata, comments, and vendored code you did not write. That is the exact input surface for indirect prompt injection, where attacker-controlled text in content the agent reads becomes instructions the agent follows. An injection that previously had to talk an agent into running a shell command now has a second path: talk it into rendering something.

Compare this against how explainx.ai handles the same problem in Melo's /interact mode, which also runs model-authored code. There, the code executes in a sandboxed iframe with an opaque origin — no cookies, no storage, no same-origin access to the surrounding app — precisely because "the model wrote this code" and "this code is safe to run in a privileged context" are unrelated statements. Melo's other path, the typed component spec, avoids the problem differently: the model picks and populates a pre-built component instead of writing executable code at all.

None of that means Antigravity is unsafe. It means the isolation model is currently undocumented, and undocumented is not the same as absent. Until Google publishes it, the reasonable posture is: fine on your own repositories, more careful on a codebase you just cloned from a stranger, and worth asking about before it goes anywhere near a machine with production credentials — the same caution that applies to Remote Control's exposure of live env vars.

The launch is real, and slightly unpolished

Two small tells that this went out fast.

The blog post has a typo in the zero-dependency section — the sentence about exporting an artifact and loading it later renders "load it" as a mangled string in the published copy. It is trivial, and it is also the kind of thing that survives when a post ships the night before the tweet.

More substantively, the announcement never names the version it shipped in, never states a plan tier, and points to no documentation page for the feature. The /generative_ui slash command is introduced in a parenthetical inside step 2 of a getting-started list — for a command that is the primary entry point to the whole capability. Antigravity's slash command surface is documented elsewhere; this one is not yet part of it.

That is a normal shape for a fast-moving harness, and it is also why explainx.ai's agent harness landscape is worth re-reading periodically rather than once: the feature sets are converging faster than the documentation is.

How to actually try it

1. Update to Antigravity 2.11.0 or later (released August 26, 2026).
2. Open a project you know well — the output is only as good as the codebase context.
3. Run /generative_ui, or just ask in plain language.
4. Inspect in the artifact preview panel; click elements to drill in.
5. Export to standalone HTML from the sidepanel when you want to keep it.

Prompts that play to the feature's actual strengths, rather than producing a chart you could have made in a spreadsheet:

• /generative_ui — then: "Map the import graph of src/, group by directory, and let me click a node to see what imports it."
• "Visualize the dependencies in my project and highlight anything with more than five inbound edges."
• "Build an interactive timeline of this file's git history showing which functions changed in each commit."
• "Turn the last test run's timing output into a sortable chart so I can see the slowest suites."

The last one is the one that pays for itself. Test timing data is the canonical example of tabular output nobody reads — Google's "tabular data can be hard to digest" argument, applied to something you already generate every day.

For a different flavour of what Antigravity's visual output can do when it is pointed at something other than code, see explainx.ai's writeup of the Omni video-in-Google-Sheets stunt, and the Debuzz / Claudette skill thread for how the same community is porting Claude Code skills onto Antigravity.

Why this matters beyond one release

Four harnesses, four teams, four starting points, one conclusion: the response object is no longer text.

• Claude made artifacts a consumer primitive years ago, and Claude Code turned them into publishable pages.
• Gemini generates a bespoke interface per prompt in the app and in Search's AI Mode.
• explainx.ai built Melo's component library and then open-ended sandboxed simulations for teaching.
• Antigravity put it in the agent manager, next to the diff and the plan.

The differences that remain are the interesting ones, and they are all the same tradeoff seen from different sides: generate arbitrary code (maximum expressiveness, slower, occasionally wrong, harder to sandbox) versus populate a validated component (fast, reliable, bounded). Google has now picked the first option twice — once for consumers in Gemini, once for developers in Antigravity — while explainx.ai picked the second for teaching and the first, sandboxed, for open-ended requests.

If you are building anything with an agent that has to explain itself, that fork is the design decision, and it is worth making deliberately rather than by default. explainx.ai's agent harness guide walks the surrounding architecture for anyone deciding where their own product should sit on it.

Related reading

• Google Antigravity Remote Control: browser-based agent sessions explained
• Google's generative UI: Gemini builds a custom app for every prompt
• How explainx.ai's Melo generates real-time interactive lessons
• Melo /interact: sandboxed, model-authored live simulations
• Claude Code Artifacts: shareable AI sessions vs Lovable, Codex Sites, and v0
• Antigravity CLI: sandbox, plugins, and slash commands reference
• What is indirect prompt injection? How web content hijacks AI agents
• Top 10 open and closed-source agent harnesses (2026)
• What is an agent harness? Complete guide

Official sources: Visualizing with the help of Antigravity · Antigravity changelog (2.11.0) · Antigravity Artifacts documentation

FAQ

What are Interactive Generative UI Artifacts?

Agent-authored interactive HTML/CSS/JS — charts, dependency graphs, 3D explanatory simulations — rendered inline in Antigravity's conversation and in its artifacts panel, announced August 26-27, 2026 and shipped in version 2.11.0.

What is the /generative_ui command?

A slash command in Antigravity that asks the agent to create a new visualization directly, rather than describing what you want in prose. It is introduced in step 2 of Google's getting-started instructions and does not yet have a dedicated documentation page.

Do I need Google AI Ultra for it?

No tier requirement was stated in either the announcement or the changelog — unlike Remote Control, which Google explicitly rolled out to Ultra subscribers first. Quota, not entitlement, is the more likely practical limit.

Can I export the artifact?

Yes, to a standalone HTML file via the sidepanel and artifact viewer. That file can be committed, attached to a PR, or served from any static host.

Is it really zero-dependency?

Google's claim is that visualizations render locally without installing packages and can run offline. Antigravity 2.11.0 supplies Chart.js, Plotly, and KaTeX to generative UI widgets, which is what makes offline rendering plausible. Grep an exported file for external src and href attributes if you need certainty.

Does it replace Mermaid diagrams?

No. Google's own framing is that markdown, images, and Mermaid "aren't enough" for some ideas — additive, not a replacement. Mermaid remains better for anything that should diff cleanly in Git.

Is agent-generated JavaScript sandboxed?

Not documented. Antigravity's published sandboxing covers terminal command execution, and Strict Mode gates browser JavaScript execution behind review, but there is no documentation of an isolation boundary for the artifact renderer itself.

Feature details, version numbers, and pricing reflect Google's Antigravity announcement post of August 26, 2026, the launch tweet of August 27, 2026, the 2.11.0 changelog entry, and Google's own Antigravity plans post of May 19, 2026. Quotas, tier gating, and documentation coverage for this feature are all changing quickly — verify against antigravity.google/changelog and the in-app usage meter before relying on any specific detail.