oryxflow: trustworthy, reproducible AI data analysis¶

Data analysis you can believe, and reproduce later — for humans and AI coding agents. oryxflow turns a data-science script into a pipeline where no result can quietly sit on stale data, and every result records the code and inputs that made it. Rigor like that normally costs you rerun time; here it doesn't, because nothing is ever computed twice. It's a Python library with no server, no database, and no account: pip install oryxflow and you're done.

Working with an AI agent? The Claude Code plugin teaches Claude Code to build your data analysis this way — so the agent checks its own reruns, can't train a model on stale data, and leaves a record of what produced every number. You get analysis you can trust, not just analysis that runs — and because the agent stops redoing work it has already done, you spend less time and fewer tokens getting there. Using a different agent? The docs are machine-readable too — point it at llms-full.txt and it has read all of oryxflow in one request.

Why oryxflow: trustworthy, reproducible data science¶

Four things you get on day one — the full argument is in Why oryxflow:

• No result is ever built on stale data. Change a parameter, the data, or a task's code and oryxflow reruns exactly what that change affects. You can't accidentally evaluate a new model on stale features.
• An answer to "how was this made?" oryxflow records what ran, when, with which code and inputs, and why it recomputed — so provenance and staleness are queries rather than guesses, and any result can be regenerated later.
• No file mess, no parameter bookkeeping. You never name, path, or version an intermediate file again — no features_v3_final.pkl, no to_pickle/read_pickle plumbing, no spreadsheet of which run used which settings. Ask for a result by the task and parameters that made it.
• And it's faster, not slower. Being this careful usually means waiting. Here finished steps load from cache, so the 10-minute data pull runs once, not once per edit.

Start small; it scales with you. A first pass can be a plain script or a quick exploratory probe — you don't need a task graph on day one. As the work gains steps, cost, and parameter combinations (as it always does), the plugin's /oryxflow:migrate command lifts what you already wrote into cached tasks. No rewrite, and no cliff between "exploring" and "pipeline" — migrate a messy project.

oryxflow in brief¶

You declare each step of your analysis as a task: what it depends on and what it produces. The engine runs them in dependency order, skips anything already computed, and hands you any result by name.

import oryxflow
import pandas as pd

class GetData(oryxflow.tasks.TaskPqPandas):        # output saved as parquet
    def run(self):
        self.save(pd.DataFrame({'x': range(10)}))

@oryxflow.requires(GetData)                        # declare the dependency
class ProcessData(oryxflow.tasks.TaskPqPandas):
    def run(self):
        df = self.inputLoad()                      # GetData's output, already loaded
        df['x2'] = df['x'] ** 2
        self.save(df)

flow = oryxflow.Workflow(ProcessData)
flow.run()                                         # runs GetData, then ProcessData
df = flow.outputLoad()                             # load the result by name

Edit ProcessData and only it reruns, so the result you print always matches the code you have now. Change nothing and run flow.run() again and nothing happens at all — both outputs already exist, so the engine skips them. That is why the rigor is free: trust and reproducibility are the product, and caching is just how you get them without paying for them twice. Next step: Quickstart — a real pipeline in a few minutes.

How oryxflow compares to Airflow, MLflow, DVC, and notebooks¶

oryxflow doesn't replace an experiment tracker or a production orchestrator — it fills the gap between an ad-hoc script and a heavyweight platform, and composes with both. What's distinctive is the combination of local-first simplicity, invalidation that notices a code change, and always-on lineage.

The per-tool detail is in Why oryxflow, and the head-to-heads are on the blog: vs Airflow, vs MLflow, vs DVC, vs Dagster, vs Prefect, and the whole field.

Where to next¶

Frequently asked questions¶

How do I stop rerunning my whole pipeline every time I change one step? oryxflow caches each step's output and reruns only what a code, data, or parameter change affects, plus everything downstream of it. Change one feature and the untouched upstream steps load instantly from cache instead of recomputing. It's a local-first Python library: pip install oryxflow, declare each step as a task, and re-running only pays for what actually changed.

How do I cache intermediate DataFrames in Python without brittle pickle files? Declare each step as an oryxflow task that saves its DataFrame, and the engine caches it, addresses it by task identity instead of a hand-managed filename, and reloads it on the next run. You never wire up to_pickle / read_pickle paths or track which file is current — you ask for a result by the task that made it, and stale outputs rerun automatically when the code changes.

Is there a lightweight alternative to Airflow or MLflow for a local data science project? oryxflow is a local-first Python workflow library that sits between notebooks and heavyweight orchestrators — no server, scheduler, database, or account. Where Airflow orchestrates production DAGs and MLflow tracks experiments, oryxflow makes one analyst's pipeline reproducible and cached: it reruns only what changed and records what produced each result. Reach for it when a notebook has outgrown itself but Airflow or MLflow would be overkill.

How do I run a parameter sweep without rerunning the upstream steps every time? Parameters flow through the task graph, so oryxflow reruns only the tasks a given parameter actually changes and reuses the shared upstream cache across every combination in the sweep. Compare ten model configs and the data-loading and feature steps run once, not ten times. Each run is tagged by its parameters, so results stay reproducible and you can load any combination's output by name.

Is there a Claude Code plugin to make AI-generated data analysis reproducible and trustworthy? Yes — the oryxflow Claude Code plugin. It teaches your coding agent to build the analysis as a reproducible pipeline: verifying its own reruns, never training on stale intermediates, and recording what produced every result. oryxflow guarantees a result was produced by the code and inputs it recorded — reproducible, not automatically correct — so you can check AI-written analysis instead of trusting it blindly. Because finished work is reused rather than recomputed, none of that costs you extra time or tokens. It ships as a skill plus slash commands, not an MCP server.

When should I not use oryxflow? You don't need a task graph for a first look at a dataset — a quick CSV load, a group-by, one plot is fine as a plain script. You don't have to choose upfront, though: start there and run /oryxflow:migrate when the work gains depth, cost, or parameter combinations, and what you already wrote becomes cached tasks. oryxflow earns its keep the moment a stale early step can silently corrupt everything below it, an expensive step makes the edit-run loop painful, or you're sweeping an experiment matrix — which is also where hand-managed scripts and AI coding agents go wrong. It isn't a production orchestrator (use Airflow or Prefect) or an experiment dashboard (use MLflow or Weights & Biases); it composes beside both.

Learn more¶

• Scaffold a real project: /oryxflow:init-project in Claude Code
• Why this matters: 4 reasons your machine learning code is probably bad
• API details: API Reference
• Source & issues: oryxintel/oryxflow on GitHub