Platform

The OmiCairn platform

OmiCairn’s first version, released under its previous name RAGOmics, was an interactive web platform for omics analysis. It is now fully deprecated and retired. Users dragged datasets and function blocks onto a canvas, joined them into an analysis tree, ran every node in its own container, and inspected the results in a visualization panel with an AI assistant at hand. The analysis tree of function blocks is still its core. What later versions added is accountability: pre-registered plans, deterministic cross-checks, a claim-review agent and reviewer agents.

How it evolved See the first version

Analysis panel of the first version: a list of public datasets on the left; in the center an analysis tree of function-block nodes, most with green Run Completed headers and one red Runtime Error node; on the right an AI interpretation of a Louvain clustering node. — **The analysis panel, first version.** Datasets on the left; an analysis tree of function-block nodes in the middle (green: completed, red: failed); on the right, the assistant’s interpretation of the selected clustering node. Select the image to enlarge it.

Lineage

Four stages, one unit of work

Each stage kept the analysis tree of containerized function blocks and changed who drives it: a person at a canvas, then agents on one machine, then agents on a hosted platform, then a pipeline that has to justify every claim it makes.

1
First versionRetired

OmiCairn v1 (as RAGOmics)

An interactive web platform for omics analysis. Users built analysis trees of function blocks on a canvas, ran each node in its own container, explored results in a visualization panel and asked an AI assistant for help.
- Analysis tree of function blocks
- Visualization panel for single-cell and spatial data
- Assistant for parameters, errors and interpretation
Retired. Source code released in OmiCairn-engineering (stage 3)
2
Research prototype

OmiCairn-early

A local agent. Language-model agents turn a request in plain English into an analysis tree, write each function block, run it in a Docker container, debug it over several turns and review its output.
- Orchestrator plans the tree
- Multi-turn bug fixing in the container
- Job review with automatic rework
github.com/dummyindex/OmiCairn-early
3
Engineered web platform

OmiCairn-engineering

The multi-user web platform: an analysis-graph editor, data management, a visual panel and an AI assistant, with a backend, a computation worker that dispatches containerized jobs, and a runner for autonomous per-node agents.
- Web interface, backend and worker
- Jobs on local Docker or cloud batch
- LLM bug fixer and workflow generation
github.com/dummyindex/OmiCairn-engineering
4
Accountable research pipelineUsed for the campaign

OmiCairn

A question goes in, not a pipeline. Agents scope the question, pre-register the analysis plan and decision rules, execute it, cross-check every reported number against the code that produced it, and review whether the evidence answers the question.
- Pre-registration and deterministic cross-check
- Claim-review agent and reviewer agents
- Experience replay across runs; experts can steer
github.com/dummyindex/OmiCairn

The unit that carried over

Function blockCode (Python, R or shell), its dependencies and container image, typed arguments, documentation
instantiate
NodeThe block with parameters and configuration, run in its own container, with results and logs
compose
Analysis treeNodes joined by data dependencies; each node can be inspected, rerun or extended

First version

Analysis trees of function blocks, each block instantiated as a node.
Containerized execution, with code, parameters, logs and outputs kept per node.
Interactive visualization of results in a visual panel.
A person drives: builds the tree, sets parameters, decides what runs next.
Assisted debugging of failed nodes.

Today

A question as input; agents scope it and plan the tree.
Pre-registration of hypotheses and decision rules before any analysis runs.
Deterministic cross-check: every reported number resolves to executed outputs.
A claim-review agent and reviewer agents check the report against the evidence.
Experience replay of validated blocks and fixes; experts can still steer.

How OmiCairn works today

Gallery

The first version, screen by screen

Seventeen screenshots and three short clips from the first version’s user guide, grouped by task.

Retired

RAGOmics is completely retired. Its source code is released in OmiCairn-engineering.

The first version shown in this gallery is fully deprecated. Its human-engineered web platform has been replaced by our latest OmiCairn-based web platform, and its source code is public for transparency.

Source code: OmiCairn-engineering ↗

The interface is bilingual, so some screens are in Chinese. Select a screenshot to enlarge it; clips play muted while in view, unless reduced motion is on.

Build the analysis tree

Datasets and function blocks are dragged onto a canvas and wired together. Each connected block becomes a node that runs on its own, and the whole graph is the analysis tree.

Zoomed-out analysis canvas with many rows of small green node cards, some with chart thumbnails, and a toolbar reading Manual Analysis 214, Failed 9, Success 195. — A large analysis treeOne analysis task with 214 nodes, zoomed out to 24%. Green headers are completed nodes; plotting nodes show their charts inline. The toolbar counts running, failed, successful and pending nodes.

Annotated screenshot: a blue data node connected to a row of green analysis nodes, with labels for Data Node, Analysis Node, Pipeline, Run Tree, Run Node and Modify Parameter, and a histogram opened from one node. — Anatomy of the canvasA data node feeds analysis nodes, each an instance of a function block. The user guide marks the controls: run the whole tree, run one node, modify parameters, and open a node’s chart in the visualization panel.

Node Code dialog with a dark code editor showing a Python class with compute and prehandle methods, a JSON parameter configuration below, and an empty requirements panel. — Inside a function blockEvery node exposes its code: a Python implementation, a static configuration that declares typed, documented parameters, and its requirements. This block contract carried over into OmiCairn.

Function-block sidebar with categories such as Plot, Basic Statistics and Quality Control; a block is being dragged onto the canvas, where it becomes a Ready to run node. Annotations are in Chinese. — The function-block libraryChinese interfaceBlocks are grouped by category, searchable and documented; dragging one onto the canvas creates a node. The annotations in this user-guide image are in Chinese; the interface is bilingual.

Close-up of the canvas at 105% zoom: a blue zebrafish data node connected by dashed lines to green Run Completed nodes (sc_filter_genes) and red Runtime Error nodes (dotplot, pathways). — Branches and failures, up closeOne dataset feeds several branches. Completed nodes stay green; failed ones turn red and wait for a fix, while the rest of the tree keeps its results.

Four node cards side by side with headers Ready to run (white), Running (grey), Run complete (green) and Runtime error (red). — Four node statesThe color of a node’s header is its state: ready to run, running, run complete, or runtime error.

Assembling a pipelineScreen recordingA public dataset and a preprocessing block are dragged onto the canvas and connected. 15-second clip.

Inspect results visually

Any completed node opens in a visualization panel built for single-cell and spatial data: embeddings, cell metadata, gene lists, cell sets and annotations.

Visualization panel with a list of observations on the left, a UMAP scatter plot colored by six samples in the center, and cell-set controls on the right. — The visualization panelCell metadata on the left, the embedding in the middle, cell sets and annotations on the right. Here a UMAP is colored by sample.

UMAP scatter plot with a curved trajectory of cells colored by eight pancreatic cell types, with the panel controls around it. — Cell types on a UMAPPancreatic endocrinogenesis data colored by cell type: ductal, Ngn3-low and Ngn3-high endocrine progenitors, pre-endocrine, alpha, beta, delta and epsilon cells.

Analysis canvas with two completed nodes on the left and, on the right, a visualization preview of an embedding overlaid with velocity streamlines. — Preview beside the treeSelecting a completed node previews its chart next to the canvas; here a streamline plot from an RNA-velocity block.

Three-dimensional scatter plot of cells in purple, teal and orange with a dimension menu offering pca and umap. — Three dimensionsThe same data in three dimensions, with the basis (PCA or UMAP) chosen from a menu.

UMAP colored by many clusters, with a Save button highlighted in the cell-set panel on the right. — Manual annotationCells are lasso-selected on the embedding and saved as a cell set or a new cell-type annotation.

Coloring and highlighting cellsScreen recordingCells are colored by cell type, the palette is changed, and single cell types are highlighted on a PCA embedding. 25-second clip.

Work with the assistant

A language-model assistant sat beside the canvas. It explained results, diagnosed failed nodes, and filled in parameters. The user decided what to run.

Interpreting a nodeScreen recordingAfter a PCA node completes, the assistant explains what the block did, what its output contains and what could come next, using the pipeline as context. 26-second clip.