GroundTruth

The problem

After a flood or an earthquake, the first 72 hours are triage. Someone sits in front of aerial imagery deciding which blocks get the trucks. The imagery tells you what a roof looks like. It does not tell you how many people live under it, whether the road in is passable, or whether the building you just clicked is a clinic.

That context exists — building footprints, population rasters, road networks, critical infrastructure — but it lives in files nobody opens during a crisis.

What it does

GroundTruth is a damage assessment console. You pan aerial imagery and select buildings. An agent sitting inside the page answers questions about what you are looking at right now: population exposure in this viewport, road access to this polygon, which critical facilities fall inside the affected area.

You ask "what's the flood exposure here?" and here is unambiguous — it is the current viewport, the current selection, the imagery date currently loaded.

Why WebMCP and not a server MCP

This is the whole argument. A remote MCP server can query the same datasets, but it has no idea what "here" means. It cannot see your viewport, your selection, or your map state. It would need you to describe your screen in words before it could help.

WebMCP puts the tools in the page, so they close over live application state. The agent does not receive a bounding box you typed — it reads the one you are looking at. The tools are the app's own functions, which means the agent and the human operate the same console and see the same thing.

How we built it

A Next.js map console over MapLibre, with a WebMCP tool surface exposed from the client. Each tool is scoped to live UI state rather than taking free-floating parameters. A data pipeline pre-processes building footprints, population and infrastructure layers into tiles the browser can query without a round trip.

What we learned

Designing tools that close over UI state is a different discipline from designing REST endpoints. The temptation is to expose one powerful tool with many parameters. That performs worse than several narrow tools that each read the current state, because the model stops having to reconstruct context it cannot see.

What's honest about it

The datasets are pre-staged for the demo region rather than fetched live, and the damage signal comes from imagery the operator reads, not from an automated classifier. Both are deliberate: the point of the entry is the agent-to-page interface, not a damage model. Live data ingestion is the obvious next step.

Built With

• geojson
• maplibre
• next.js
• openai
• react
• typescript
• vercel
• webmcp