🤖 machine learning

CellScientist: Dual-Space Hierarchical Orchestration for Closed-Loop Refinement of Virtual Cell Models

CellScientist is a dual-space hierarchical framework that enables closed-loop refinement of virtual cell models by systematically routing execution discrepancies between high-level hypothesis and low-level implementation spaces to generate targeted, auditable model revisions rather than simple code fixes.

Original authors: Mengran Li, Bo Li, Jiaying Wang, Wenbin Xing, Yixuan Dong, Chengyang Zhang, Hongliang Zhang, Yuzhong Peng, Jinlin Wu, Bob Zhang, Bingo Wing-Kuen Ling, Fuji Yang, Zhen Lei, Jiebo Luo, Zelin Zang

Published 2026-05-11

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Mengran Li, Bo Li, Jiaying Wang, Wenbin Xing, Yixuan Dong, Chengyang Zhang, Hongliang Zhang, Yuzhong Peng, Jinlin Wu, Bob Zhang, Bingo Wing-Kuen Ling, Fuji Yang, Zhen Lei, Jiebo Luo, Zelin Zang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a very smart, but slightly chaotic, apprentice how to build a model of a living cell. This model needs to predict what happens to the cell when you give it a drug or change its genes.

In the past, if the model made a mistake, the apprentice would just look at the broken code, fix the syntax error, and try again. But often, the code was fine; the idea behind the code was wrong. The apprentice would keep fixing the same wrong idea over and over, never realizing the core concept was flawed.

CellScientist is a new framework that changes how we teach this apprentice. Instead of just fixing code, it acts like a dual-space architect and quality inspector.

Here is how it works, using simple analogies:

1. The Two Workspaces (Dual-Space)

Think of the process as happening in two separate rooms:

Room A: The Blueprint Room (Hypothesis Space). Here, the AI writes down the ideas and assumptions. "Let's assume the drug works by changing the cell's shape," or "Let's assume the drug works by changing its internal chemistry." These are the high-level plans.
Room B: The Construction Site (Implementation Space). Here, the AI turns those blueprints into actual, working computer code (programs) that can run on a computer.

The Problem: Usually, if the building (the code) collapses, the builder just patches the bricks. They don't realize the blueprint was drawn upside down.
The CellScientist Solution: It keeps the two rooms connected. If the building fails, it doesn't just patch the bricks; it sends a specific message back to the Blueprint Room to redraw the plan.

2. The Three-Step Dance (The Loop)

The system runs in a continuous loop, like a chef tasting a soup and adjusting the recipe:

Hypothesis (The Recipe): The AI writes a recipe (a hypothesis) for how the cell works.
Implementation (Cooking): It tries to cook the soup (write the code) following strict rules so the kitchen doesn't catch fire (the code must be valid and safe).
Refinement (Tasting & Adjusting): It tastes the soup (runs the test).
- If it tastes bad, the system asks: "Is the recipe wrong? Or did I just chop the onions too big?"
- The Magic: It uses a special map (called HRT) to pinpoint exactly which part of the recipe caused the bad taste. Did we forget the salt (a modeling assumption)? Or did we use the wrong pot (a coding error)?
- It then sends a targeted message back to the Blueprint Room to fix only that specific part, rather than throwing away the whole recipe.

3. The "Audit Trail" (Why it's special)

Most AI systems are like black boxes: they try things, fail, and you only see the final result.
CellScientist is like a transparent glass kitchen. It keeps a detailed log of every single attempt:

"We tried Recipe A. It failed because the heat was too high."
"We tried Recipe B. It worked better, but the texture was wrong."
"We finally settled on Recipe C."

This means scientists can look at the log and see exactly why the AI made the choices it did. It turns "debugging" (fixing broken code) into "scientific discovery" (understanding why an idea didn't work).

4. The Results (What the paper claims)

The authors tested this system on three different types of "cell modeling" challenges:

Cell Painting: Looking at photos of cells to see how they change shape.
Transcriptomics: Measuring how genes turn on and off.
Single-Cell: Looking at individual cells rather than a crowd.

The Claim: In all these tests, the models built by CellScientist were better at predicting cell behavior than models built by:

Standard human-designed models.
Other AI agents that just try random things.
Automated search tools.

Crucially, the paper claims that CellScientist didn't just get lucky with one specific dataset. It worked well across different types of data and different ways of splitting the data, proving it is a robust way to build these virtual cell models.

Summary Analogy

Imagine you are trying to navigate a maze.

Old Way: You hit a wall, turn around, and try a different path immediately. You might hit the same wall again because you didn't realize the map was wrong.
CellScientist Way: You hit a wall. You stop, look at your map, realize the map says "Wall is here" but the map is drawn upside down. You flip the map (fix the hypothesis), draw a new path, and then walk again. You keep a notebook of every wrong turn so you never make the same mistake twice.

The paper concludes that by separating the idea from the code and linking them tightly, CellScientist creates a smarter, more reliable way to build virtual models of life.

Technical Summary: CellScientist

Problem Statement
Virtual Cell Modeling (VCM) aims to predict cellular responses to perturbations (e.g., drugs, genetic interventions) using data such as Cell Painting morphology profiles and L1000 transcriptomic responses. A critical bottleneck in current Large Language Model (LLM)-assisted modeling workflows is the "refinement-routing problem." When a model's prediction fails, the discrepancy is observed at the executable code level, but the root cause may lie in higher-level modeling assumptions, representation designs, or task constraints. Existing workflows often follow a linear "generation–execution–repair" paradigm where feedback is treated as an undifferentiated signal for code debugging. This approach fails to propagate feedback across abstraction levels, leading to situations where code is repaired while the underlying hypothesis responsible for the discrepancy remains unaddressed. Furthermore, without structured feedback propagation, iterative refinement risks fixing implementation details while violating task constraints or drifting from the intended biological hypothesis.

Methodology: CellScientist Framework
The authors propose CellScientist, a dual-space hierarchical orchestration framework designed to close the loop between hypothesis formulation and executable implementation. The framework operates through a "Hypothesis → Implementation → Hypothesis" cycle, structured around three core components:

HRT (Hierarchical Reasoning Topology):
- This component structures the editable design space as a dynamic typed hypergraph ( $G_t$ ).
- Nodes represent specific modeling decisions (e.g., perturbation representation, fusion strategies, objective functions), while typed hyperedges encode coupled dependencies between these decisions.
- HRT enforces structural admissibility rules (e.g., data flow acyclicity, leakage prevention) and uses a bounded routing degree ( $d$ ) to limit the neighborhood of decisions affected by a specific feedback signal. This allows the system to localize failures to specific design neighborhoods rather than restarting the entire workflow.
LCA (Logic-Constrained Alignment):
- LCA acts as the bridge between the high-level hypothesis space ( $\mathcal{H}$ ) and the low-level implementation space ( $\mathcal{I}$ ).
- It realizes a hypothesis $h$ as an admissible executable program ( $c$ ) by enforcing a set of constraints ( $\Omega_{const}$ ) derived from the task protocol (e.g., split definitions, metric requirements, interface signatures).
- The system performs constraint checking, local repair, or rejection of candidates to ensure that the generated code strictly adheres to the protected task semantics, preventing "metric–semantic gaps" where code runs but violates the experimental design.
PDR (Performance-Discrepancy Refinement):
- PDR converts execution outcomes and validation metrics into structured feedback signals ( $m_t$ ).
- It routes these signals to specific addresses ( $a_t$ ) within the HRT hypergraph (nodes or hyperedges) based on the nature of the discrepancy (e.g., identity preservation failure, batch leakage).
- The system then applies a local edit ( $\delta_t$ ) to the hypothesis state, updating the model design while preserving validated components outside the edited neighborhood.

The workflow maintains a run history ( $B_t$ ) and a module memory ( $M_t$ ) of reusable, validated implementation blocks, allowing the system to retain stable components while revising specific design choices.

Key Contributions

Formulation: The paper formulates LLM-assisted VCM refinement as a dual-space cross-level feedback-routing problem under protected task semantics, explicitly addressing the attribution gap between execution failures and modeling assumptions.
Framework: It instantiates this view with a hierarchical orchestration framework (CellScientist) that aligns executable implementations with structured hypothesis states via HRT, LCA, and PDR.
Evaluation: The authors evaluate CellScientist across morphology, transcriptomic, and single-cell perturbation benchmarks, demonstrating that the selected executable models improve over baselines while preserving auditable traces of the refinement process.

Experimental Results
The evaluation was conducted under fixed split and evaluation protocols to ensure comparability.

Morphology Benchmarks: On BBBC036, BBBC047, and CPG0016 datasets, the CS-model (the final executable model selected by CellScientist) outperformed fixed predictors (TabR, RealMLP, RF-TD), search-based baselines (FLAML, Random Search), and the agent-designed baseline CellForge. Improvements were observed in global metrics (MSE, PCC, R²) under both SMILES-based and plate-based splits.
Transcriptomic Benchmarks: On LINCS2020 L1000 data (Seven Cell Lines and Full Data settings), CS-model achieved superior performance in RMSE, PCC, and P@100 metrics compared to domain-specific baselines (DLEPS, DeepCE, CIGER, etc.).
Single-Cell Benchmarks: On Norman, Schiebinger, and Papalexi datasets, CS-model showed significant gains in PCC and PCCDE (differential expression-sensitive PCC) over CellForge.
Efficiency and Robustness: Ablation studies confirmed that the full controller (HRT + LCA + PDR) maximizes the trade-off between execution success rate, rule compliance, predictive quality, and runtime. The framework demonstrated robustness across different LLM backbones (e.g., Gemini 3 Pro, DeepSeek-R1, GPT-5.2) and prompt variations.

Significance and Claims
The paper claims that CellScientist transforms validation failures from unstructured debugging events into structured evidence for model refinement. By maintaining explicit hypothesis states and routing feedback to targeted local revisions, the framework enables a traceable, auditable refinement process.

Auditability: The system preserves rejected branches, regressive candidates, and constraint checks, providing a complete record of the design trajectory (e.g., the transition from FiLM-CVAE to Ref-RGAF in the BBBC047 case study).
Generalization: The results suggest that the constrained refinement workflow transfers across distinct cellular readouts (morphology to transcriptomics to single-cell), indicating that the framework addresses fundamental issues in model construction rather than overfitting to a specific dataset.
Modesty: The authors explicitly state that the case studies serve as audit trails rather than proof of autonomous scientific discovery or the identification of unique biological laws. The selected architectures (e.g., DD-MIA, Ref-RGAF) are presented as task-specific inductive biases supported by validation feedback, not as universally optimal solutions. The work focuses on the process of reliable, traceable model refinement rather than claiming the discovery of new biological mechanisms.