andrey-core 0.2.0

Andrey is a causal discovery package for Python.

• Fast: Over 100x faster on PC, and faster on most other supported methods.
• Just as accurate: the same errors or fewer in 38 of 42 comparisons with other packages.
• One API: 21 methods, each one function call.
• Agent-ready: a command line that answers in JSON, and a skill for coding agents.

uv add andrey-core

• With pip: pip install andrey-core
• Optional extras: andrey-core[numba] for compiled CPU code, andrey-core[torch] for GPUs
• Development version: uv add git+https://github.com/Abel-ai-lab/andrey
• Installation guide: the extras, a PyTorch build for your GPU, and building Andrey from source

Benchmark report

Four ideas make it fast; each is animated in a blog post:

• Do many things at once: thousands of independence tests run as one array operation, with the same results.
• Never compute twice: the correlation matrix is computed once and cached; GES memoizes its local scores.
• Skip what can't matter: tests with a closed form settle most edges before any matrix is inverted.
• Use the hardware you have: with the optional extras, Numba compiles GES's path checks and a GPU computes large tables.

What's inside

* Experimental: no published benchmark yet, and the API may change.

Quick start

Learn the protein-signalling network of Sachs et al. (2005) from 853 cells, and score it against the known network:

import andrey
from andrey.data import load_dataset
from andrey.metrics import score

sachs = load_dataset("sachs")  # 853 cells, 11 proteins, and the known network
out = andrey.pc(sachs.data)    # learn a graph
print(out)

scores = score(out.structure, sachs.graph)
print({k: round(scores[k], 2) for k in ("shd", "skeleton_precision", "skeleton_recall")})

PC  cpdag  |  11 nodes  |  8 edges (6 undirected, 2 directed)

  raf -- mek
  plc -- pip3
  pip2 -- pip3
  erk -- akt
  erk -- pka
  akt -- pka
  p38 -> pkc
  jnk -> pkc
{'shd': 11, 'skeleton_precision': 1.0, 'skeleton_recall': 0.47}

PC finds 8 edges, all among the known network's 17. The structural Hamming distance (SHD) counts the edges to add, remove, or reorient to reach the known network: 11 here (9 edges are missing, and 2 are oriented that the known network leaves undirected), and 17 for a graph with no edges.

For your own data, pass a pandas DataFrame or a NumPy array: one row per sample, one column per variable. From a shell or an agent:

andrey run pc --data your_data.csv   # JSON when piped, a summary in a terminal
andrey --skill                       # a guide an agent loads as a skill

Learn more

• Documentation: guides and the API reference.
• Examples: notebooks, one method or task each.
• Demos: step through methods and explore results in your browser.
• Benchmarks: every size, time, and error count.
• Launch post, FAQ, and changelog.
• Roadmap: the planned work, in order.

Andrey is in alpha: the API may change between releases, so pin the version you use. Linux is fully tested; macOS and Windows install and run on the CPU, but the full test suite and the GPU speedups (CUDA / MPS) are not tested there yet.

Citing, license, contributing

If you use Andrey in your work, please cite it, or use the citation file:

@software{andrey,
  author = {{Abel AI Lab}},
  title = {Andrey: A very fast causal discovery package},
  year = {2026},
  version = {0.2.0},
  url = {https://andrey.abel.ai},
}

Andrey is released under the Apache License 2.0. Bug reports and pull requests are welcome in the issue tracker; the contributing guide explains how to set up a development environment.

Andrey is inspired by causal-learn, pgmpy, Tetrad, and many other causal discovery packages.