The Policing Analysts

Working with national crime data normally means learning it first: which of 1,628 documented columns holds what, which codes mean which categories, which tables can honestly be joined. That work stands between a question and its answer, and it is the reason most people never ask.

This removes that step. You ask in ordinary language, and four specialist analysts — each one already versed in the data — do the rest. What makes their answers usable is not that they are fast, but that they are bounded and candid: they stay inside the data they know, they say what a figure excludes, and they decline rather than improvise when the data cannot support an answer.

Neither dataset arrived in usable shape. Both were rebuilt as AI-Native Data Products — an open design standard under which a dataset is required to carry its own documentation as data: a catalogue of every entity and column, a business glossary, a cookbook of worked queries, the design decisions taken while building it, its lineage, its quality readings, and its own verdict on whether it is fit to be trusted.

It is the reason an analyst can be dropped in front of 1,628 columns and know what they mean without a human explaining them: the dataset explains itself.

This work is already done. Both products were engineered and deployed onto a Teradata system ahead of time, and that is where they live now. You are not being asked to model anything, load anything or document anything — you are being handed the finished result. Everything from here is about reaching it.

It is also the foundation everything else on this page stands on. The analysts are not clever in spite of the data; they are useful because the products were built to explain themselves. Take that away and there is no map, no boundary and no verdict to rely on — just a model guessing at columns. The standard is the enabling work, and the rest is what it makes possible.

An analyst that has to discover the data as it goes will sometimes discover the wrong thing and answer anyway. These analysts start from a map: every entity in both datasets, what each column means, how the tables join, and — visible below — the one link between the two products that was declared but never actually built.

It is not a diagram drawn for this page. It is the map itself, and you can open it in the product and watch an analyst read it.

Two policing datasets are what this example happens to be built on. The method underneath is indifferent to subject matter — the same steps apply to any source you hold, and Part 02 shows a third, entirely unrelated product running on the same deployment.

Uderia is a platform for putting AI agents to work on enterprise data without giving up control of what they may do. Agents there are not general chatbots pointed at a database: each one is bound to a defined slice of data, checked against that boundary on every question, and answerable for what it did.

The policing analysts are packaged for it as an agent pack — a ready-made team you install in one step, complete with their knowledge of the two datasets. Installing it takes a few minutes; you do not build or configure anything.

The platform is open source, licensed under the GNU Affero General Public License v3, with a permissive commercial tier for organisations that need to keep their own modifications private. You are reading about a hosted instance because it is the quickest way to try it — but nothing here is tied to it.

The on-premise case goes further than hosting location. Every layer has a local option — the language model, the embeddings, the vector and graph stores, the platform's own state. Configured that way it makes no external network calls at all: the data never leaves your network, and neither does the question asked about it. For a policing, defence or health deployment that is frequently the difference between a system that can be approved and one that cannot.

Any platform offering to do this work will need an answer to three questions. They are worth asking early, because the answers are difficult to change later.

Openness here is not a licence badge on one component. It runs the length of the stack: the method the data products were designed to, the products themselves, the model of the domain, the protocols, the platform, and the model doing the thinking. There is no layer you can only rent, and none you can only look at through the one above it.

That matters most when something needs to change — a definition that is wrong for your jurisdiction, an agent that should refuse more, a model that must run inside your own walls. The party that deploys this owns every one of those decisions.

One exception, stated because you would find it anyway. The platform's own reasoning prompts — Uderia's method for planning and self-correction — are encrypted below the Enterprise tier, which lifts the licence to MIT and opens them. That is Uderia's intellectual property rather than yours, and it is the only closed layer in the stack. Everything that encodes your domain is open in every tier: the products, their catalogues and comments, the map, the analysts' instructions, their documentation and their worked strategies.

The distinction is the point. A page arguing that answers should disclose what they leave out would be a poor place to leave something out.

The alternative on offer in this market is usually the opposite arrangement: one vendor supplies the ontology, the platform and the copy of your data, and each layer is inspectable only through the layer above it. That is a faster start and a much harder exit. Nothing on this page requires you to accept that trade — and if you eventually want none of it, the products keep working, because they were always just your data, documenting itself.

Nothing in this approach is about crime data. The steps were: take a source, engineer it into a product that documents itself, build the map from the product's own catalogue, and give analysts that map and a boundary. None of those steps knows what the subject matter is.

You can see that on this very deployment. Alongside the two policing products sits a third, unrelated to this pack and to policing entirely — a commercial service-and-sales domain — built to the same standard, registered in the same catalogue, and reached through the same machinery:

Three unrelated subjects, one registry, one way in. Substitute claims, telecoms, tax, clinical records, logistics or anything else you hold: the work is engineering the source into a product that explains itself — after which the analysts, the map, the boundaries and the receipts follow without being rewritten for the domain.

What you are reading, then, is an example carried far enough to be checked. The pack is real, the numbers are measured, and the pattern behind it is the part that transfers.

Wiring a capable model to a database is no longer hard, and almost every assistant platform does it. The question worth asking is what the platform does once the model starts answering — whether a wrong answer can be stopped before you read it, whether anyone can tell afterwards how good it was, and whether you could prove to a third party what happened.

Those are the capabilities Uderia is built around. Each of the following is a mechanism you can inspect, not a claim about intent.

A capability comparison we ran across six enterprise data and AI platforms found several of these unmatched — in particular treating an ontology as a governed, versioned product, and giving an autonomous agent an identity whose permissions are a strict subset of its owner's. The individual mechanisms above are the reason, and each can be checked rather than taken on faith.

How they work together

Ask the coordinator by default. One question, and it picks. You do not need to know which analyst owns which dataset — that is the job you handed over.

Each consultation gets its own conversation. When @POLICE calls a specialist it opens a separate conversation for it and puts its question there. That is where the specialist's own work is recorded, and it stays readable afterwards.

You have to open the history to see any of this. The history panel starts closed — so by default a coordinated answer looks like one conversation with one reply, and the specialists are invisible. Open it with the ‹ handle on the left edge of the conversation. Your question then appears as an entry marked L0 with the coordinator's tag, and each specialist it consulted sits indented beneath it, marked L1 with that specialist's tag. The indent is the parent-and-child relationship, and it is the only place you can see it.

Calling one directly is opt-in. The coordinator reaches all three whatever you do. But to address one yourself — typing @NIBRS rather than letting @POLICE decide — that analyst has to be switched on, which is the optional half of step 5.

To go deeper, move into that conversation. Open the L1 entry and continue there: you are then talking to that analyst directly, with its own history, and the coordinator's thread stays clean for routing. Tagging a specialist inside the coordinator's conversation is for a one-off — it works, but every such turn is added to the coordinator's context.

The map follows the specialist. @NIBRS and @CASEDF each carry the map of both products, so it is there to open beside either of them. @PDOCS reads documents rather than data, and @POLICE holds nothing of its own — ask either for the map and there is correctly none to show.

Everything above is enough to use this well. What follows is for when you want to see why the answers behave the way they do — four steps, five minutes, and nothing to configure.

The map at the top of this page is not an illustration. It is the real thing, three levels shallower than what is actually in there, and you can open it.

Both routes below are AI-Native Data Product consumption, and both are legitimate. The standard's whole promise is that a product can be handed to an agent that has never seen it before — and the first route is that promise, exercised directly: point an agent at the product, tell it how to read the catalogue, let it work things out live. It is never stale, it needs almost no setup, and for a single product with an analyst reading every answer it is often the right choice.

The second route reads the same catalogue — just earlier, and once. The map you opened at the top is not a rival source of truth; it is the product's own entity_metadata, column_catalogue, table_relationship and access_object, projected into a form the agent holds before it plans. Nothing was modelled by hand, and nothing was invented.

That earliness is what buys the difference. An agent discovering the catalogue question by question can only be asked to stay in scope; an agent holding the map can be held to it, because the boundary is a fact the platform can check against every operation.

That approach is genuinely good. It reads the truth at the moment it asks, so it is never out of date, and it needs almost no setup. The analysts described here start from exactly the same self-describing datasets. What they add is a map built in advance — of what the data contains, what the columns mean, and how the two datasets relate — and that map is what turns instructions into limits.

Nothing on this page required a modelling exercise on top of the product. There is no second schema, no agent-specific ontology, no annotation pass. The map is generated — and it is generated from the modules the AI-Native Data Product standard already obliges a product to publish.

Which means the discipline pays twice. The catalogue you wrote for humans and downstream systems is, without further work, the thing that lets an agent answer safely.

The practical consequence for a product builder: the better your product documents itself, the better these analysts are, with no work directed at them specifically. A column you describe becomes a column an agent can find. A decision you record becomes an answer it can give. A link you honestly mark as unbuilt becomes a join it refuses to fabricate.

The same holds when something is wrong. If the product publishes a mistake, that mistake is written down in one place, so it can be found and corrected there — which is precisely what a mistake living only inside a model's judgement cannot be.

Those deterministic checks read the record before the answer reaches you. One of them is the rule that a figure taken from a sample is not a total — the shape of mistake that is hardest to notice, because every step that produced it succeeded and the number it produces looks like an answer. By default they state what they found alongside the answer; an operator can set them to withhold it instead.

The balance sits that way round deliberately: the checks that run always are the ones that cannot have an opinion, and the model judgements are the part you switch on. Of the 56 dimensions the platform defines, 35 apply to an analyst of this kind.

That record is also how the platform improves. A weakness that has been written down can be turned into a check that holds for every agent on every turn; one that exists only as someone's memory of an odd-looking answer cannot.