Aurora

Aurora

Glass-box quantitative intelligence. Local. Open. Cited.

Aurora is the verification cortex for serious quantitative work — for humans analyzing hard data, and for AI systems that can't afford to hallucinate.

Cloud LLMs guess. Aurora computes.

[⬇️ Download the desktop app](#%EF%B8%8F-download-the-desktop-app) · Run from source · Aurora Sentinel demos · See it in action · Aurora Copilot · Aurora Cortex (MCP + SDK) · Roadmap · FantasyLab.ai

---

⬇️ Download the desktop app

The easiest way to run Aurora — no Python, no terminal, no setup. Download the installer for your OS, double-click, and Aurora opens as a native app with the analysis backend bundled inside it.

→ Download the latest release

Pick the file that matches your OS (filenames carry the version, e.g. 0.2.0):

Aurora_aarch64.app.tar.gz is an auto-updater artifact, not a download —

use the .dmg on macOS. There is currently no Intel-Mac (x86_64) or Linux

AppImage build; Intel-Mac users can run from source.

On first launch Aurora bootstraps a small knowledge-bank seed, then runs fully offline — no API keys, no cloud, no telemetry. Drop a CSV on the window and watch it analyze. Aurora is local-first: your data never leaves your machine unless you explicitly share a single finding — see PRIVACY.md.

Heads up on the "Unknown Publisher" warning. Current releases are not yet

code-signed, so Windows SmartScreen may show *"Windows protected your PC"* and

macOS Gatekeeper may say *"unidentified developer."* This is expected for a

young open-source project. On Windows: More info → Run anyway. On macOS:

right-click the app → Open. Code-signing is on the roadmap.

Desktop app — tips & known quirks

A few things that are expected behavior, not bugs:

• First launch shows a welcome screen, not a run. That's intentional — a fresh start is clean. Drop a CSV (or click a demo card) to begin; your past runs are always available under Data → Bundles.
• Give the backend a few seconds on first launch. Aurora starts a local analysis server (127.0.0.1:8001) the first time you open it; the status dot reads "connecting…" for ~5–10 s before it goes live. If it lingers, the app is still warming up — it is not frozen.
• Big datasets take longer, and results land all at once. A large file can spend a while in *"analyzing…"*. When it finishes you'll see *"analysis complete"* and the views populate. If the Overview looks momentarily empty right after completion, give it a few seconds or click another tab and back — the assembled state is still being fetched, and it will fill in.
• Re-running the same file is instant. Identical data + settings reuse a cached analysis; the banner reads *"instant · cached."* That's a speed win, not a skipped run.
• Knowledge Bank starts small on a fresh install. The bundled app ships with a seed bank that grows over time; the large multi-thousand-entry bank you may see in screenshots is built up on a machine that's been ingesting data for a while. Citations still work against whatever is local.

Want to build it yourself or run from source? Keep reading.

---

⚡ Quickstart (60 seconds)

# 1. Clone + create a virtualenv

git clone https://github.com/FantasyLab-ai/aurora.git cd aurora python -m venv .venv

Windows:

.\.venv\Scripts\Activate.ps1

macOS / Linux:

source .venv/bin/activate

2. Install

pip install -r requirements.txt

3. Run the Studio

python studio_api.py

Open http://127.0.0.1:8000. Click ▶ Try a demo for an instant smoke test, or drop your own CSV / Parquet / JSON / XLSX.

First run will download a small knowledge-bank seed (~50 MB). After that, Aurora runs fully offline — no API keys, no cloud, no telemetry.

Optional extras (only if you need them):

pip install cryptography             # Ed25519 bundle signing

pip install mcp # MCP server for LLM agents (Claude Desktop, Cursor, etc.) pip install -r requirements-dev.txt # contributor / test extras

For the optional Vite + TypeScript frontend build (developers only), see § Optional frontend build.

---

🖥️ The desktop app

A native, installable app — frameless window, sidebar navigation, drag-and-drop any file onto it. Built with Tauri 2, with Aurora's full analysis backend bundled inside the installer, so it runs with zero setup: no Python, no venv, no terminal.

Most people should just [download it](#%EF%B8%8F-download-the-desktop-app).

The rest of this section is for developers who want to build it from

source or hack on the UI.

What it does

Build it from source / develop

The desktop app lives in desktop/. To build the installer yourself (PyInstaller backend + Tauri shell) or run the UI in hot-reload dev mode, see [`desktop/README.md`](desktop/README.md) — it covers the prerequisites (Node, Rust), the one-command launcher (launch.ps1), the installer build (build_installer.ps1), and the Windows Smart App Control caveat. A git tag vX.Y.Z push triggers the cross-platform release CI.

---

🚨 Aurora Sentinel — Decision Contracts in the room

Aurora ships a complete demo rig under demos/ that turns a Decision Contract trip into something tangible — a Discord ping, a Slack alert, an OBS overlay card, a smart-plug flipping in your room. Five "I gave my local AI X and watch what it caught" videos, all built on the same scaffolding.

Quickstart for the demos (after the install above):

# Generate the synthetic datasets one time:

python -m demos.datasets.falling_ball.generate python -m demos.datasets.server_metrics.generate

Install the demo contracts into Aurora's contracts dir:

cp demos/contracts/*.json ~/.aurora/decision_contracts/ # macOS / Linux copy demos\contracts\*.json $env:USERPROFILE\.aurora\decision_contracts\ # Windows

Configure your webhooks once (copy the template + paste your URLs):

cp demos/.env.demos.example demos/.env.demos # macOS / Linux copy demos\.env.demos.example demos\.env.demos # Windows

Run the relay (it reads .env.demos for Discord/Slack URLs):

python -m demos.relay.app

Full step-by-step recording walkthrough with OBS setup, contract installation, and a per-demo runbook lives at [`demos/README.md`](demos/README.md).

---

See Aurora in action

A real run on an environmental air-quality dataset — captured straight from a Studio session.

The run banner. Domain selector across the top (Research / Ops / Industrial / Finance / Medical / Economics / Sports / Logistics / Custom+) sets context. The Aurora Pulse line below states the run's status in plain English. The 0 fabricated chip is the contractual signal that every finding traces to a method.

The Studio. The Overview cube rotates through six analytical lenses (Overview, Anomalies, Regimes, Motifs, Forecast, Physics). Below it, the Intelligence row surfaces the top anomalies (20 critical), the forecast peak prediction, a what-if causal answer, and the discovered physics law — y = a·t² + b·t + c at RMSE 126.720 — all live and grounded in artifacts, not LLM guesses.

The moat: every sentence cites a source

"What This Means" reads like a research paragraph because it is one. Each claim is tagged with a seed:* citation — seed:diurnal_cycle , seed:mutual_information_kg , seed:causal_chain , seed:physics_match , seed:wavelet_morlet , seed:sindy — that links to the exact knowledge-bank entry backing it. The panel below lists all 12 entries Aurora actually retrieved, each with its real source: Newton (1701), French AP (1971), Pierson & Moskowitz (1964), NIST, NOAA NDBC, Torrence & Compo (1998). No invented citations. No invented numbers. No invented papers.