Skip to content
Back to search

velocity

Self-hosted OSINT situation console: live aircraft, ships, satellites, quakes and conflict events fused on one 3D globe, with position history you own and replay for as long as you keep it. No API keys required.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/andrewctf--velocity/badge.svg)](/listings/andrewctf--velocity)

HTML

<a href="/listings/andrewctf--velocity"><img src="/api/listings/andrewctf--velocity/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Docker is the short road. It brings up the API, the web app and nginx together:

git clone https://github.com/AndrewCTF/velocity.git
cd velocity
cp .env.example .env       # optional, leave it empty and it still works
docker compose up          # api + web + nginx on :8080

Now open <http://localhost:8080>. It comes up live, planes moving, ships, quakes, the lot, with nothing to configure in between — and position history is already recording to a Docker volume, so it's still there the next time you run `docker compose up` (set `ARCHIVE_MODE=1` in `.env` for an open-ended archive instead of the default rolling window; see [Scope and limits](#scope-and-limits)). The first time in, a short tour points out where things live; you can pull it back up whenever from **⚙ Settings**.

That dock along the bottom is the archive. Pick a window (1h, 6h, 24h, 3d, 7d), click anywhere on the density strip, and the globe rewinds to that moment; the header swaps from *Live* to *Replay*, and one button puts you back. Playback runs at 1x through 3600x. The dated day-picker and the *recording since … · GB · fixes* ownership chip live in the 2D console at `/2d`, which reads the same `/api/history/coverage` archive.

The Play button drives the clock through half-hour tar1090 replay chunks with a 24-entry cache, decoding readsb's 16-byte heatmap entries in a Web Worker and appending each contact's samples to its `SampledPositionProperty`. Aircraft reach back to 2024 through the public readsb heatmap archives the backend proxies and caches (`GET /api/history/upstream/chunk|tracks|coverage`); one decoded adsb.lol chunk (2024-06-01 12:00 UTC) held 180 slices of 10 s and 3,953 aircraft tracks over Europe. Vessels have no public equivalent, so they replay only as far back as your own archive goes.

> **Local (open) mode.** The compute-heavy endpoints — the LLM-backed Reports > tabs, recon, and OSINT enrichment — *fail closed* on a keyless box so a > public deployment can't be made to spend GPU/credits by an anonymous caller. > The dev `docker compose up` sets `ALLOW_UNAUTHENTICATED=1` for you (the stack > is loopback-only), so those features work out of the box and the UI shows an > open-mode banner. Configure `API_KEY` or Supabase in `.env` and real auth > takes over (the flag becomes irrelevant). For an internet-facing box use > `docker-compose.prod.yml`, which leaves the flag unset. The globe, replay, > evidence capture, and all keyless feeds never needed the flag.

<details> <summary><b>Local dev without Docker</b></summary>

make install                                      # pnpm install + api venv
cd apps/api && .venv/bin/uvicorn app.main:app     # backend on :8000
pnpm dev                                          # vite on :5173, proxies /api to localhost:8000

Set `API_PROXY_TARGET` if the backend isn't on `http://127.0.0.1:8000`; the dev server proxies `/api`, `/tiles` and `/ws` there, so the browser stays same-origin. (`VITE_API_URL` is different: it makes the browser call the API directly, cross-origin, and is only for builds with no proxy in front.) `API_KEY` is for servers, the CLI and the MCP server. Never build it into a hosted web bundle, because anyone who loads the page can read it. Browsers sign in with Supabase instead (`docs/security/auth-and-sessions.md`). </details>

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "osint-velocity",
  3. "owner": { "name": "Velocity OSINT", "url": "https://projectvelocity.org" },
  4. "description": "OSINT GEOINT — live geospatial-intelligence MCP tools, an analyst skill, and slash commands for Claude Code.",
  5. "plugins": [
  6. {
  7. "name": "osint-geoint",
  8. "source": "./plugin/osint-geoint",
  9. "description": "Live ADS-B / AIS / GPS-jamming / SAR dark-vessel intelligence with cross-domain incident fusion, as 46 context-optimised MCP tools plus an analyst skill and commands.",
  10. "version": "1.0.0",
  11. "category": "intelligence",
  12. "keywords": ["osint", "geoint", "adsb", "ais", "mcp"]
  13. }
  14. ]
  15. }
README.md · README · 749 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Velocity
  2. A self-hosted live map of aircraft, ships and satellites that records what it
  3. sees, so you can rewind to any past moment. No API keys, no account.
  4. [![License](https://img.shields.io/badge/license-AGPL--3.0-orange.svg)](./LICENSE)
  5. [![Version](https://img.shields.io/github/v/release/AndrewCTF/velocity?label=release&color=blue)](https://github.com/AndrewCTF/velocity/releases/latest)
  6. [![Tests](https://img.shields.io/badge/tests-3276%20passing-brightgreen.svg)](#tests)
  7. [![No keys required](https://img.shields.io/badge/API%20keys-optional-success.svg)](#what-it-pulls-in)
  8. <p align="center">
  9. <img src="docs/media/hero-replay.gif" alt="Live world view, fly-in to Europe, an aircraft selected with its owned track, then the last hour rewound on the replay scrubber" width="900">
  10. </p>
  11. <p align="center"><i>One take, real data: the live world, zoom to Europe, click an aircraft, see its track, rewind the last hour.</i></p>
  12. ```bash
  13. git clone https://github.com/AndrewCTF/velocity.git && cd velocity
  14. docker compose up # then open http://localhost:8080
  15. ```
  16. ## Why it exists
  17. Free trackers only let you look back a little: Flightradar24 gives 7 days of
  18. replay on the free tier, MarineTraffic 24 hours, and ADS-B Exchange dropped its
  19. free API. Velocity pulls the same public feeds and writes every position to
  20. your own disk, so the history is yours.
  21. | | History you can replay | Self-hosted | Account / API key | Who owns the archive |
  22. | -------------- | --------------------------------- | ----------- | ----------------- | -------------------- |
  23. | **Velocity** | As much as your disk holds | Yes | None | You |
  24. | Flightradar24 | 7 days on the free tier | No | Account | Them |
  25. | MarineTraffic | 24 hours free (down from 72) | No | Account | Them |
  26. | ADS-B Exchange | Free API tier discontinued | No | Paid API | Them |
  27. Free tiers as of July 2026; each cell is checkable on the vendor's pricing page.
  28. ## What it does
  29. - **Records history.** Every position goes into SQLite by default, or
  30. Postgres/TimescaleDB if you set `HISTORY_PG_DSN`. The default keeps a rolling
  31. window; set `ARCHIVE_MODE=1` to keep everything. A scrubber at the bottom
  32. rewinds the map to any moment you recorded.
  33. - **Says where each contact came from.** Every aircraft and ship shows which
  34. feeds reported it, how many agreed, and how old the position is, so a stale
  35. fix doesn't look live. `/api/status/provenance` gives the same per feed.
  36. - **Puts more on the same map.** GPS jamming, ships with AIS switched off,
  37. flight restrictions, military bases, naval warnings, earthquakes, internet
  38. outages and conflict events.
  39. - **Keeps evidence.** Captures get a SHA-256 hash and an append-only custody
  40. log, and a case exports to an HTML or PPTX report that cites its sources.
  41. - **Talks to AI agents.** It runs as an MCP server, so an agent can ask about
  42. live traffic instead of guessing. Anything automated is labelled as such.
  43. [Quick start](#quick-start) · [The apps](#the-apps) · [Take the tour](#take-the-tour) · [Query it from an AI agent](#mcp-server-query-the-live-console-from-an-ai-agent)
  44. ## Limits
  45. - It's built for one person, not a team.
  46. - Coverage is whatever the public feeds see. It's good over Europe and North
  47. America and thin elsewhere; ship data is densest around Northern Europe. The
  48. map tells you where coverage is thin.
  49. - Some live state (current incidents, area selections, briefs) clears on
  50. restart. History, saved objects, cases and the evidence log stay on disk. See
  51. [Scope and limits](#scope-and-limits).
  52. - The 3D satellite view needs a lot of GPU memory.
  53. **Use at your own risk.** No warranty; the authors take no responsibility for
  54. how you use this tool or the data it pulls. Velocity pulls from third-party
  55. sources that have not authorised it: their terms apply to you, the requests
  56. come from your IP, and rate limits, bans and legal exposure are yours. Feeds can
  57. be incomplete, delayed or spoofed, and AI summaries can be wrong. Don't use it
  58. for navigation, safety-of-life, or anything where being wrong hurts someone.
  59. Read [`DISCLAIMER.md`](./DISCLAIMER.md) before you run it. Security
  60. self-assessments: [ISO/IEC 27001:2022 controls](docs/security/isms/statement-of-applicability.md),
  61. [OWASP ASVS 5.0 L2](docs/security/asvs-l2-assessment.md).
  62. ## Prerequisites
  63. Honestly, not much. There are two ways to run it, pick whichever you're set up for:
  64. - **The easy way, with Docker.** If you have Docker (24 or newer, with the
  65. `compose` plugin that ships with Docker Desktop), that's the whole list. One
  66. command and you're up.
  67. - **Running the pieces yourself.** If you'd rather not use Docker, you'll need
  68. Node 20+, pnpm 9 (`corepack enable` picks the right version for you), Python
  69. 3.12 for the backend, and `uv` to pull its dependencies. A plain venv works too
  70. if you don't have `uv`.
  71. Either way, you need a browser that can do WebGL2, so any recent Chrome, Edge or
  72. Firefox. The globe leans on your GPU, so on a laptop with switchable graphics do
  73. yourself a favour and push it onto the discrete card before you judge the frame
  74. rate.
  75. And no keys. The core feeds (planes, ships, quakes, satellites, the basemap) all
  76. run without a single API key. Keys only ever add reach; see
  77. [What it pulls in](#what-it-pulls-in) for what each one buys you.
  78. ## Quick start
  79. Docker is the short road. It brings up the API, the web app and nginx together:
  80. ```bash
  81. git clone https://github.com/AndrewCTF/velocity.git
  82. cd velocity
  83. cp .env.example .env # optional, leave it empty and it still works
  84. docker compose up # api + web + nginx on :8080
  85. ```
  86. Now open <http://localhost:8080>. It comes up live, planes moving, ships,
  87. quakes, the lot, with nothing to configure in between — and position history
  88. is already recording to a Docker volume, so it's still there the next time you
  89. run `docker compose up` (set `ARCHIVE_MODE=1` in `.env` for an open-ended
  90. archive instead of the default rolling window; see
  91. [Scope and limits](#scope-and-limits)). The first time in, a short tour points
  92. out where things live; you can pull it back up whenever from **⚙ Settings**.
  93. ![The time dock in replay: the window set to one hour, the incident and signals density strips populated across it, and the header reading "Replay · 03:00 to 04:00 Z" with a return-to-live button](docs/media/replay-scrubber.jpeg)
  94. That dock along the bottom is the archive. Pick a window (1h, 6h, 24h, 3d, 7d),
  95. click anywhere on the density strip, and the globe rewinds to that moment; the
  96. header swaps from _Live_ to _Replay_, and one button puts you back. Playback
  97. runs at 1x through 3600x. The dated day-picker and the _recording since … · GB
  98. · fixes_ ownership chip live in the 2D console at `/2d`, which reads the same
  99. `/api/history/coverage` archive.
  100. The Play button drives the clock through half-hour tar1090 replay chunks with a
  101. 24-entry cache, decoding readsb's 16-byte heatmap entries in a Web Worker and
  102. appending each contact's samples to its `SampledPositionProperty`. Aircraft
  103. reach back to 2024 through the public readsb heatmap archives the backend
  104. proxies and caches (`GET /api/history/upstream/chunk|tracks|coverage`); one
  105. decoded adsb.lol chunk (2024-06-01 12:00 UTC) held 180 slices of 10 s and 3,953
  106. aircraft tracks over Europe. Vessels have no public equivalent, so they replay
  107. only as far back as your own archive goes.
  108. > **Local (open) mode.** The compute-heavy endpoints — the LLM-backed Reports
  109. > tabs, recon, and OSINT enrichment — _fail closed_ on a keyless box so a
  110. > public deployment can't be made to spend GPU/credits by an anonymous caller.
  111. > The dev `docker compose up` sets `ALLOW_UNAUTHENTICATED=1` for you (the stack
  112. > is loopback-only), so those features work out of the box and the UI shows an
  113. > open-mode banner. Configure `API_KEY` or Supabase in `.env` and real auth
  114. > takes over (the flag becomes irrelevant). For an internet-facing box use
  115. > `docker-compose.prod.yml`, which leaves the flag unset. The globe, replay,
  116. > evidence capture, and all keyless feeds never needed the flag.
  117. ### Open it on your phone
  118. The stack listens on `127.0.0.1` only, on purpose: the dev stack runs in open
  119. mode, so anything that can reach it can use it. To reach your own instance from
  120. your phone, put it on your tailnet instead of your LAN:
  121. ```bash
  122. tailscale serve --bg 8080 # https://<this-machine>.<your-tailnet>.ts.net
  123. ```
  124. Then add that origin to `.env` and restart, or the API refuses the new `Host`
  125. header (the DNS-rebinding guard in `app/origin_guard.py`):
  126. ```bash
  127. CORS_ORIGINS=http://localhost:8080,https://<this-machine>.<your-tailnet>.ts.net
  128. ```
  129. Only devices signed in to your tailnet can open it. Don't use `tailscale funnel`,
  130. which publishes it to the whole internet. For anything wider than your own
  131. devices, run `docker-compose.prod.yml` with Supabase sign-in configured
  132. (`docs/security/auth-and-sessions.md`); it fails closed without a credential.
  133. <details>
  134. <summary><b>Local dev without Docker</b></summary>
  135. ```bash
  136. make install # pnpm install + api venv
  137. cd apps/api && .venv/bin/uvicorn app.main:app # backend on :8000
  138. pnpm dev # vite on :5173, proxies /api to localhost:8000
  139. ```
  140. Set `API_PROXY_TARGET` if the backend isn't on `http://127.0.0.1:8000`; the dev
  141. server proxies `/api`, `/tiles` and `/ws` there, so the browser stays same-origin.
  142. (`VITE_API_URL` is different: it makes the browser call the API directly,
  143. cross-origin, and is only for builds with no proxy in front.) `API_KEY`
  144. is for servers, the CLI and the MCP server. Never build it into a hosted web
  145. bundle, because anyone who loads the page can read it. Browsers sign in with
  146. Supabase instead (`docs/security/auth-and-sessions.md`).
  147. </details>
  148. ## The apps
  149. Velocity isn't one mega-dashboard; it's a workspace of eighteen apps that all
  150. share the same selection and time context, so switching never loses the object
  151. you had selected. The launcher in the top bar groups them:
  152. | Group | Apps | What they're for |
  153. | ----------- | ---------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  154. | **Live** | Map · Sim | The Cesium globe (always mounted behind everything else) and a browser war-game overlay. |
  155. | **AI** | AI · Models | The analyst agent, automated watch and alerts, and a registry of local models (installed, catalog, presets, engine). |
  156. | **Analyze** | Explorer · Graph · Investigate · Targeting · Video · Country · Markets · Quiver · Vertex | Filter the live object store, grow a link-analysis graph, run digital OSINT (domains/people/wallets), a notional kill-chain board, FMV/ground recon, per-country World-Bank/UN stat dossiers, indices/commodities/FX with a stress index, time-series cards over the recorded archive, and a system graph of sources, feeds and layers. |
  157. | **Data** | Foundry · Workflows · Workshop | Bring your own data through governed pipelines; automate the live feeds with a node-graph editor; compose modules from live widgets. |
  158. | **Product** | Reports | Case files, watch-officer briefs, dossiers, and case→report export. |
  159. | **3D** | City 3D | Gaussian-splat city scenes built from a keyless satellite AOI. |
  160. The rest of this README tours the ones you'll live in. Everything below is a
  161. real screenshot of the current build (v1.0.1), taken against live feeds on
  162. 2026-08-08, not a mockup. `node scripts/screenshot-readme.mjs` re-shoots the
  163. whole set.
  164. ## Take the tour
  165. **1. The whole planet, live.** Thousands of aircraft plus vessels, satellites,
  166. quakes and more on one Cesium globe. Every aircraft and ship renders as its
  167. category icon, coloured and rotated to its heading; dense areas cluster into
  168. count badges you can drill into.
  169. ![Global view of the Velocity globe with live air, sea and incident traffic](docs/media/hero-world.jpeg)
  170. **2. Zoom anywhere, toggle everything.** Drag into a region and traffic, labels
  171. and coastlines fill in. The left rail is the whole intel stack in one tree — air,
  172. maritime, space, ground hazards, signals and 18 infrastructure layers — each
  173. with its live count. A right-side map toolbar adds the analyst verbs on top of
  174. the globe: **measure** a running great-circle distance, **area-select** a box
  175. and search every object inside it, **annotate** with dropped markers, or **move**
  176. a marker — plus one-click camera reset and zoom.
  177. ![The layer tree over a live European air picture, air/maritime/space/hazards toggles with counts](docs/media/panels/rail-layers.jpeg)
  178. **3. Click anything.** Select an aircraft or vessel and the right panel fills
  179. with its dossier: identity, kinematics, the flight/route, ACARS, a
  180. pattern-of-life baseline, GPS integrity and the raw fields — while a magenta
  181. line traces its recent track on the globe. An **AI assessment** block (labelled,
  182. and grounded in the observed track) summarises what the dossier fields imply.
  183. Click empty space and it all clears.
  184. ![A selected aircraft over the North Atlantic with its full dossier panel open — identity, kinematics, integrity, freshness, provenance, sanctions screening — and its magenta track drawn back across the ocean](docs/media/panels/inspector-selection.jpeg)
  185. **4. Or query the whole store at once.** The Explorer app is every live object
  186. in one filterable, sortable table — tens of thousands of tracks across vessels,
  187. aircraft and quakes, each tagged with the feed it came from and how long ago it
  188. was seen. Facet it, save the search, export the result to CSV.
  189. ![Explorer: every live object in one filterable table, faceted by kind and tagged by source](docs/media/ui-explorer.png)
  190. **5. Chokepoints and AOIs, watched continuously.** A curated library of the
  191. world's maritime chokepoints — Hormuz, Bab-el-Mandeb, Malacca, the Taiwan
  192. Strait, the English Channel, undersea-cable corridors — each with live transit
  193. counts and the daily oil-flow figures that make it matter. Standing detections
  194. fire against them in the background.
  195. ![Global chokepoint watch: Hormuz, Bab-el-Mandeb, Suez, Panama and Malacca with their daily transit and oil-flow figures](docs/media/panels/rail-chokepoints.jpeg)
  196. **6. Airspace, bases, ports and airports — operational context, still keyless.**
  197. Toggle the TFR/Airspace layer and live FAA temporary flight restrictions draw as
  198. real polygons, coloured by reason with their altitude bands. Alongside them:
  199. 7,183 military bases (air, naval and army, from Wikidata), NGA NAVAREA broadcast
  200. warnings with mine areas flagged, 3,804 ports from the NGA World Port Index
  201. (harbour size and type, shelter, repairs, dry dock, pier and channel depths),
  202. and airports enriched with runways (length, surface, lighting, per-end ILS
  203. category from FAA NASR), tower/ground/ATIS frequencies, live METAR with flight
  204. category, and a LiveATC linkout. A basemap picker swaps between nine keyless
  205. map styles (Carto dark, 3D satellite + terrain, Apple satellite, Esri
  206. imagery/topo/dark, OpenTopoMap, USGS, Sentinel-2 cloudless), each probed live
  207. before it's offered and each carrying its required attribution.
  208. ![Live FAA temporary flight restrictions drawn as polygons over the US, with SIGMET hazards and the airport and port layers on](docs/media/places-airspace.jpeg)
  209. **7. Space, with real physics.** ~16k satellites from CelesTrak, propagated
  210. in-browser with actual SGP4 orbital mechanics and enriched from SATCAT with
  211. owner, launch date, radar cross-section and orbit class.
  212. ![The globe wrapped in the live satellite constellation](docs/media/hero-satellites.jpeg)
  213. **8. The watch officer works the inbox.** An autonomous watch officer fuses
  214. jamming, dark vessels, military air activity and conflict events into ranked,
  215. cited alerts — GPS spoofing, jamming cells, dark-vessel candidates — each with an
  216. `[inferred]` reasoning line and a one-click _slew to_. It runs `detect_deception`
  217. and `deep_analyze` against the live picture, so the inbox fills itself on a fresh
  218. keyless boot with no operator setup.
  219. ![Watch-officer inbox: queued alerts carrying spoofing, jamming and dark-vessel badges alongside the reasoning behind each one](docs/media/panels/rail-inbox.jpeg)
  220. **9. …and writes the brief.** Every couple of minutes it promotes the
  221. convergences — "vessels went dark near reported activity", "spoofed tracks
  222. co-located with an AIS gap" — into ranked incident cards with a written, cited
  223. summary and a _slew to_ button. Actionable incidents are auto-promoted into the
  224. investigation graph, so the ontology grows itself.
  225. ![Watch-officer intel brief: ranked, cited cross-domain incidents with slew-to](docs/media/ui-briefs.png)
  226. **10. Keep it as evidence.** Anything worth keeping goes into the
  227. chain-of-custody **evidence locker**: capture a URL snapshot, upload a file, grab
  228. a screenshot, or freeze the current feed state, and each artifact is hashed with
  229. SHA-256, written to `./data/evidence`, and logged to an append-only custody
  230. chain in the local ontology store. Attach it to a situation, re-verify the hash
  231. any time, or roll a whole case into a signed hash-of-hashes manifest. Fully
  232. keyless. From there, **Reports** exports the case (see [Export](#export)) as a
  233. JSON bundle, a self-contained HTML report with per-claim provenance footnotes,
  234. or a PPTX brief — with any AI narrative confined to a clearly labelled block.
  235. **11. A tool that draws on the map gets its own window.** The annotation
  236. editor, the watchbox rules and the field kit open as free-floating, draggable,
  237. resizable windows over the globe rather than stealing the rail from the layer
  238. tree — arm a tool from the map toolbar, set up what it draws beside the thing
  239. you are drawing on, and _Window → Re-dock every floating panel_ clears them all.
  240. Positions persist for the session.
  241. ![Two floating windows over the live globe: the annotation editor with its shape, colour and style controls, and the watchbox panel with its enter/exit/loiter trigger rules](docs/media/ui-detach-toolbar.jpeg)
  242. **12. Bring your own data — the Foundry tab.** Upload a CSV/JSON/NDJSON, shape it
  243. through a governed pipeline (13 transform steps: filter, derive, join, aggregate,
  244. union, window, pivot, dedup, cast, sort…), gate every version with data-health
  245. checks (freshness SLAs, schema-drift, uniqueness…), and bind it into the same
  246. ontology graph as the live feeds. Lineage, immutable versions with rollback, and
  247. a dead-letter for rows that fail a transform all come along; the pipeline graph
  248. flags exactly which outputs went stale.
  249. ![Foundry lineage pipeline: raw datasets on the left feeding five transforms into derived outputs, with raw, derived and stale colour-coded](docs/media/foundry-pipeline-new.png)
  250. **13. Automate it — the Workflows tab.** A node-graph editor over the same live
  251. feeds and ontology: wire sources (aircraft, vessels, quakes, alerts, datasets,
  252. ontology, countries) through sandboxed Python/SQL/LLM transform blocks into sinks
  253. (alerts, ontology objects, datasets, persistent memory), then run it on a
  254. schedule. Control blocks can reach outward too — webhooks to your own server, or
  255. a MAVLink bridge for drone tasking that rehearses log-only without a vehicle.
  256. ![A Workflows DAG: live aircraft through Python and SQL into an alert](docs/media/workflows-dag.png)
  257. ## Scope and limits
  258. The point is fusion. Plenty of sites already do one feed well: Flightradar24 for
  259. planes, MarineTraffic for ships, [GPSJam](https://gpsjam.org) for jamming.
  260. Velocity goes after the seam between them: AIS plus radar imagery flags a ship
  261. that's switched its transponder off; a cluster of aircraft reporting bad GPS
  262. integrity becomes a jamming hotspot; when two or more of those line up in the
  263. same place and time, they get promoted to a single incident with a written,
  264. cited summary.
  265. A few things worth knowing up front, because I'd rather you read them here than
  266. be annoyed later:
  267. - It's built for one analyst. One optional API key, no accounts or roles.
  268. - **What persists vs what clears.** Durable under `./data/` or the Timescale
  269. service: the position-history archive (a Postgres + TimescaleDB hypertable by
  270. default; SQLite at `./data/history.db` remains the keyless fallback when no
  271. `HISTORY_PG_DSN` is set, with one boot warning naming the switch), the local
  272. ontology store (ontology objects, case files, situations;
  273. `intel/ontology_local.py`, `./data/ontology.db`), plus separate SQLite files
  274. for Foundry, Workflows,
  275. alert rules, cached news and the Instability Index scorer (`foundry.db`,
  276. `workflows.db`, `alert_rules.db`, `news_history.db`, `instability.db`), and a
  277. keyless-local audit log (`audit_log.db` — only materializes when no
  278. `SUPABASE_URL` is configured; a keyed deployment writes audit rows to
  279. Supabase instead and never creates the file). That's 8 SQLite files, not
  280. one — back up the whole `./data` volume, not a single DB. Also durable: the
  281. evidence locker (blobs under `./data/evidence`, custody chain in the
  282. ontology store's append-only `assertions` table), a disk tile cache
  283. (`./data/tilecache`) and any downloaded local models (`./data/models`).
  284. Volatile, and cleared on backend restart: the live incident list, transient
  285. AOI selections, and generated watch-officer briefs. The Docker Compose
  286. volumes mean the durable stores survive `docker compose down`, not just a
  287. process restart.
  288. - **Retention, honestly.** The dev compose sets `HISTORY_RETENTION_HOURS=48`
  289. (2 days), but that's a ceiling, not a promise: `HISTORY_MAX_BYTES` (2 GB by
  290. default) binds first, and at measured global ADS-B+AIS ingest (~3 GB/h on a
  291. keyless box pulling full-breadth feeds) the byte cap fills well before the
  292. hour window matters, leaving well under 2 hours of effective depth out of
  293. the box — not 48. The hour window only becomes the binding limit once disk
  294. is large enough for it to be the tighter cap; a genuine 48h global archive
  295. needs on the order of 150 GB (`~3 GB/h * 48h`). Raise `HISTORY_MAX_BYTES`,
  296. or set `ARCHIVE_MODE=1` with `HISTORY_DISK_BUDGET_GB` sized to what you're
  297. willing to spend on disk (the production compose profile does this, 5 GB to
  298. start). `/api/history/coverage` reports the ACTUAL current depth
  299. (`oldest_ts`), not the configured ceiling, and the 2D console's day-picker
  300. and ownership chip render it, so you can see what you're really getting.
  301. Depth answers now come from the hourly `positions_hourly` aggregate; the old
  302. SQLite coverage scan took 73 s over 78M fixes, which is why the rollup
  303. exists.
  304. - AIS runs keyless and global (~50k vessels tracked, MMSI-deduped across
  305. ShipXplorer, MyShipTracking, Digitraffic and Kystverket), but coverage is densest over
  306. Northern Europe and the Baltic and thins out elsewhere; an AISStream key fills
  307. in the gaps. Sparse regions still lean on the radar (SAR) layer.
  308. - **The two headless-Chrome sidecars are degraded under Docker, not crashed.**
  309. ADS-B (OpenSky + the httpx tar1090 mirrors + ShipXplorer AIS) and the
  310. regional Kystverket/Digitraffic AIS feeds are direct HTTP calls and run at
  311. full strength in the container. But the tar1090 ADS-B sidecar and
  312. MyShipTracking (the enabled primary keyless _wide-area_ AIS source) drive a
  313. real Chromium via Node, which the slim API image doesn't ship — they log a
  314. warning and sit idle rather than crash the backend, so you lose their extra
  315. coverage, not the app. Run bare-metal (`bash scripts/run-api.sh`) for full
  316. sidecar coverage.
  317. - Some **Analyze** apps are notional by design — the Targeting kill-chain board
  318. and the Video/FMV sensor HUD carry a "NOTIONAL // SIMULATED" banner and are
  319. driven by the Sim overlay, not a live weapons or ISR feed.
  320. - The 3D satellite view will eat your VRAM. The default 2D dark map runs on a
  321. laptop; check [System requirements](#system-requirements) before switching the
  322. heavy mode on.
  323. None of it needs an API key to start. Keys only add reach.
  324. ## What is enforced
  325. Not promises, checks in the tree. Each line names the route or test that holds
  326. it:
  327. - **Clearance on reads and writes.** One predicate,
  328. `intel/ontology.visible_to`, filters local reads (`get`, `list_by_kind`,
  329. `search`, links, assertions) and the situations, maps and evidence routes by
  330. the caller's level and compartments; keyless callers are clearance 0, and a
  331. write above clearance or onto a hidden row answers 403.
  332. → `apps/api/tests/test_clearance_local_reads.py`
  333. - **Custody-chained evidence.** Every capture is hashed with SHA-256 and
  334. appended to an immutable custody log; `GET /api/evidence/{sha}/verify`
  335. re-checks the bytes. → `apps/api/tests/test_evidence.py`
  336. - **Hash-chained audit.** Mutations append to `action_log.db`; `GET
  337. /api/audit/verify` walks the chain. → `apps/api/tests/test_asvs_fix_a_logging.py`
  338. - **Citations withheld when ungrounded.** `LLM_REQUIRE_CITATIONS=1` (default)
  339. withholds a selection or country brief that cites none of its own ids;
  340. `GET /api/ai/guardrails` reports the posture. →
  341. `apps/api/tests/test_citations_hard.py`
  342. - **Human-in-the-loop write-back.** A write-back action is operator-only and
  343. runs only from a proposal the operator approves; the audit row carries the
  344. payload's SHA-256, never the payload. → `apps/api/tests/test_writeback_action.py`
  345. ## What it pulls in
  346. Live numbers measured off a running keyless backend on 2026-08-08; they move
  347. around through the day:
  348. | Feed | Typical live count | Where it comes from |
  349. | ------------------------------- | ---------------------------------------- | ------------------------------------------------------- |
  350. | Aircraft (ADS-B) | 12–15k (14,436 measured) | OpenSky + airplanes.live + adsb.lol + FR24 |
  351. | Military aircraft | ~30–60 | adsb.lol + airplanes.live |
  352. | Vessels (AIS) | ~50k tracked, global | ShipXplorer + MyShipTracking + Digitraffic + Kystverket |
  353. | GPS jamming | ~220 flagged 1° cells | ADS-B NACp/NIC, the GPSJam method |
  354. | Dark vessels | radar change-detection | Sentinel-1 SAR |
  355. | Fused incidents | correlation-driven | the correlation engine |
  356. | Satellites | 16,095, SATCAT-enriched | CelesTrak |
  357. | Airspace (TFRs) | live restriction polygons | FAA |
  358. | Military bases | 7,183 (+1,330 MIRTA/Wikidata) | Wikidata + DIA MIRTA |
  359. | Naval broadcast warnings | ~800 plotted points | NGA NAVAREA |
  360. | Ports | 3,804, with harbour detail | NGA World Port Index |
  361. | Airports | runways + ILS + frequencies + live METAR | FAA NASR, NOAA, LiveATC |
  362. | Earthquakes | ~290/day | USGS + EMSC |
  363. | News + fact-check | ~370 articles (off by default) | publisher RSS |
  364. | Internet outages | country level | IODA, Cloudflare |
  365. | Submarine cables | ~700 | TeleGeography |
  366. | Conflict events | ~1.5k live | GDELT, EONET, ACLED |
  367. | Wildfires | VIIRS hotspots | NASA FIRMS (needs a key) |
  368. | 3D war damage, imagery, webcams | varies | Sentinel, GIBS, OSM |
  369. | Per-country toolkits | 53 countries | open-data / registries / sanctions links |
  370. Optional keys, if you want more reach: AISStream for global AIS, an OpenSky
  371. login for a bigger ADS-B budget, `FIRMS_MAP_KEY` for fires, an ACLED key for
  372. conflict events, `CLOUDFLARE_TOKEN` for outages. `GET /api/intel/sources`
  373. reports what's actually live versus what's still waiting on a key.
  374. ### Use your own receiver
  375. If you run an ADS-B receiver (readsb, ultrafeeder, tar1090), Velocity folds its
  376. aircraft into the same picture as the public feeds and records them to your
  377. archive like everything else. Point `ADSB_FEED_URLS` in `.env` at your
  378. tar1090's `aircraft.json`. The variable replaces the default list, so keep the
  379. defaults in it if you still want them:
  380. ```bash
  381. ADSB_FEED_URLS=http://192.168.1.20:8080/data/aircraft.json,https://globe.theairtraffic.com/data/aircraft.json,https://skylink.hpradar.com/data/aircraft.json,https://api.adsb.lol/v2/point/0/0/20000
  382. ```
  383. Contacts are merged by ICAO address, freshest fix wins. Inside Docker,
  384. `localhost` is the API container, so use the receiver's LAN address.
  385. For a small desk display of what is overhead (ESP32, e-ink), `GET /api/overhead`
  386. returns the nearest aircraft as compact JSON from the same snapshot, with no
  387. upstream call of its own: see [docs/desk-display.md](docs/desk-display.md).
  388. ## MCP server: query the live console from an AI agent
  389. The part I think is genuinely new: the backend doubles as a **Model Context
  390. Protocol** server, so an AI agent can interrogate the same warm feeds the globe
  391. renders without scraping a dozen sites or flooding its own context. Ask "where
  392. is GPS being jammed right now?" and it answers from the live feed. Full
  393. architecture + `/api/intel/*` HTTP reference: [`docs/mcp-server.md`](./docs/mcp-server.md).
  394. It exposes 94 tools over `app.mcp_server` (a representative slice below; run
  395. `--list-tools` for the full set):
  396. | Tool | What it returns |
  397. | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  398. | `get_situation` | Global summary: aircraft by category, GNSS-degraded count, emergencies, worst jamming cells, vessel/alert counts. The cheap first call. |
  399. | `focus_area(lat,lon,radius_nm)` | **Loads a region PRIMARY** (dedicated fresh `/v2/point` fetch + ongoing priority refresh, independent of global rate limits) and returns a full bundle: aircraft + density + GPS jamming + vessels + fused anomalies. |
  400. | `aircraft_density` | Grid of cells (count, by category, GNSS-degraded) for an area. |
  401. | `gps_jamming` | GPSJam-method assessment (ADS-B NACp<8 / NIC<7, 1° bins): flagged cells, severity, affected aircraft. Global or scoped. |
  402. | `query_aircraft` | Filtered query (bbox/centre, category, squawk, callsign, altitude band, emergency / gnss_degraded / on_ground). |
  403. | `lookup_aircraft(ident)` | One aircraft by ICAO24 or callsign + integrity/threat assessment. |
  404. | `query_vessels` | AIS vessels in an area, classified; `dark_only` for dark-vessel candidates. |
  405. | `anomalies` | Fused report: emergencies, jamming hotspots, dark vessels, alerts + a triage threat level. |
  406. | `detect_deception` / `locate_emitter` | Flag spoofed/co-located tracks; triangulate a jamming source from degraded-integrity aircraft. |
  407. | `whats_changed` / `incident_history` | Delta since a timestamp; the incident timeline for an area. |
  408. | `deep_analyze(question, lat?, lon?)` | Gathers the relevant intel JSON and has a **reasoning model** reason over it (DeepSeek when configured, else a local Ollama model), so heavy analysis stays off the agent's context and only the conclusion returns. |
  409. Every tool returns compact, bounded JSON (counts, grids, ≤50-item samples), so
  410. an agent can sweep the planet for a few hundred tokens instead of pulling 15k
  411. features. Heavy tools also take **`detail='short'`** (the default digest — top-N
  412. of each list plus a `<field>_total`) or **`detail='long'`** (the full bundle), so
  413. an agent sweeps in `short` and drills in `long`. Area-primary loading means the
  414. agent's region of interest stays fresh and dense even while the global firehose is
  415. being rate-limited; the rest of the world keeps streaming from the sticky snapshot.
  416. The same fusion powers the in-app **AI selection brief**: click an entity and
  417. `POST /api/ai/selection/brief` fuses its registry enrichment and pattern-of-life
  418. dossier into a selection-tier model prompt — every claim cites the dossier field
  419. it came from, an uncited answer is withheld rather than shown, and it degrades
  420. to the raw props if no model is configured.
  421. ### Install as a Claude Code plugin (skill + commands + agent)
  422. The repo is also a Claude Code **plugin marketplace**. One install wires the MCP
  423. server _plus_ an analyst skill (`osint-intel`), slash commands (`/osint-brief`,
  424. `/osint-watch`, `/osint-jamming`), and a `osint-watch-officer` agent. Start the
  425. backend (`bash scripts/run-api.sh`), then in Claude Code:
  426. ```
  427. /plugin marketplace add /path/to/OSINT
  428. /plugin install osint-geoint@osint-velocity
  429. ```
  430. Set **repo_dir** and **python** (the repo's venv interpreter) when prompted; the
  431. plugin runs that Python directly, so it works on Windows, macOS, and Linux. The
  432. installer prints the exact commands for your OS: `bash
  433. plugin/osint-geoint/install.sh` (Linux/macOS, `-y` to register the MCP server) or
  434. `plugin\osint-geoint\install.ps1` (Windows, `-Run` to register).
  435. ### Point your agent at your own instance
  436. The MCP server is mounted into the backend at `/mcp` (streamable-HTTP), so
  437. once you're running Velocity yourself there's nothing extra to install to
  438. query it from an agent. Register it with any MCP client against your own
  439. host:
  440. ```bash
  441. claude mcp add --transport http osint-geoint \
  442. http://localhost:8000/mcp \
  443. --header "Authorization: Bearer $VELOCITY_TOKEN"
  444. ```
  445. `$VELOCITY_TOKEN` is only required if you've set `API_KEY` on the backend; a
  446. keyless local instance needs no header at all.
  447. ### Self-host / develop
  448. ```bash
  449. # 1. backend must be running (provides the warm feeds)
  450. uv run --project apps/api uvicorn app.main:app --port 8000
  451. # 2a. MCP server over stdio (Claude Code / Desktop / Agent SDK), cross-platform
  452. uv run --project apps/api python -m app.mcp_server
  453. # 2b. or streamable-HTTP
  454. uv run --project apps/api python -m app.mcp_server --http --port 8765
  455. # introspect (no backend needed)
  456. uv run --project apps/api python -m app.mcp_server --list-tools
  457. ```
  458. To register the local stdio server with Claude Code, run from the repo root:
  459. ```bash
  460. claude mcp add osint-geoint -- uv run --project apps/api python -m app.mcp_server
  461. ```
  462. `uv run` resolves the right interpreter on Linux, macOS, and Windows without
  463. hardcoding a venv path. No `uv`? Point it at the venv Python directly:
  464. `apps/api/.venv/bin/python -m app.mcp_server` (Linux/macOS) or
  465. `apps\api\.venv\Scripts\python.exe -m app.mcp_server` (Windows), run from
  466. `apps/api`.
  467. Config (env or `apps/api/.env`): `API_BASE`, `API_KEY`, `OLLAMA_HOST`,
  468. `OLLAMA_MODEL` (empty picks the smallest installed model; `deep_analyze`
  469. degrades to returning raw JSON if Ollama is absent). The MCP server never
  470. crashes a tool call: backend down returns a structured `backend_unreachable`
  471. error; Ollama down falls back to raw intel JSON.
  472. ## Export
  473. Two ways out, for two jobs:
  474. **The live picture.**
  475. `GET /api/export?fmt=geojson|csv|kml&kinds=aircraft,vessels&bbox=min_lon,min_lat,max_lon,max_lat&limit=N`
  476. downloads the current snapshot the globe renders as **GeoJSON** (QGIS /
  477. kepler.gl / Leaflet), **CSV** (spreadsheets), or **KML** (Google Earth). `bbox`
  478. clips to a viewport; `kinds` is comma-separated (default `aircraft`); `limit`
  479. caps features; vessels are best-effort.
  480. **A finished case.**
  481. `POST /api/situations/{id}/export?fmt=json|html|pptx` walks a situation's
  482. children, its sourced assertions and every attached piece of evidence into a
  483. shareable artifact: a self-describing **JSON** bundle, a self-contained **HTML**
  484. report with a provenance footnote on each claim, or a **PPTX** brief. Any AI-written
  485. narrative is confined to one labelled block — the rest is your cited evidence.
  486. ## System requirements
  487. The heavy component is the **client**, a CesiumJS WebGL2 globe. It is GPU- and
  488. browser-main-thread-bound, and the backend is light. WebGL2 is required
  489. (Chrome/Edge 110+, Firefox 110+). On hybrid-graphics laptops, force the discrete
  490. GPU (`chrome://gpu`, look for adapter "ACTIVE").
  491. **VRAM depends heavily on which mode you run:**
  492. - **2D-dark (default basemap):** light. The globe is a proxied 2D raster basemap
  493. plus the entity layers (aircraft/vessels). Runs on integrated graphics / ~2–4 GB
  494. VRAM, which is the right mode for modest hardware.
  495. - **3D-sat (satellite imagery + world terrain + OSM 3D buildings, optional Google
  496. Photorealistic 3D):** **VRAM-heavy.** CesiumJS streams terrain meshes, high-res
  497. imagery, and 3D-tile building/photogrammetry sets, and it caches into whatever
  498. VRAM is available, measured at **20+ GB on a 32 GB card**. Tilesets are now
  499. individually cache-capped (Google 3D ~1.5 GB, OSM buildings ~0.5 GB) and MSAA is
  500. off (FXAA instead), but with terrain + global imagery + a high-DPI/4K canvas the
  501. resident set is still large. On a card with less VRAM, Cesium evicts and
  502. re-fetches more aggressively (lower fps, more pop-in) and still runs.
  503. | Tier | GPU | RAM | Display | What you get |
  504. | ------------- | ------------------------------------------------ | ----- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
  505. | Edge / lite | WebGL2 integrated (Iris Xe / Vega / M1) | 8 GB | 1080p | `OSINT_PROFILE=lite` (default). 9k aircraft, 32k vessels, 2D-dark. Backend fits in ~1.5 GB; the adaptive governor sheds low-priority layers to keep frames under budget. |
  506. | Recommended | Discrete ≥8 GB VRAM (RTX 3060 / RX 6700 / M-Pro) | 16 GB | 1080p–1440p | Full profile with all feeds. 2D-dark smooth; 3D-sat usable at city scale. |
  507. | Full / 3D-sat | RTX 4070+/16 GB VRAM or better | 32 GB | up to 4K | All feeds + browser sidecars + 3D-sat terrain + buildings; best frame rate. |
  508. These tiers come from a cgroup-isolated benchmark (`tools/perf/bench_ram.sh`)
  509. that constrains backend + Vite + Chrome inside a single MemoryMax and measures
  510. real fps, renderMs, entity counts, and OOM kills at each RAM level. 3D-sat
  511. genuinely wants a lot of VRAM, and the low-VRAM minimum only holds for the
  512. 2D-dark map; switch on 3D-sat and you'll want a discrete card with headroom.
  513. **Backend (server):** Python 3.12, outbound HTTPS. The `lite` profile
  514. (default) disables browser sidecars, history, and the FR24/OpenSky-gaps tiers,
  515. measuring ~530 MB steady-state RSS — comfortably fits an 8 GB box alongside
  516. the browser. The `full` profile with all direct feeds warm measures ~3.2 GB.
  517. The optional headless-Chrome coverage sidecars are the real memory line item:
  518. the ADS-B scraping tier measured ~11 GB RSS across its ~50-process Chrome tree
  519. and the AIS tier ~3-6 GB across its ~20-36 (both measured 2026-07-24 at full
  520. coverage), so budget roughly 15 GB on top of the backend when both are
  521. enabled — or keep `lite` and use the direct feeds.
  522. ## Stack
  523. - **Frontend**: Vite + React 18 + TypeScript + CesiumJS + MapLibre GL JS v5.24 + Tailwind + Zustand
  524. - **Backend**: FastAPI (Python 3.12) + httpx + websockets. Live _derived_ state
  525. is in-process (bounded observation store + disk tile cache); durable state
  526. (the position-track replay archive, the ontology store: objects / case files /
  527. situations, and the evidence locker's custody chain) persists to
  528. Postgres + TimescaleDB or SQLite, on Docker volumes in Compose, with a
  529. rolling window by default or an open-ended disk-budgeted archive via
  530. `ARCHIVE_MODE`
  531. - **Agent access**: Model Context Protocol server (`app.mcp_server`, MCP SDK) + optional local Ollama analysis
  532. - **Data**: PostgreSQL 16 + TimescaleDB backs the position archive today (6 hour
  533. chunks, columnar compression, hourly `positions_hourly` rollup, SQLite as the
  534. keyless fallback). PostGIS + Redis remain planned.
  535. - **Infra**: Docker Compose, nginx reverse proxy
  536. ## Layout
  537. ```
  538. osint/
  539. ├── apps/web/ # React + Cesium console (14-app workspace)
  540. │ └── src/
  541. │ ├── globe/ # Cesium globe, layers, map toolbar (measure/area/annotate)
  542. │ ├── entity-panel/ # right-rail dossier / inspector
  543. │ ├── evidence/ # chain-of-custody evidence locker UI
  544. │ ├── foundry/ # FOUNDRY surface (datasets, pipeline DAG, builds, ontology)
  545. │ └── shell/ # app switcher + detachable floating panels
  546. ├── apps/api/ # FastAPI backend
  547. │ └── app/
  548. │ ├── intel/ # agent-facing analytics, local ontology store, evidence, case export
  549. │ ├── foundry/ # BYO-data layer: datasets, transforms, builds, checks, binding
  550. │ ├── routes/intel.py # /api/intel/* deep-query JSON API
  551. │ ├── routes/evidence.py# /api/evidence/* capture / verify / attach / manifest
  552. │ ├── routes/foundry.py # /api/foundry/* datasets/pipelines/checks/bindings
  553. │ └── mcp_server.py # Model Context Protocol server
  554. ├── packages/shared/ # Shared TS types (LayerDescriptor, Observation)
  555. ├── docs/ # design notes, decisions.md, foundry-plan.md
  556. └── infra/ # Docker, nginx, db init
  557. ```
  558. ## Tests
  559. ```bash
  560. # from the repo ROOT (running from apps/api makes .env auth resolve → a wall of 401s)
  561. OSINT_DISABLE_BACKGROUND=1 apps/api/.venv/bin/pytest apps/api -q # 3276 passed + 21 skipped
  562. pnpm -r test # vitest (web, shared)
  563. pnpm -r typecheck
  564. bash scripts/verify.sh # typecheck + lint + web unit + api tests in one shot
  565. # manual MCP integration drivers (need backend on :8000):
  566. # apps/api/.venv/bin/python tests/mcp_client_check.py # stdio handshake
  567. # apps/api/.venv/bin/python tests/mcp_full_check.py # tools end-to-end + Ollama
  568. ```
  569. ## Phase status
  570. This is the internal build log, in order shipped — not the pitch (that's
  571. above). Legend: ✅ shipped · 🚧 in progress
  572. - ✅ **Phase 0** — Foundation
  573. - ✅ **Phase 1** — MVP: live ADS-B / AIS / quakes / GPS-jamming layers on the globe
  574. - ✅ **Phase 2**: Replay + drill-in. The timeline scrubber and the history
  575. archive ship with a Postgres + TimescaleDB backend (48h rolling window by
  576. default, or an open-ended disk-budgeted archive with `ARCHIVE_MODE`), SQLite
  577. as the keyless fallback, and a tar1090-style half-hour chunk replay pipeline
  578. that carries aircraft back to 2024 from public readsb heatmap archives;
  579. drilling into any past moment works today. PostGIS + Redis for the rest of
  580. the platform's state are a deferred scaling upgrade, not a blocker
  581. - ✅ **Phase 3** — Fusion engine + alerts (correlation rules) + 2D mirror
  582. - 🚧 **Phase 4** — Advanced sensors + agent access. MCP server + intel API
  583. (now with a Claude Code plugin and `detail=short|long` tool variants), Sentinel-1 SAR
  584. dark-vessel detection, an autonomous watch-officer that writes cited incident
  585. briefs and auto-populates the ontology graph from them, a keyless
  586. infra/domain OSINT layer, a places/airspace layer (FAA TFR polygons,
  587. military bases, NGA naval warnings, World Port Index port detail, NASR/METAR
  588. airport enrichment, an 8-way keyless basemap picker), a **chain-of-custody
  589. evidence locker** and **case→report export** (JSON/HTML/PPTX with per-claim
  590. provenance), a globe map toolbar (measure/area-select/annotate) and detachable
  591. floating panels, a photo-geolocation pipeline, a City 3D Gaussian-splat viewer,
  592. optional local-GPU (Ollama) inference, and a first-run onboarding tour. More
  593. sensors and deeper analysis are ongoing.
  594. - 🚧 **Phase 5** — Foundry: a keyless, local, single-operator data-integration
  595. loop. Upload → transform (governed 13-step DSL with
  596. lineage) → build (dependency DAG, staleness, cycle rejection) → data-health
  597. checks → bind into the local ontology graph. In: immutable versions +
  598. rollback, row-level quarantine/dead-letter, freshness/schema-drift SLAs,
  599. window/pivot analytics, entity resolution. Deliberately out of scope
  600. (single-operator identity): multi-tenant MLS, distributed compute, streaming
  601. CDC, connector catalogs. Next: ontology Actions (audited write-back) and
  602. dataset branches.
  603. - 🚧 **Phase 6** — Workflows: a node-graph automation layer over the same live
  604. feeds and ontology. 20 blocks — sources (aircraft, vessels, quakes, alerts,
  605. datasets, ontology, countries), transforms (`op.python`/`op.sql`/`op.llm`
  606. sandboxed subprocesses, `op.geo`, `op.http`, `op.steps`), sinks (alert,
  607. ontology, dataset, persistent memory), and **external-actuation control
  608. blocks** that reach out of the platform: `control.webhook` to any server, and
  609. `control.drone`/`control.device` to command a UAV or hardware via a JSON
  610. envelope. A first-class **MAVLink bridge** (`app.mavlink_bridge`,
  611. ArduPilot/PX4, log-only without a vehicle so you can rehearse) ships in-repo.
  612. See [`docs/workflows-control-blocks.md`](./docs/workflows-control-blocks.md).
  613. See [`docs/`](./docs) for the per-feature design notes and pipeline writeups.
  614. ## License
  615. [AGPL-3.0-or-later](./LICENSE) covers Velocity's **source code**. Upstream **data
  616. carries its own licenses**; several feeds are non-commercial / academic (e.g.
  617. ACLED, adsb.fi, OpenSky). See [`NOTICE`](./NOTICE) for per-source attribution and
  618. terms, and verify each upstream's current terms before any commercial or
  619. redistributive use.
  620. No warranty, and no liability for how you collect or use the data — see
  621. [`DISCLAIMER.md`](./DISCLAIMER.md), which also covers scraping, upstream terms,
  622. personal data, and prohibited uses.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.