# Orion caps TensorFlow below 2.15 and calls its own PyPI status pre-alpha

> Orion is a MIT licensed library from Data to AI Lab at MIT for unsupervised time series anomaly detection, installed with one pip command. Its dependency list holds two frameworks below major versions, its extras are gated by Python version, and its leaderboard scores thirteen pipelines as win counts against ARIMA.

**sintel-dev/Orion** — Unsupervised time series anomaly detection library

- Repository: https://github.com/sintel-dev/Orion
- Website: https://sintel.dev/Orion/
- Stars: 1,372 · Forks: 208
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/sintel-dev-orion

## PyPI calls the distribution pre-alpha while the quickstart says pip install

The header badge links to a PyPI search filtered on Development Status 2, which is the pre-alpha slot. Three lines lower, the quickstart calls pip the easiest and recommended way to install Orion, with one command:

```bash
pip install orion-ml
```

That line pulls the latest stable release from PyPI. So the distribution channel's own metadata describes the project as pre-alpha while the project's own page tells you it is the recommended path, and nothing on this page reconciles the two.

The naming has a second wrinkle worth internalising. The distribution is `orion-ml`, the import root is `orion`, and the demo data helper lives under `orion.data`. Three different names for one project, and the only one you type in Python code is the shortest.

Everything else in the header points outward rather than inward: a Sintel website, documentation at sintel-dev.github.io, notebooks in the repository, a repository link, a LICENSE link, and a Slack workspace invite for announcements and discussion.

## The default install pins two frameworks below major versions

The install requirements are not a light list. Two machine learning frameworks are present, each with a ceiling:

```
tensorflow>=2.2,<2.15
numpy>=1.17.5,<2
pandas>=1,<3
numba>=0.48,<0.60
s3fs>=0.2.2,<0.5
mlblocks>=0.6.2,<0.7
ml-stars>=0.2.1.dev0,<0.4
scikit-learn>=0.22.1,<1.8
scipy<1.14
torch>=1.4,<2.6
protobuf<4
```

Three details in those ten lines decide whether an install succeeds on a current machine. TensorFlow is held below 2.15 and torch below 2.6, so pip resolves downwards and will happily downgrade an environment that already has newer versions. `protobuf<4` carries the comment fix conflict directly above it, so a known dependency clash is being held in place deliberately rather than resolved.

The floor is unusual too: ml-stars is pinned at `0.2.1.dev0`, a development release, so the lowest accepted version is one that was never a stable cut.

Two cloud dependencies come along by default as well, `s3fs` for S3 and the `azure-cognitiveservices-anomalydetector` client, on top of `stumpy`, `pyts`, `ncps` and `tabulate`. A default `pip install orion-ml` therefore arrives with two frameworks, two cloud SDKs and a wide scientific stack, whether or not your use of Orion needs any of them.

## The pretrained extra hides two dependencies behind a Python version marker

Pretrained models live in a separate requirements block, so they are opt-in:

```
timm
smart_open
"timesfm[torch]>=1.2.0,<1.5;python_version>='3.11'"
"jax;python_version>='3.11'"
chronos-forecasting>=2.2.0,<2.3.0
'wrapt>=1.14,<1.15'
```

Read the markers rather than the names. TimesFM and JAX are both conditioned on `python_version>='3.11'`, which means that on an older interpreter they are not installed at all, and the extra still installs successfully. The failure mode is silent by construction: a missing dependency here looks exactly like an extra you did not ask for.

The commented labels group them by role, one marker block for units and another for TimesFM, which tells you the block is maintained as a small catalogue rather than generated. `wrapt` is capped below 1.15 and chronos-forecasting is held in a narrow band above 2.2.0.

The base install does not share this structure. It lists `ncps` with no version at all, next to `numba>=0.48,<0.60`, which is the loosest and oldest pair of pins in the whole file.

## The leaderboard turns scores into thirteen win counts against ARIMA

The benchmark section says the library runs an Orion benchmark in every release, over 12 datasets that have known ground truth, and records the score of each pipeline on each dataset. The table that follows does not show those scores. It shows a single column, headed Outperforms ARIMA, holding a count of wins per pipeline.

Thirteen pipelines are listed for those twelve datasets. AER is at 12, which is every dataset. LSTM Dynamic Thresholding is at 9. Five pipelines sit at 7, namely TadGAN, LSTM Autoencoder, Dense Autoencoder, LNN and TimesFM. UniTS and VAE are at 6, GANF and Matrix Profile at 5, AnomalyTransformer at 2, and Azure at 0.

Two structural observations. The metric discards magnitude, so a pipeline that wins a dataset by a wide margin and one that wins it by a hair count the same, and the page points to two Google Sheets documents for the per-dataset numbers rather than publishing them. And the reference point is one ARIMA baseline, which is a reasonable smoke test but not a strong one; the commercial detector scoring zero sits in the same table as the research code, which is the comparison most readers will quote.

## The quickstart tells you to ignore the warnings it expects

The detect step carries a note that deserves to be read twice. It says that depending on your system and the exact versions installed, some warnings may be printed, that they can be safely ignored, and that they do not interfere with the proper behaviour of the pipeline. Given the dependency ceilings in the install file, that is a realistic expectation rather than boilerplate.

The fit example is where the friction shows. Hyperparameters are addressed by a generated key:

```python
hyperparameters = {
    'orion.primitives.aer.AER#1': {
        'epochs': 5,
        'verbose': True
    }
}
```

The key names a primitive class, `aer`, an instance number, `AER#1`, and it has to match whatever the automl machinery produced. Change the spelling or the index and the setting lands nowhere. The library describes these as verified pipelines rather than fixed implementations, and this key is where that flexibility costs a user.

Detection itself takes only the new data. `orion.detect(new_data)` returns a pandas DataFrame with `start`, `end` and `severity` columns, and the demo output is one row: start 1402012800, end 1403870400, severity 0.122539. No threshold argument is exposed in this path, so what counts as anomalous is decided inside the fitted pipeline.

## The Makefile documents itself, and its help target is the default goal

Run `make` with no arguments in this repository and you get help, because the first line is `.DEFAULT_GOAL := help` and the help target pipes the Makefile through a small Python script that matches `target: ## description` lines. The documentation is therefore written into the Makefile itself, which is the pattern used across Data to AI Lab projects.

The targets are organised in four groups. Cleaning covers build artifacts (`build/`, `dist/`, `.eggs/`, stray egg-info and egg files), Python artifacts (`.pyc`, `.pyo`, editor backups and `__pycache__`), test artifacts (`.tox/`, `.pytest_cache`), coverage artifacts (`.coverage`, `htmlcov/`), and docs. Installing starts with a clean and runs `pip install .` into the active Python's site-packages, with a sibling target for the test install.

The docs clean line carries its own failure handling: the recursive make is prefixed with a dash and its output is discarded, with a comment saying it fails if Sphinx is not yet installed. That is deliberate, and it is the same philosophy as the warning note in the quickstart.

The root also holds `tox.ini`, `setup.cfg`, `tasks.py`, `MANIFEST.in`, `HISTORY.md`, `AUTHORS.rst`, `CONTRIBUTING.rst`, `BENCHMARK.md`, `DOCKER.md`, and the `orion/`, `benchmark/`, `docs/`, `docker/`, `tests/` and `tutorials/` directories.

## Version names carry a date, and the newest tag is older than the newest commit

Three releases are visible, and each one puts a date in its own title: v0.7.1 named for 2025-03-17, v0.7.0 for 2024-12-18, and v0.6.1 for 2024-10-04. Two of those match their publication date exactly. v0.7.1 was published on 2025-03-18, a day after the date in its name.

The gap that matters is between the newest tag and the working tree. The default branch is `master`, the most recent push is dated 2026-09-28, and the newest release is v0.7.1 from March 2025. Since the quickstart tells you that `pip install orion-ml` pulls the latest stable release, a default install gives you the dependency set as it stood in March 2025, which is not the set written in the install file at the tip of master. The CI badge is filtered on the master branch, so the tests that run are testing the branch, not the tag.

The repository is not archived and carries an MIT LICENSE. Nothing in these three facts resolves the version question, which is why the pipeline list in the benchmark is the part to trust over the tag number: a named pipeline is a named implementation, while a tag is only a point in time.

## Conclusion

Orion earns its place when you want a benchmarked set of pipelines instead of one hand-built detector, because the leaderboard tells you AER wins on all twelve datasets with ground truth while a commercial detector scores zero, and the demo path from load_signal to detect is three calls. Two things to weigh before you adopt it. The dependency set is dated in both directions: tensorflow below 2.15 and torch below 2.6 mean a modern environment gets downgraded on install, and the extras that bring TimesFM and JAX only appear on Python 3.11 and newer. And the version you get from PyPI is not the version at the tip of master, since the newest tag is v0.7.1 from March 2025 while commits continue. If you need a stable dependency floor for production, pin that release and read the warning note in the quickstart before deciding anything printed during fit is harmless.

## FAQ

### What is Orion from sintel-dev used for?

It is a machine learning library for unsupervised time series anomaly detection. Given a time series it provides a set of verified ML pipelines that identify rare patterns and flag them for expert review, built on automated machine learning tools developed at Data to AI Lab at MIT.

### How do I install Orion and which versions does it require?

The documented install is `pip install orion-ml`, which pulls the latest stable release from PyPi. The install requirements hold tensorflow at `>=2.2,<2.15` and torch at `>=1.4,<2.6`, pin `protobuf<4` with the comment fix conflict, and set the ml-stars floor at the development release `0.2.1.dev0`.

### Which pipelines appear on the Orion leaderboard?

Thirteen, scored over 12 datasets with ground truth by number of wins against an ARIMA pipeline. AER is at 12, LSTM Dynamic Thresholding at 9, five pipelines at 7, UniTS and VAE at 6, GANF and Matrix Profile at 5, AnomalyTransformer at 2 and Azure at 0. Per-dataset scores are kept in two linked Google Sheets documents.

### How does Orion report the anomalies it detects?

`orion.detect(new_data)` returns a pandas DataFrame with `start`, `end` and `severity` columns, and the quickstart output shows a single row with start 1402012800, end 1403870400 and severity 0.122539. The call takes the new data only, with no threshold argument in that path.

### Which Orion extra installs TimesFM and JAX?

The pretrained block carries `timesfm[torch]>=1.2.0,<1.5` and `jax`, and both are conditioned on `python_version>='3.11'`. On an older interpreter those two dependencies are skipped and the extra still installs, so a missing model backend looks like an extra that was never requested.

### Where can I read more about evaluating Orion pipelines?

The page points at BENCHMARK.md for benchmarking pipelines, `orion/evaluation/README.md` for pipeline evaluation, a three part blog series on the NYC taxi dataset covering anomaly detection, GANs and evaluation, the notebooks under tutorials, and links for Colab and mybinder.

## Sources

- [License: MIT](https://github.com/sintel-dev/Orion/blob/master/LICENSE)
- [Project website](https://sintel.dev/Orion/)
- [README](https://github.com/sintel-dev/Orion/blob/master/README.md)
- [Releases](https://github.com/sintel-dev/Orion/releases)
- [sintel-dev/Orion on GitHub](https://github.com/sintel-dev/Orion)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/sintel-dev-orion