Skip to main content
A Galagos analysis is a conversation, not a script. You describe your research question, the agent writes a plan, runs the steps inside your project’s sandbox, and returns a written summary with figures and references. You read the summary, ask for refinements, and the same conversation continues from there. You do not name tools. You do not write code. You do not configure a pipeline. The agent does.

The conversation loop

Every analysis follows the same rhythm:
1

Ask

Type your research question into the chat at the bottom of the project. Plain English works. Reference uploaded file names directly.
2

Read the plan

The agent writes its plan in plain English in the right panel before compute starts. Read it; this is the moment to catch a misread of your data.
3

Run

The agent executes step by step — shell commands, scripts, package installs, all visible in the Steps list. You can close the browser; the run continues in the background.
4

Read the summary

When the run finishes, the agent returns a written summary with the headline numbers, the figures, and a self-written Limitations paragraph. You see results, not a raw output folder.
5

Refine

Ask follow-up questions in the same conversation. “Re-run with the stricter filter.” “Do these results look believable?” The agent has full context of the previous steps.
Start broader than you think. Asking for a comprehensive analysis lets the agent show you what’s interesting; you can then drill into the parts that matter. A narrow first question often misses the result that actually matters.

What to type — concrete examples

The following prompts are taken from real workflows. They illustrate the level of detail that produces good results.
The agent downloads the dataset server-side, runs alignment and quantification, and returns the matrix together with a QC summary.

What the agent does behind the scenes

Plan preview

Before committing CPU time, the agent writes a plain-English plan: which comparison, which tool, which parameters, which expected output. Read it before walking away. A one-line correction here saves minutes or hours of misdirected compute.

Running in real shells

The agent runs bash, R, and Python in a real Linux sandbox attached to your project. It installs packages it needs (pip, install.packages, apt) and they persist for next time. It downloads datasets server-side — your laptop does not stay open while a 30 GB SRA download completes.

Self-healing recovery

If a step fails — wrong input format, missing dependency, parameter out of range — the agent detects the error, tries an alternative, and reports the recovery in the Steps list. You see what happened without having to debug.

Critical-decision interrupts

For decisions that materially change the result, the agent pauses and asks. The canonical example: DESeq2 versus limma-voom for differential expression with few replicates. The agent surfaces both options, explains the trade-off, and lets you pick the suggested answer, type a custom answer (“use limma-voom with eBayes shrinkage”), or dismiss to let it proceed with its best guess. The decision is recorded in the run history.

Background jobs

Long downloads and long compute steps run as background jobs. An orange status bar above the chat input shows what’s active (“1 background process: wget”). You can keep working on other questions; close the browser; the work continues. Galagos emails you when a long-running job finishes or when the agent needs a decision.

Live trace and the final report

As the run progresses, the chat shows each step in real time — the tool called, the inputs used, the brief summary of the output. Click any step to expand its full command, stdout, and stderr. When the analysis completes, a collapsible report appears with:
  • A summary of the goal and approach.
  • The parameters used at each step.
  • Key findings — ranked gene lists, variant counts, cluster assignments — depending on the analysis.
  • Figures rendered inline.
  • The Limitations paragraph: caveats the agent flags about its own output.
  • Literature references from PubMed, UniProt, and NCBI.
Reports read top-to-bottom for a narrative, or you can skip to the parameters block to verify reproducibility.

Refining in the same conversation

The cheapest, fastest move is to keep asking. The agent already has the data, the tool versions, and the context — it doesn’t need to re-establish any of that to answer:
  • “Do these results look believable given the sample size?” — the agent critiques its own output.
  • “Re-run with FDR 5% instead of 10%.” — same workflow, different threshold.
  • “What if I exclude sample 4?” — re-runs the comparison without it.
  • “Now do the same comparison with edgeR and tell me where they disagree.” — runs the alternate method and produces a comparison.
  • “Show me the same volcano plot but with the top 20 labelled.” — replaces the figure in seconds.
Follow-ups consume far fewer credits than starting a new analysis, because the agent doesn’t re-plan from scratch.

Time-travel editing

If a step went wrong or you want to back up and try a different question, every message has a small edit and retry control. You can:
  • Edit and resend an earlier message to fork the conversation from that point.
  • Retry a failed step.
  • Revert to an earlier checkpoint in the conversation.
  • Undo a revert.
The full history is preserved in the run record either way — time-travel doesn’t erase the previous path, it branches from it.

A few tips

  • Start broader than you think. Ask for the comprehensive analysis first; drill in afterwards.
  • Ask the agent to critique itself. “Are these results believable?” often surfaces caveats you would have written down anyway.
  • Refine in-session. Follow-ups are cheaper, faster, and inherit context.
  • Don’t scope to fit the hardware. Galagos runs in a real Linux sandbox with scalable compute. Ask for what you actually want.
  • Read the Limitations paragraph. It is the first thing a reviewer reads, and it is often the most useful thing in the report.

Next steps

Visualisations and reports

What the viewers and figures look like, and how to export them.

Reproducibility and audit

Every command, every parameter, every decision — preserved for review.

Session persistence

Long-running jobs continue while the browser is closed.

Skills

Reusable building blocks that change how the agent runs.