Radar Autonomy

Autonomous fleets need ground. Not abstractly — specific parcels, close enough to where demand actually is, with enough grid capacity to charge a fleet overnight, zoned to permit the use, with a yard geometry that a vehicle can actually circulate through, and with a path to site control that does not take three years.

Each of those is a different public-records problem with a different source, a different update cadence, and a different failure mode. Assembled by hand, the answer arrives as a spreadsheet and a recommendation — and six months later, when someone asks why this parcel, the reasoning has evaporated. The number survives; the evidence behind it does not.

Radar exists to make that chain unbreakable. Not a map with scores on it. A traceable path from a public source, through a documented derivation, to a gate that a site either cleared or failed — with the record that decided it still attached at the end.

The workbench renders more than a hundred map layers — 109 typed layer specifications over a set of shared sources — and several of them are multi-megabyte GeoJSON assets that land whenever the network delivers them. In the naive implementation, whichever asset arrives last paints on top, so the same site can look different on two loads.

So the stack is reconciled rather than appended. Every layer is declared once in one ordered canonical array; new layers insert relative to the next already-mounted canonical identifier; and the entire stack is re-sorted whenever an async asset arrives. Broad context layers are additionally pinned beneath the basemap’s own road and place labels, so geography never buries its own names.

Two details I am fond of. First, geographic scope is a compile-time contract: layer and mode availability live in tables closed with a TypeScript satisfies clause, so adding a layer without declaring which markets it is valid in is a build failure — and switching markets projects the user’s visibility rather than mutating it, so one city can never render or cite another city’s evidence. Second, the basemap has a three-tier fallback ending in an inline offline style, because a blocked CDN should degrade to a working dark map with every bundled layer still attached, not to a dead black rectangle.

There is a research agent inside the workbench. It runs a read-only tool loop over the product’s own data — workbench context, candidate search, site briefs, operator facilities, market summaries, data limitations — plus live intel and hosted web search, bounded to eight tool rounds and force-finalised after five data rounds.

The rule it lives under is the same rule the rest of the system lives under: a reply is checked for real tool evidence, and without it the agent falls back to a safe ungrounded response rather than improvising. Citations are derived mechanically from the tool calls that actually happened, not written by the model.

It is also budgeted like something that runs in production — capped body size, per-principal and per-IP rate limits, and a token-cost ceiling whose units are deliberately decoupled from billing prices, so renaming a model can never silently disable the guardrail. Limiter keys are hashes; no raw user identifier, access token, or IP is retained.

Alongside the product sits a small second repository that does nothing but govern how machine work is delegated. It holds no application code — it is registries, policies, schemas and evaluations, and it is machine-checked on every change.

Routing happens before any model reasoning. A deterministic router classifies the task, selects one specialist, and resolves exactly which context items that specialist may read — returning a three-way split of readable items, metadata-only items, and blocked items, each blocked one carrying a named machine-readable reason. Specialists then launch as no-tool subagents in a fresh, non-resumed context that can see nothing but a signed packet.

The packet is where the design earns its keep. It embeds a revision hash computed over every registry, so editing any of them invalidates every outstanding packet. And validation refuses to trust the packet’s own claims: it re-runs the router live and byte-compares the result. A packet whose two revision strings match each other but are stale is rejected. A packet that quietly appends one extra source grant on a current revision is also rejected — because the freshly derived route does not contain it.

Above all of it is a four-verb human boundary — send, spend, sign, release — declared once, derived mechanically, and enforced in code rather than requested in prose. Approvals bind to a hash of the exact payload, so a changed recipient or amount invalidates the approval. A producer can never review its own work.

The instinct on a project this size is to defer the discipline — get the map working, make the numbers look right, add provenance later. That order does not work. Provenance is not a layer you can retrofit; it is a property of how each value was constructed, and once a value has been through three derivations without carrying its source, the information is gone.

The second lesson is that constraints written in prose do not hold. Every rule in this system that actually survived contact with a deadline is one that fails a build, fails a check, or fails a schema. The rules that lived in documentation got broken — including by me.

Both of those transfer directly to diligence work. The question I ask of a target’s AI claims now is not whether the model is good. It is: what happens here when an input is missing, and who finds out?