Pipette: Encoding scientific literature into an executable Skill Graph for multi-agent bioinformatics

Pipette is a multi-agent AI framework that leverages a literature-derived Skill Graph to guide natural language-driven generation of biologically valid, reproducible, and end-to-end bioinformatics workflows, effectively lowering the computational expertise barrier for genomic data analysis.

The Gist

Imagine you have a massive library containing every scientific paper ever written about biology. Now, imagine you want to solve a complex medical mystery, like figuring out why a specific drug works or finding a genetic cause for a disease. To do this, you need to read thousands of papers, understand the tools scientists use, and connect the dots between them to build a step-by-step plan.

For most regular scientists (the "bench biologists"), this is like trying to build a house without a blueprint, a toolbox, or knowing how to use a hammer. They have the data (the bricks), but they lack the computational expertise to build the house (the analysis).

Enter Pipette.

What is Pipette?

Think of Pipette as a super-smart, multi-person construction crew that you can talk to in plain English. You don't need to know how to code or use complex command lines. You just say, "Analyze this patient's DNA," or "Find out which genes are reacting to drought in rice," and Pipette does the rest.

But here's the catch: If you just ask a standard AI (like a basic chatbot) to do this, it might get creative in the wrong way. It might try to use a hammer to screw in a lightbulb, or mix chemicals that explode. It's great at writing sentences, but bad at following the strict, logical rules of science.

The Secret Sauce: The "Skill Graph"

This is where Pipette's magic happens. The creators built something called a Skill Graph.

Imagine the Skill Graph as a massive, interactive subway map of the entire world of biology.

• The Stations: Each station is a specific scientific task (like "cleaning data," "finding mutations," or "docking a drug").
• The Tracks: The tracks connecting the stations represent valid steps.
• The Rules: The map was drawn by reading over 20,000 scientific papers. It knows exactly which station you can go to next. For example, it knows you can't take the "Drug Design" train until you've stopped at the "Protein Structure" station.

If you try to tell Pipette to do something impossible (like analyzing a drug before you've even identified the protein it targets), the Skill Graph acts like a traffic cop. It stops the AI, says, "Whoa, that track doesn't exist," and guides it back to the correct path. This prevents the AI from "hallucinating" (making things up) and ensures the science is real.

How Pipette Works (The Crew)

Pipette isn't just one robot; it's a team of specialists working together:

1. The Copilot: This is the friendly voice you talk to. It understands your question and figures out what you need.
2. The Executor: This is the worker bee. It looks at the subway map (Skill Graph), picks the right tools, writes the code, and runs the analysis. If it hits a snag (like a broken tool), it doesn't panic; it finds a workaround, just like a human would.
3. The Reviewer: This is the strict quality control inspector. Before the results are shown to you, the Reviewer checks the work. "Did they use the right math?" "Is the graph labeled correctly?" If something is wrong, they send it back to the Executor to fix it.
4. The Reporter: Once the work is done, this agent writes a clear, easy-to-read report with pictures and explanations, so you don't have to read the raw data.

What Did They Test?

The team tested Pipette on four very different, difficult tasks to see if it could really handle the job:

• The "Cell City" (Single-Cell RNA): They asked Pipette to look at 68,000 individual blood cells and sort them into different types (like T-cells, B-cells, etc.). Pipette did it perfectly, matching the results of human experts.
• The "Rice Stress Test" (Bulk RNA): They asked it to figure out how rice plants react to heat and drought. Pipette not only found the same genes as the original study but also explained why they reacted that way.
• The "Drug Puzzle" (Molecular Docking): They asked Pipette to figure out how a cancer drug (Imatinib) fits into a protein lock. Pipette didn't just guess; it corrected its own mistakes when the software glitched and found the exact fit, down to the atomic level.
• The "Medical Detective" (Clinical Genomics): They gave it a patient's DNA and asked, "Is there a genetic disease here?" Pipette followed strict medical rules (ACMG guidelines), found the dangerous mutations, and even warned them about a missing chromosome, acting like a highly trained genetic counselor.

Why Does This Matter?

For years, there has been a huge gap between generating data (which is now cheap and easy) and understanding data (which is hard and expensive). Pipette bridges that gap.

It's like giving every biologist a personal research assistant who has read every paper in the library, knows every tool in the toolbox, and never gets tired. It allows scientists to focus on the questions and the biology, rather than getting stuck on the code and the computers.

In short, Pipette turns complex, scary computer science into a simple conversation, making the power of big data available to anyone with a question.

Technical Summary

1. Problem Statement

Despite the dramatic reduction in the cost of genomic sequencing, data analysis remains a bottleneck due to the high computational expertise required. Bench biologists often lack the command-line proficiency, statistical knowledge, and ability to chain multiple software tools into reproducible workflows.

• Limitations of Current LLMs: While Large Language Models (LLMs) can generate code, they frequently fail at orchestrating multi-step bioinformatics workflows. They lack explicit representations of domain-specific constraints (e.g., compatible data types, valid analytical transitions), leading to "hallucinated" or incoherent workflows where steps are logically incompatible.
• Gap in Existing Agents: Current bioinformatics agents (e.g., Biomni, AutoBA) often lack a unified framework that spans multiple sequencing modalities while ensuring methodological rigor, transparency, and reproducibility.

2. Methodology: The Pipette Framework

Pipette is a multi-agent AI framework designed to translate natural language queries into rigorous, reproducible bioinformatics workflows. It operates on a cloud infrastructure with two primary layers: a conversational interface and an orchestration engine.

A. The Core Innovation: The Skill Graph

The central component of Pipette is the Skill Graph, a directed, edge-weighted knowledge graph extracted from over 20,000 peer-reviewed publications (PubMed Central) and 800 manually curated notes.

• Structure: Nodes represent discrete analytical "skills" (e.g., read alignment, differential expression), and directed edges represent valid sequential transitions between them.
• Construction Pipeline:
  1. NER & Relation Extraction: Fine-tuned PubMedBERT models identify tools, operations, and data types (F1 = 0.91 for NER).
  2. Document-Level Ordering: Unlike standard sentence-level relation extraction (which achieved only 6.2% recall for pipeline edges), Pipette uses document-level positional ordering to extract workflow sequences, achieving 60.5% recall.
  3. Data Type Validation: Edges are filtered and validated based on input/output data type compatibility (using EDAM ontology). This step improves precision from 14.5% to 37.2% and allows for the inference of new, logically valid edges not explicitly co-observed in literature.
• Result: A graph of 91 skills across 9 biological domains with 483 directed edges (258 literature-backed, 225 type-inferred).

B. Multi-Agent Architecture

The framework employs a six-stage pipeline managed by specialized agents:

1. Copilot Agent: Interprets user intent and routes tasks.
2. Executor Agent: Operates in an iterative "Plan-Write-Execute-Observe" loop, utilizing the Skill Graph to navigate valid transitions, write code (Python/R/Bash), and handle errors.
3. Reviewer Agent: An independent auditor that checks the Executor's code and figures for statistical rigor, multiple testing corrections, and methodological validity. It can trigger a remediation loop if failures are detected.
4. Provenance Tracking: Automatically generates a machine-readable Directed Acyclic Graph (DAG) capturing software versions, parameters, seeds, and data lineage for full reproducibility.
5. Reporter Agent: Synthesizes quantitative findings into structured Markdown reports.
6. Hypothesis Agent: Contextualizes results against current literature (PubMed) to generate testable hypotheses.

3. Key Contributions

• Skill Graph Construction: Demonstrated that document-level extraction combined with data type inference recovers an order of magnitude more valid pipeline connections than traditional sentence-level relation extraction.
• Self-Correcting Architecture: Introduced a dual-agent system (Executor + Reviewer) that autonomously detects and fixes methodological errors (e.g., missing pH protonation in docking, incorrect RMSD calculations).
• Cross-Domain Orchestration: Successfully executed complex workflows spanning single-cell genomics, bulk RNA-seq, structure-based drug design, and clinical variant classification without manual code intervention.
• Reproducibility: Provided a fully machine-readable provenance record for every analysis, addressing a critical gap in computational biology.

4. Results & Benchmarks

Pipette was benchmarked across four domains using real-world datasets, comparing its performance against published ground truths and unguided LLMs (Claude Opus 4.5, GPT-5.4).

• Single-Cell RNA-seq (PBMC 68K & Pancreas):

  • Pipette achieved a Pearson correlation of r=0.959 with published cell type proportions for PBMCs and r=0.998 for the pancreas dataset.
  • It correctly identified major cell lineages and achieved high clustering agreement (ARI = 0.92, NMI = 0.89).
  • Ablation Study: Pipette (with Skill Graph) significantly outperformed unguided LLMs in marker gene recall and cell type proportion accuracy. Unguided models often used suboptimal clustering algorithms or missed rare cell populations.

• Bulk RNA-seq (Rice Stress Response):

  • Pipette correctly formulated a DESeq2 GLM with appropriate covariates (batch, segment).
  • It recapitulated published biological findings (e.g., heat shock being a stronger stimulus than drought).
  • While it identified slightly more DEGs (due to lack of LFC shrinkage in default settings), the log2 fold-change correlation with published results was exceptionally high (r = 0.976–0.991).

• Drug Design (Imatinib & Cyclic Peptides):

  • Imatinib/ABL1: The agent autonomously corrected a missing pH protonation step and a software parsing bug. It achieved a binding affinity of -11.8 kcal/mol and a heavy-atom RMSD of 0.89 Å against the crystal structure, successfully reproducing the binding mode.
  • Cyclic Peptides: Designed 10 cyclic peptides targeting p53-MDM2. The top candidate (CP07) achieved -12.1 kcal/mol binding affinity and sub-angstrom pharmacophore reproduction (0.95 Å RMSD). The system autonomously recovered from docking engine failures.

• Clinical Variant Classification (ACMG/AMP):

  • Pipette analyzed the GIAB HG002 reference genome against the ACMG Secondary Findings v3.2 panel.
  • It correctly identified 0 pathogenic variants in the healthy reference (as expected) and 100% sensitivity (7/7) on a spike-in benchmark of known pathogenic variants.
  • It correctly applied complex inheritance logic (e.g., compound heterozygosity for MUTYH) and generated clinically actionable management recommendations.

• Ablation Study (Skill Graph Impact):

  • Removing the Skill Graph led to significant performance drops. Unguided LLMs failed to select appropriate tools (e.g., using MiniBatchKMeans instead of graph-based clustering), omitted critical covariates in statistical models, and failed to execute multi-step cross-domain transitions (e.g., linking differential expression to drug target identification).

5. Significance

• Lowering the Barrier: Pipette democratizes access to complex bioinformatics, allowing bench scientists to execute standard genomic analyses without coding expertise.
• Reliability through Constraints: By grounding agent planning in a literature-derived Skill Graph, the system prevents the "hallucination" of invalid workflow steps, ensuring biological plausibility.
• Quality Control: The independent Reviewer Agent acts as a systematic quality gate, catching methodological errors (e.g., statistical assumptions, QC thresholds) that human peer reviewers typically flag.
• Future Outlook: The framework represents a shift toward self-correcting, literature-grounded agentic systems. Future work aims to integrate GPU-accelerated foundation models, expand to multi-modal analyses, and couple with robotic laboratory platforms for closed-loop experimental validation.

Availability: The platform is available at https://pipette.bio, and the Skill Graph is accessible at http://skillgraph.pipette.bio. All benchmark data and code are open-source on GitHub.