Genomics Agentic Research System
Watch the whole system run — raw reads to a reviewed analysis
the filesystem is the state machine, the LLM is the navigator
These are recordings of real GARS runs: a Claude agent executing literal stage contracts, stdlib helpers enforcing the rails, and the filesystem as the only state machine. The headline recording runs the entire arc for real — six ENA yeast samples, nf-core/rnaseq with every task on AWS Batch, DESeq2, and a plan-gated custom analysis — and a second shows the lab writing its own skill and the system dispatching it like the built-ins. Every message, command, exit code and file you'll see was actually produced — nothing is mocked.
The contract moments — where the system stops on purpose
How GARS is built — and why it holds
GARS is a filesystem agent for genomics built on one division of labor, learned the hard way and written into every layer: the agent orchestrates, code computes. Everything that protects the science is deterministic, tested code; what the agent adds is a governed natural-language operating layer — intent routing, gate-keeping dialogue, and a procedure that is enforced, not merely documented.
The ICM methodology: contracts, not vibes
Every stage is a markdown contract the agent executes literally: scope boundaries, fixed response templates, human gates at the decisions where science lives. State is the filesystem itself — numbered stage directories, STATUS files as the single authority, machine-owned files at mode 0444.
advantage
An SOP in a wiki gets skipped under pressure; a contract runs the preflight, checks the exit code, writes STATUS and appends provenance every single time, and the fixed templates make “what did the operator actually do” answerable after the fact. Resumability and auditability come free with the filesystem — no server, no database, and data never leaves the cluster. An unconstrained agent, by contrast, has receipts here: in early live tests one analyzed a colleague's unrelated experiment and another deleted 112 symlinks to satisfy a validation rule. The independent review's words: GARS is “one of the more rigorous existing answers to how you let an LLM agent near real data safely.”
Bioinformatics skill wrappers: pipelines that cannot half-run
Each assay runs through a GARS-authored wrapper on one shared core (wrapperlib.py): preflight check that refuses bad inputs before a cent of compute, an audited params.yaml, a generated submit.sh with a requeue guard, and a collect exit gate that checks content, not existence — every sample must appear as a column of the merged matrix, or the run does not pass.
advantage
The wrappers read facts (samplesheet columns, parameters, output paths) from the pinned pipeline checkouts rather than from memory, and validation is numerical. That discipline caught a real upstream defect before retirement of the old dependency: a published DE table whose fold-changes correlated 0.33 with the actual data (the GARS wrapper's: 0.99) — a gene at padj ≈ 1e-12 reported as a 1.04× change that was really ~70×. Silent defects like that pass every “file exists” gate ever written.
Custom skills: in-house methods become first-class citizens
A lab's own method gets the same machinery as nf-core: the skill-authoring toolkit (create-bioinformatics-skill) scaffolds a wrapper from a spec, a conform linter checks it against the wrapper rules mechanically, and the result runs through the same doors — preflight, executor, exit gate, provenance. The demo's sulfur-panel score was built this way (spec → scaffold → conform PASS → registry row → real run).
advantage
Extensibility without losing governance. In most frameworks a custom script is where rigor ends; here it is where the same rigor begins. The custom-analysis stage (03) adds the missing piece for one-off work: the agent drafts an analysis PLAN as a reviewable file, a human approves intent before anything executes, and outputs are verified against the plan and registered by type.
Memory: multi-project state a person can walk away from
GARS's memory is the workspace itself, kept legible by code: a generated per-project index, per-assay progress (project_state.py renders how far each project got, which scientific decisions are still unmade, and the last HISTORY entries — at every session boot), append-only HISTORY.md with the template and model version stamped per stage, and an artifact registry that resolves inputs by type (counts_gene, de_results) rather than by remembered paths.
advantage
A bioinformatician running many projects resumes any of them cold — or hands one to a colleague — because the state is readable without the person who left it. Web platforms offer this with servers and data movement; GARS does it local-first on the cluster where the data already lives, with nothing to host.
The review is candid about limits and so is the demo: the analysis rigor comes from nf-core and deterministic code, the agent's contribution is the governed interface — and the recorded runs on this site are the evidence, not a claim.