Aurora, a local statistics engine
Drop in a dataset. Aurora runs real statistical methods on your own machine, cites every finding, and when a method can't run, it tells you why instead of faking a result.
Anomaly in precip_mm at row 47
precip_mm |z| = 10.9, temperature_c |z| = 0.5, surfaced for review.
A finding card from the desktop app, redrawn. Tally: the factory bearing demo, about 10 s on a laptop.
For analysts, engineers, scientists and quants who want real statistics on their data, and for AI builders who want their agents to compute instead of guess.
Real methods produce the numbers: anomaly detection, regimes, forecasting, physics-law discovery. No language model is asked for its best guess at a z-score.
Each one names the method and threshold behind it and links its source. The write-up carries a "0 fabricated" check.
Same data and settings give the same result, with a trace of exactly which method produced it.
"semantically identical questions return different numbers."
Overheard on r/dataengineering
What happens between the two, in five steps. These are the app's real screens. The orb acts them out as you scroll.
CSV, Parquet, JSON or XLSX. Aurora profiles the time axis, gaps and duplicates, then runs only the methods that are valid for that shape. You don't pick methods.
Anomalies are flagged by consensus, so one jumpy detector can't raise an alarm alone. In a 5,000-row test, 325 points cleared that bar. Regimes come from a hidden Markov model, change points from PELT, and forecasters compete on a held-out fold.
Each finding carries its method, threshold, claim id and reference. The local model only rewords knowledge it retrieved, and a verifier checks each sentence against its source and flags anything that doesn't trace back.
A method that can't run is skipped with a stated reason, never quietly faked. From a real run:
Gaussian process analysis exceeded the 90-second per-method time budget on this dataset and was deferred.run narrative, climate_buoy_demo.csv
Every run exports a portable .aurora.json bundle with a SHA-256 content hash and an optional Ed25519 signature. Load it on another machine and it verifies, or it raises if anything was changed.
import aurora_sdk as aurora
r = aurora.run("data.csv", depth="standard")
r.bundle.save("audit.aurora.json") # SHA-256 + optional Ed25519
b = aurora.Bundle.load("audit.aurora.json")
b.verify() # raises if tamperedReal runs, timed locally. The datasets ship with Aurora or are public, so you can rerun them.
| Run | Result | Time |
|---|---|---|
| Factory bearing demo | 11 cited findings, 3 critical | ~10 s |
| Air quality, 9,357 rows | 12 cited knowledge entries, 0 fabricated | ~14 s |
| 5,000-row outlier test | 325 points flagged by two or more detectors | |
| Rediscover the Law | derives y = ½·a·t² from a video of a falling ball, with SINDy |
Every lens is built from named methods you can inspect. Plain English on top, the math one click down.
The shape of your data, what ran, what was skipped, and the headline results.
Flagged when two of three detectors agree: robust Mahalanobis, isolation forest, LOF.
Hidden Markov states with dwell times, plus PELT change points for when the system itself changed.
Repeating windows and discords from the matrix profile, plus persistent homology.
AR(1), kNN-window and exponential smoothing compete on a held-out fold. The winner is named, with its interval.
SINDy fits sparse governing equations and checks them against known laws.
One command fetches aurora-mcp from PyPI for Claude Desktop, Claude Code, Cursor or any MCP client. It's also in the official MCP Registry as io.github.FantasyLab-ai/aurora.
uvx aurora-mcp --list-toolsadd to your agent config
{
"mcpServers": {
"aurora": {
"command": "uvx",
"args": ["aurora-mcp", "--allow-root", "/path/to/your/data"]
}
}
}the 7 tools
They only read paths you allow, cap their output and return JSON.
aurora_analyzeRun the analysis on a CSV, TSV, Parquet or XLSX file and return cited findings.aurora_findingsList findings with severity, the exact method and threshold, and a claim id.aurora_explainThe receipt for one finding: computed values, assumptions, references.aurora_forecastA forecast fitted on the data, with the method disclosed.aurora_simulateStep the system forward. It pauses when intervals get too wide.aurora_interveneWhat-if: perturb one variable and propagate it through the discovered model.aurora_load_bundleLoad a shared .aurora.json and verify it before trusting it.The desktop app isn't code-signed yet, so Windows SmartScreen and macOS Gatekeeper will warn on first launch.
On Windows: More info, then Run anyway. On macOS: right-click the app, then Open.
The hosted knowledge-base packs aren't published yet.
The installer if you'd rather not touch a terminal. The source if you'd rather read it first. The agent route is above.
Download the installer for your OS, double-click, and drop a CSV on the window. The analysis engine is bundled inside.
Run the Studio locally, then open http://127.0.0.1:8000 and try a demo or drop your own CSV, Parquet, JSON or XLSX.
git clone https://github.com/FantasyLab-ai/aurora.git
cd aurora
python -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install -r requirements.txt
python studio_api.pypip install cryptography # Ed25519 bundle signing
pip install mcp # MCP server for LLM agentsWhat the methods found, what they refused to conclude, and the command to rerun it yourself.
2026-07-29 · 8 min readA climate buoy dataset, 20 cited findings, and a Gaussian process regression that hit its 90 second budget, gave up, and said so.
Read the experimentShared straight from the app. There's no telemetry, so this feed is the only way we know anyone's using it.
live from aurora-community.fantasy-labai.workers.dev/feed
Free and open source. Try the demo in your browser first if you'd like.
Star it on GitHub · Patreon keeps it free · Watch the build · contact@fantasylab.tech
