What Can I Build Here? Zoning Intelligence Without the Guessing
Part of the AI-runtime thread. Earlier we argued that compute should be a capability the runtime selects and that correctness is a property you measure. Geospatial is the same argument in a domain where a wrong answer has a permit number on it.
Ask a general-purpose AI "can I build a self-storage facility on this parcel?" and you'll get a fluent, confident answer. Sometimes it's right. Sometimes it invents a zoning code, misreads which district the parcel sits in, or, worst of all, tells you a use is permitted when the ordinance says it needs a special exception. In zoning, a confident wrong "yes" is a due-diligence error with money attached.
The failure is asking a language model to do two things it is structurally bad at: compute a spatial relation ("is this point inside that district?") and assert a legal conclusion it can't ground. So we added geospatial as a Runtime capability in place of a zoning chatbot, governed by one rule.
Never ask an LLM a spatial relation a geometry engine can calculate, and never fabricate a permit. Where the ordinance is unclear, abstain.
Geometry is evidence
The first move is to stop treating a parcel as prose. A parcel boundary is a typed spatial evidence object (a GeoRef) carrying the geometry's content-addressed identity, its CRS, its jurisdiction, and when it was observed. The same boundary in the same coordinate system is one identity across every data provider, so "which parcel" is never provider-specific and never drifts.
Spatial questions are then answered by a small, deterministic geometry engine alone: point-in-polygon (is the proposed building inside the lot?), polygon intersection (does the parcel touch the flood overlay?), area, centroid, distance. It refuses a silent coordinate-system mismatch (a binary op across two CRSs raises and does not quietly return nonsense) because a wrong-by-a-datum answer is worse than no answer. The point is that geometry is exact, and exact is precisely what an LLM can't promise.
Deterministic-first, and honest about the wall
Land-use is where most systems quietly guess. Ours is deterministic-first and fail-safe:
- the official base zoning is authoritative, so a base-incompatible use is PROHIBITED with certainty;
- a use permitted by right on that base is PERMITTED;
- and wherever the answer depends on the ordinance's permitted-use table or an overlay we have not parsed (the honest "deep wall" of zoning), the runtime returns UNKNOWN and cites the source for a human to verify.
That abstention is the whole product. Anyone can build a system with high recall by guessing on the hard cases; the number that matters is false-permitted = 0: never concluding a confident "permitted" the base zoning doesn't support. On a cross-country sample of real parcels, across every target use, that rate is exactly zero: the system prohibits what's incompatible, permits what's by-right, and abstains, visibly, on everything that needs the ordinance.
Real data, from the source
None of this means anything on synthetic parcels. The evidence is harvested directly from official, keyless sources (US Census / FCC jurisdiction resolution, then each jurisdiction's own published ArcGIS zoning layer) by a dedicated zoning-sources-mcp server. No commercial data-provider API, no keys. The sweep so far:
149,624 zoning districts from 4,562 official ArcGIS services, 16,711 distinct zoning codes: the ArcGIS Hub zoning index walked to end-of-index.
Each record carries the canonical geometry_hash identity, the real zoning code, and, where published, a link to the district's ordinance page.
The runtime learns the cheapest sufficient evidence
Here's where it becomes a runtime decision. Multiple sources can speak to a parcel (official GIS, commercial parcel data, the ordinance), each with a cost. Fetching all of them, always, is expensive; fetching one is cheap but often insufficient. The zoning tenant treats "which evidence bundle do I need for this situation?" as a learned decision, scored on whether the cheapest bundle still reaches the correct disposition, with false-permitted as a hard blocking SLO.
Measured offline against baselines:
| Strategy | Reward | Avg cost | False-permits |
|---|---|---|---|
| single provider (cheapest) | +0.080 | 1.0u | 1 (violates the SLO) |
| fixed "always thorough" | +0.850 | 8.0u | 0 |
| Context Runtime (learned bundle) | +0.894 | 5.67u | 0 |
The learned policy is 1.4× cheaper than always-fetching-everything at equal correctness, and, unlike the cheap single-provider baseline, it never trips the false-permitted SLO. Reward here is correct disposition minus a cost penalty; the win is spending evidence only where the decision actually needs it.
See it run
It's live: geo.redevops.io evaluates every target use against every harvested parcel in one call (watch the false-permitted counter stay at zero and the honest UNKNOWNs pile up where the ordinance is needed), runs the geometry engine on a real point-in-polygon computation, and shows the learned-evidence benchmark. Nothing on that page is mocked: the dispositions come from the same deterministic resolver, the spatial answers from the same engine.
Zoning is a good stress test for the whole thesis, because it punishes the two things LLM-first systems do worst (computing relations and asserting groundless conclusions) and rewards the two things a runtime does best: use the right tool for the sub-problem, and abstain honestly when the evidence isn't there. The same shape generalizes far past zoning: anywhere a precise engine can compute what a model would otherwise guess, and anywhere a confident wrong answer costs more than an honest "I don't know."