Building Toward Governable AI, One Drawer at a Time
Local governments do not suffer from a shortage of AI tools. Vendors arrive weekly, armed with slick demos, confident timelines, and the reassuring promise that this time, truly, the transformation will be digital.
What we lack is something far less glamorous and far more consequential: governable knowledge systems that AI can operate on without quietly inventing reality along the way. In Van Buren and St. Joseph Counties, Michigan, we are not shopping for a better chatbot. We are working toward an architectural stance, one that we are still very much in the process of building.
This is not a finished system. It is not a proven blueprint. It is, at best, a direction we believe local government must head if it intends to keep authority, memory, and accountability in public hands rather than renting them back from vendors at a premium.
AI in government turns out not to be a software problem. It behaves much more like a knowledge governance problem masquerading as a software problem. Until public institutions own a structured, authoritative knowledge layer, every AI tool they adopt will hallucinate, drift, or quietly rewrite reality with great confidence and very little remorse.
The Problem We Inherited: The Municipal Junk Drawer
As discussed earlier in this series, most institutional knowledge lives in what can only be described as a municipal junk drawer. PDFs of uncertain origin. Legacy databases that no one quite trusts but everyone still uses. Critical context stored in the collective memory of staff who are one retirement away from becoming folklore.
When modern AI is pointed at this environment, it misleads with confidence. It cannot naturally distinguish a draft ordinance from an adopted one, or a village regulation from a township requirement. To the model, everything looks like “text.” Authority is invisible.
AI did not create this problem. It simply revealed it, rather like turning on a bright light in a storage room that everyone has been carefully not opening.
So we began reframing the challenge. Before intelligence, before automation, before convenience, knowledge governance has to come first.
The Direction We Are Exploring: A Two-Plane System
What we are currently building, and testing, and occasionally arguing with, is a system based on a deliberate separation between two planes. We are working from the assumption that Authority and Intelligence must be separated by a hard structural line.
This is not a radical idea. Every government already operates this way in practice. Clerks maintain the record. Boards establish authority. Staff interpret and apply. The quiet mistake of modern AI adoption has been collapsing these roles into a single opaque system and hoping for the best.
We are trying to make the separation explicit in software.
Plane 1: Authority and Operations (The System of Record)
This plane answers a very narrow but very important question: “What is true right now, according to the law?” This is the institutional memory the county must own.
In our current work, this plane rests on open foundations: PostgreSQL for data, PostGIS for spatial authority, and Directus as the gatekeeper for human-in-the-loop workflows. It is intentionally cautious. Nothing here updates itself. No AI writes to this plane without human approval, documentation, and the digital equivalent of a raised eyebrow.
This layer moves slowly on purpose. Government, after all, is not a startup, and public trust does not benefit from rapid pivots.
Plane 2: Intelligence and Retrieval (The Reasoning Layer)
This plane answers a different question: “What information is relevant right now?” This is where AI is allowed to be helpful.
We are experimenting with vector search using pgvector inside our own environment so that reasoning remains tethered to actual county records. The model can summarize, infer, and explain. It can be useful. What it cannot do is redefine reality.
The boundary matters. The record informs the AI. The AI never edits the record. That wall, more than any model choice, is the architecture of public trust.
A Small Test, Not a Grand Victory: The Resolution Experiment
To move from theory toward something testable, we recently applied this approach to a year’s worth of Board of Commissioner’s resolutions. Ordinarily, these live inside narrative PDF minutes, unstructured and noisy.
Before, a simple question like, “Was the E-911 VHF radio upgrade approved in 2021?” forced the AI to scan hundreds (or thousands) of pages of discussion. It produced an answer quickly. It was also wrong.
After, we used AI in a very narrow, supervised role to extract those resolutions into a structured relational database. Think of it less as artificial intelligence and more as an industrious intern who never gets bored but still needs supervision.
Now the same question became a direct query against a ledger.
The answer was no longer generated. It was retrieved and cited. Accuracy skyrocketed not because the model became smarter, but because the knowledge became governable. This is the quiet truth we keep bumping into: data engineering does most of the real work that AI gets credit for.
The Hardest Part We Are Still Wrestling With: Spatial Reality
The most stubborn challenge in local government AI is the GIS silo. AI is famously bad at inventing correct spatial logic, and local governments are famously reliant on spatial truth.
To bridge this gap, we are experimenting with the Model Context Protocol as a kind of service window between the AI and the county’s spatial reality.
The server tells the AI exactly what authoritative tables exist: parcels, zoning, utilities. The AI is given pre-validated spatial tools instead of guessing. When a user asks, “Is this parcel in a flood zone?” the AI does not improvise. It rings the bell.
Our server runs the query on authoritative data and returns a factual answer.
The AI never “knows” the county. It “asks” the county. This turns out to be an important distinction. Whether the model runs in a vendor cloud today or on local hardware tomorrow, the service window remains the same.
The Tools We Are Using, For Now
Because county budgets are real and enthusiasm does not count as a funding source, this work relies on open foundations. The tools are modular and interchangeable. The architecture matters more than the brand names, but here is where we are starting:
- GDAL, the unglamorous Swiss Army knife that cleans decades of spatial data so modern systems can read it without complaint.
- PostGIS, which serves as both authoritative spatial record and reasoning engine.
- Martin and MapLibre, which let us visualize data without proprietary toll booths or per-user licensing surprises.
None of these tools or (those mentioned earlier) are magic. They are simply predictable, which in government counts as a feature.
Where This Is Headed
We are early in this work. It is messy. Some days feel more like archaeology than engineering. Our internal tools are just beginning to use these service windows to answer staff questions reliably.
We are not finished. We are not declaring victory. But we are no longer guessing blindly. We are building toward a system that reflects how our local governments actually work, rather than how vendor software brochures assume they do.
Author’s Note
A brief note for our more technical readers, who may already be composing polite but pointed responses in their heads.
Yes, many technical details are missing. Entire categories of implementation, tradeoffs, and edge cases have been intentionally glossed over. This is not an oversight. It is an act of mercy.
This series is written for mixed audiences who share the same institutions but not the same tolerance for schema diagrams. The goal here is to describe the shape of the work and the direction of travel, not to document every table, service, or failure mode. Those details matter deeply. They are simply not the conversation we are having in this space.
No, we do not have all the answers. Yes, some of this is still experimental. We are building while learning, rather than waiting for a perfect framework to arrive fully formed from a vendor slide deck. Watching is comfortable. Building is clarifying.
Which brings us to the next article in this series: what happens if local governments choose not to build and own this knowledge layer at all?
Because deciding not to decide is still a decision, and the consequences tend to arrive quietly, with a maintenance contract attached.