AI agents are starting to operate our software, not just chat about it — and geospatial visualization is an obvious target. Imagine asking a map, in plain language, to "show wildfire smoke over California last September," and getting back a real, ready-to-open view. The hard part isn't the language; it's how the agent and the map application actually talk to each other.

Today the default answer is brute force: point a vision-language model at the screen, let it read screenshots and the page's Document Object Model (DOM), and have it click, type, and drag like a human. This pattern works on any web app but on geospatial viewers it breaks down in two specific ways.

First, accuracy. Web maps like Mapbox Leaflet, Cesium, and OpenLayers render through canvas and WebGL. The actual map, which layers are on, at what date, over which region, lives in GPU surfaces that the DOM does not describe and that screenshots capture only as pixels. So when you ask the agent a basic question like "what region am I looking at right now?", it cannot reliably recover the answer; it guesses, and frequently guesses wrong.

Second, cost. Every action ships a fresh page snapshot back into the model's context. Token usage scales with how complex the UI is and how many turns the task takes, not with how hard the task actually is. Earth-science work is deeply iterative (change the date, pan, swap a layer, add a chart), so these costs compound turn after turn.

This talk introduces the GeoUI Intent Protocol: an open, application-agnostic way for an agent to drive a geospatial visualization through a typed, declarative intent instead of screenshots and clicks. The agent reasons about the map in structured terms (viewport, time, and layers) and the application is responsible for rendering that intent and for reporting its current state back in the same shape.

The design will feel familiar to anyone who knows STAC: a small, stable core plus URI-identified extensions you declare only when you need them (layer comparison, time-series charts, raster styling). The contract between agent and application is done via operations: render_intent, which applies an intent to the app, and get_state, which reads the current state back as the same structured object. Everything application-specific is hidden behind a thin per-app adapter. Crucially, the visualization application itself is never modified: you wrap it, you don't fork it. For our reference, NASA Worldview is wrapped simply by mapping GeoIntent onto Worldview's existing permalink format and back.

We bring this to life with the MIO Worldview Agent, a human-in-the-loop agent that turns a scientist's natural-language question into a catalog-verified Worldview visualization. The agent is developed in collaboration with applied Earth science experts from NASA’s Multisource Integrated Observatory (MIO), ensuring alignment with real-world Earth observation workflows. The MIO Worldview Agent serves both as our reference adapter and the vehicle for evaluating the protocol. In our benchmark we hold the agent and its data-discovery tools fixed and vary only the interaction mechanism: GeoUI intent versus the screenshot-and-click baseline, so the comparison isolates how the agent talks to the map. Across iterative Worldview workflows, we observe that the GeoUI-based interaction is roughly an order of magnitude (~15×) cheaper per task, and it answers map-state questions correctly that the baseline simply cannot recover from pixels.

The protocol is the bounded contract; the application is unmodified; so the same agent can, in principle, drive Cesium, QGIS, Leaflet, Mapbox, OpenLayers, etc and its derivative applications once someone writes a small adapter for it. One adapter per map project, and every GeoUI-speaking agent inherits it. Because GeoUI exchanges structured, validated state rather than pixels or DOM representations, it enables improved auditability through interpretable, replayable interaction logs and enforces bounded capability by constraining agents to application-declared operations and extensions.

We position this work as a step toward standardized, reproducible interfaces for geospatial visualization systems, enabling robust interaction between semi-autonomous scientific agents and Earth observation platforms.

In this talk you'll see: why screenshot-driven agents fail on geo specifically; the GeoUI core and extension model; a live look at the Worldview adapter and the two-tool contract; the benchmark and what the ~15× and accuracy numbers really measure; and a short, practical recipe for writing an adapter for your visualization application. We'll be candid about scope, too — the benchmark is an early, hand-curated pilot, and portability beyond Worldview is so far architectural rather than empirically proven across many apps.

We will release the protocol specification and the reference adapter so the community can fork it.