Lecture 29: Skills, MCP Servers, and Installing Orbit

Learning Objectives

By the end of this lecture, you will be able to:

Explain what an agentic skill is and recognize the file-system layout used by Claude-style skills
Compare how Anthropic, OpenAI, and Google package reusable agent capabilities
Describe the Model Context Protocol (MCP) and what an “MCP server” provides to an agent
Find and evaluate MCP servers for bioinformatics and literature work
Install the latest Orbit (notebook-rewire-pure-md branch) on macOS, Linux, or Windows (WSL2)
Configure Orbit with your Anthropic API key and a Galaxy API key

1. Agentic Skills

1.1 What is a skill?

A skill is a short, self-contained set of instructions an agent can pull in when it needs them. It is just a markdown file (sometimes with a helper script next to it) that explains how to do one specific task: the steps, the common mistakes, the order of tools, the conventions a particular project uses. Skills do not change the model itself—they are reading material the agent picks up only when the topic comes up.

A useful analogy: imagine you onboard a new postdoc. They are smart, but they do not know your lab’s conventions—which servers to use, which tool flags you prefer, where the data lives, which scripts are blessed. A skill is the one-page handover note for one such convention. The agent reads it the moment it needs it, follows it, and sets it aside again.

Three things make skills different from “just put the instructions in the prompt”:

Loaded only when needed. A skill is added to the conversation only when the agent decides it is relevant. You can keep hundreds of skills around without making every prompt longer (and more expensive)
Picked by short description. Each skill has a one-line description at the top. The agent reads only those one-liners to decide which skill to open, instead of reading every full skill every time
Easy to share and reuse. Skills are plain files on disk or in a GitHub repo. A lab can curate a set, version-control them with git, and use the same set across many projects and many agents

1.2 Anatomy of a Claude-style skill

Anthropic’s convention is the most concrete and is becoming a de-facto standard—other agents (including Loom/Orbit) read the same layout. A skill is a directory:

my-skill/
├── SKILL.md          # required: the actual instructions
├── reference.md      # optional: deeper docs the skill links to
└── scripts/          # optional: helper scripts the skill invokes
    └── do_thing.py

SKILL.md starts with a small header block that names the skill and describes what it is for. The header is fenced by a pair of --- lines—the same syntax Quarto uses at the top of these lecture files (it is called YAML frontmatter, but you do not need to remember the term):

---
name: paired-collection-from-pe-fastq
description: Build a Galaxy paired-collection dataset from a directory of paired-end FASTQ files using the Apply Rules DSL.
---

## When to use
... (rules of thumb the agent can reason about) ...

## Steps
1. ...
2. ...

## Gotchas
- Apply Rules trims `_R1`/`_R2` suffixes by default; ...

The name and description are the bits the agent checks first when deciding whether to open the file.

A repository of skills usually has a top-level AGENTS.md that lists every skill in one place—a kind of table of contents (“this topic → that file”) so the agent can find the right one without opening every skill on disk.

1.3 Examples

galaxyproject/galaxy-skills — the default skills bundle for Loom/Orbit. Covers things like “build a paired collection from PE FASTQ”, “map a tool over a collection”, “convert a Nextflow pipeline to a Galaxy workflow”, “Galaxy MCP usage and common gotchas”. The agent fetches them on demand from GitHub and caches them locally
anthropics/skills (Anthropic’s public examples) — skills for PDF generation, spreadsheet manipulation, Slack-flavored formatting, web research workflows
Project-local skills in .claude/skills/ (or ~/.claude/skills/ for personal ones) — e.g. “how we run the lab pipeline,” “how to format a manuscript figure,” “how to deploy this app.” These never leave your laptop

1.4 Skills across vendors

Different vendors have converged on similar ideas with different vocabularies:

Vendor	Name for “skill-like” packaging	Where it lives	Loaded how
Anthropic (Claude)	Skills	Plain markdown files in `~/.claude/skills/` (or inside a project, or in a GitHub repo)	Agent reads the header line, opens the file when relevant
OpenAI	Custom GPTs (in ChatGPT), Apps in ChatGPT, Custom Instructions, or tools in the Assistants/Agents API	OpenAI’s servers (Custom GPTs) or written as a small JSON description (API)	Picked by the user (Custom GPT) or chosen by the model (tools)
Google (Gemini)	Gems (in the Gemini app), or Tools + Apps in Vertex AI Agent Builder	Google’s servers	Picked by the user (Gems) or chosen by the agent at runtime (Tools)

Three observations are worth emphasizing:

Anthropic’s skills are just files. Anyone can write one in markdown, drop it in a folder, and the agent picks it up. There is no website to log into, no server to register with. This is why people share whole repos of skills on GitHub
OpenAI’s Custom GPTs are closer to a published persona than to a skill. Each one bundles instructions, attached files, and tools behind a single ChatGPT entry point. Outside of ChatGPT (e.g. through OpenAI’s API) the closest equivalent is an “Assistant” with attached files and tool definitions
Gemini Gems sit roughly in the middle: a saved combination of instructions and tools that lives inside Google’s app rather than as a portable file on your disk. Google’s Vertex AI Agent Builder is more programmable but runs on Google Cloud rather than on your laptop

For this course we focus on the Claude/Loom/Orbit convention because it is the only one that is fully file-based, portable, and Git-trackable—which is exactly the property you want when teaching reproducible analyses.

Skills vs. tools vs. system prompt

A useful mental hierarchy:

System prompt = “who you are” — always part of the conversation
Tool = “an action the agent can take” (run a command, edit a file, call an API) — always available
Skill = “playbook for a tricky task” — pulled in only when the agent decides it is relevant

2. MCP Servers

2.1 What problem MCP solves

Suppose every agent (Claude Code, Orbit, Cursor, Cline, ChatGPT, …) wants to talk to your lab’s database, to Galaxy, and to PubMed. Without a shared standard, every agent has to ship its own custom code for each one of those services, and every service has to ship a different adapter for each agent. With N agents and M services, that is N × M pieces of glue code—it does not scale.

The Model Context Protocol (MCP), introduced by Anthropic in late 2024 and now adopted by every major agent vendor, is a small shared protocol—a common language both sides agree to speak. It cuts that N × M down to N + M:

An MCP server is a small program that exposes some service (your database, Galaxy, PubMed, …) in the MCP language
An MCP client is the agent
Any agent that speaks MCP can talk to any server that speaks MCP

You write a server once; every MCP-aware agent can use it.

2.2 What does a server provide?

An MCP server can offer three kinds of things:

Tools — actions the agent can run on your behalf (e.g. search PubMed or launch a Galaxy workflow)
Resources — read-only data the agent can pull in (e.g. a CSV the server exposes, or the current contents of an issue tracker)
Prompts — ready-made prompt templates a user can invoke

For research work, the tools category is by far the most common.

2.3 Adding an MCP server to Claude Code or Orbit

In Claude Code, you register a server in ~/.claude/mcp.json (or per-project .claude/mcp.json):

{
  "mcpServers": {
    "galaxy": {
      "command": "uvx",
      "args": ["galaxy-mcp"],
      "env": {
        "GALAXY_URL": "https://usegalaxy.org",
        "GALAXY_API_KEY": "abc..."
      }
    }
  }
}

Orbit registers Galaxy MCP automatically when Galaxy credentials are configured; additional servers can be added through Preferences. The shape is the same: a launch command + environment.

2.4 Where to find MCP servers

Official catalog — modelcontextprotocol/servers: reference servers for filesystem, Git, GitHub, Slack, Postgres, Puppeteer, Brave Search, etc.
Community awesome list — punkpeye/awesome-mcp-servers: the largest directory; categorized by domain
Public registry — mcp.so: browsable index with install snippets
PyPI / npm / GitHub — many servers ship as uvx <name> or npx -y <name>, so you can also discover them through standard package indexes

2.5 MCP servers worth knowing about for biology and research

The community is moving fast; treat the table below as currently popular rather than exhaustive. Search the awesome list for the latest.

Server	Purpose
`galaxy-mcp`	Galaxy API: tool search, history/dataset operations, workflow invocation, IWC search. Used by Orbit by default
`pubmed` / `entrez-mcp` family	Search and fetch records from NCBI’s E-utilities (PubMed, GenBank, RefSeq, etc.)
`biorxiv-mcp` / `medrxiv-mcp`	Query the bioRxiv / medRxiv preprint APIs (`api.biorxiv.org`) for recent preprints, DOIs, and full-text PDFs
`arxiv-mcp-server`	Same idea for arXiv—useful for methods/CS-side preprints
`semantic-scholar-mcp`	Citation graph, paper recommendations, abstracts
`uniprot-mcp` / `ensembl-mcp` / `ucsc-mcp`	Sequence and annotation lookups against the major reference databases
`github-mcp` (official)	Issues, PRs, code search inside a repo or org
`filesystem-mcp` (official)	Scoped read/write under a sandboxed directory
`playwright-mcp` (official)	Headless browser automation—useful for scraping pages without an API
`slack-mcp` (official)	Read/write to Slack channels

Check third-party MCP servers before you run them

An MCP server is a program that runs on your laptop with whatever permissions you give it. Installing a random one off the internet is exactly the same trust decision as installing any other command-line tool. Prefer servers that (a) appear on the popular curated lists, (b) have an active git history, and (c) you (or someone you trust) can read before running. If a server logs into a service for you (GitHub, Slack, your Galaxy account), it is holding your access token—treat it as carefully as you would any other tool you let into that account.

3. Install Orbit

Alpha software — expect rough edges

Orbit is an alpha release. Things will break. You will hit bugs. Some flows will be half-wired or behave unexpectedly. That is expected.

One of the reasons we are running this lecture is so you find these bugs — when something breaks, that is useful signal, not a failure on your part. Note what you did, what you saw, and what you expected; we will collect these and feed them back to development.

3.1 What is Orbit?

Orbit is the desktop application for Loom, an AI co-scientist for Galaxy bioinformatics. It is built with Electron (the same framework as Slack or VS Code), so it looks and behaves like a normal desktop window. The “brain” underneath (Loom) is the same whether you launch it from the terminal or from Orbit—Orbit just gives you a friendlier window into it.

Orbit gives you:

A three-pane layout: file tree on the left, chat in the middle, and on the right a tabbed pane that shows the live notebook, the agent’s activity, or a previewed file
A live, git-tracked notebook.md that acts as the durable project log
An activity tab that streams every command the agent runs, plus per-process CPU and memory
Built-in management for Galaxy connections and skill repositories

In this lecture you install the notebook-rewire-pure-md branch, which is the active development version.

3.2 Prerequisites

Node.js 18 or newer
git
uv (provides uvx, used to launch the Galaxy MCP server)
An Anthropic API key (or another supported provider)—the same key you have been using since Lecture 25 is fine

3.3 macOS

Open Terminal (Cmd+Space, type “Terminal”) and run:

# Homebrew, if you do not have it yet
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Node, git, uv
brew install node git uv

# Clone the dev branch
git clone -b notebook-rewire-pure-md \
    https://github.com/nekrut/pi-galaxy-analyst.git
cd pi-galaxy-analyst

# Install both workspaces (root + Electron app)
npm install
cd app && npm install

Launch Orbit from inside app/:

npm start

3.4 Linux (Ubuntu/Debian)

# Build essentials + git + curl
sudo apt update
sudo apt install -y git curl build-essential

# Node via nvm (skip if you already have Node 18+)
curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
source ~/.bashrc
nvm install --lts

# uv (for the Galaxy MCP server)
curl -LsSf https://astral.sh/uv/install.sh | sh
source ~/.bashrc

# Clone the dev branch
git clone -b notebook-rewire-pure-md \
    https://github.com/nekrut/pi-galaxy-analyst.git
cd pi-galaxy-analyst

npm install
cd app && npm install
npm start

If npm start complains about a missing library

Orbit (because it is built on Electron) relies on a handful of standard system libraries—typically libnss3, libatk1.0-0, libgbm1, and libasound2. On a normal Ubuntu desktop these are usually already there, but if npm start fails with a message like cannot open shared object file: libnss3.so, install the named library with sudo apt install <name> and try again.

3.5 Windows (via WSL2)

On Windows, Orbit runs inside WSL2 (the Windows Subsystem for Linux, version 2)—a lightweight Linux environment that ships with Windows 10/11. We use it because every tool below was written for Linux and runs much more reliably there than on native Windows.

Step 1 — Install (or update) WSL2

Right-click the Start button, choose Terminal (Admin) or Windows PowerShell (Admin), and run one of the following depending on your situation:

If you have never installed WSL2 before:

wsl --install --web-download -d Ubuntu

Reboot when prompted. After the reboot, an Ubuntu window opens automatically and asks you to create a Linux username and password. These are separate from your Windows login—pick anything memorable.

If WSL2 is already installed (e.g. you set it up for Claude Code in Lecture 28):

wsl --update
wsl -l -v

The first command brings WSL2 itself up to date; the second lists your installed Linux distributions and confirms each is on VERSION 2. If you already have Ubuntu running on WSL2, you do not need to install anything else—just open the Ubuntu app from the Start menu and skip to Step 2.

If you have an older WSL1 distribution and want to upgrade it:

wsl --set-version Ubuntu 2

Windows 10 vs. Windows 11

Windows 11 ships with WSL2 ready to go. On Windows 10, run wsl --update in an admin PowerShell before wsl --install to make sure you have a recent enough WSL release.

Step 2 — Open the Ubuntu shell

From here on, every command runs inside the Ubuntu window (the Linux shell), not in PowerShell. If the window is not already open, click Start, type “Ubuntu”, and press Enter.

Step 3 — Install the prerequisites and Orbit

Inside the Ubuntu shell, paste:

# Build essentials + git + curl (skip any already installed)
sudo apt update
sudo apt install -y git curl build-essential

# Node via nvm (skip if you already have Node 18+)
curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
source ~/.bashrc
nvm install --lts

# uv (for the Galaxy MCP server)
curl -LsSf https://astral.sh/uv/install.sh | sh
source ~/.bashrc

# Clone the dev branch into your Linux home directory (NOT /mnt/c/)
cd ~
git clone -b notebook-rewire-pure-md \
    https://github.com/nekrut/pi-galaxy-analyst.git
cd pi-galaxy-analyst

npm install
cd app && npm install
npm start

WSL2 reminders

Keep the clone inside ~/ (your Linux home directory). Cloning into /mnt/c/... (your Windows drive) makes every file read crawl across the boundary between the two filesystems and will be much slower
Even though you launched it from a Linux shell, Orbit will appear as a normal Windows desktop window (Windows takes care of this for you through a feature called WSLg)
If you see libnss3.so: cannot open shared object file, install the missing libraries: sudo apt install -y libnss3 libatk1.0-0 libgbm1 libasound2, then re-run npm start
To get back to the Ubuntu shell later, search for “Ubuntu” in the Start menu, or run wsl from any Windows terminal

4. Configure Orbit

The first time you run npm start Orbit opens a one-page welcome screen that walks you through three things:

LLM provider + API key (which model and which credentials to use)
Galaxy server (optional — the bioinformatics platform Orbit can drive on your behalf)
Working directory (which folder this project’s notebook.md will live in)

You can skip any of these on first launch and fill them in later from Preferences (Cmd+, on macOS, Ctrl+, on Linux/WSL2).

4.1 LLM provider and API key

For this class:

Provider: Anthropic
API key: the class key from Lecture 28 (sk-ant-...)
Model: the default (claude-sonnet-4-6) is fine

Other providers (OpenAI, Google AI, or a local OpenAI-compatible server like Ollama) work too—you would just paste the matching key. If your ANTHROPIC_API_KEY environment variable is already set in your shell, Orbit can pick it up automatically.

4.2 Galaxy server and API key

The “Galaxy server” entry tells Orbit which Galaxy instance to use when the agent decides a step is best run on Galaxy. It needs two things: the server URL and your Galaxy API key.

Server URL

For this course, use:

https://usegalaxy.org

If you have a preferred Galaxy server (e.g. Galaxy Europe at https://usegalaxy.eu, or your institution’s instance), paste that URL instead. Orbit supports several servers in parallel through “profiles” — you can switch between them later from Preferences or with /connect.

Getting your Galaxy API key

A Galaxy API key is a long random string that lets a program log in to Galaxy on your behalf, the same way a password would—except it can be regenerated and revoked without changing your password. Galaxy generates one for you on demand:

Go to your Galaxy server in a web browser (e.g. https://usegalaxy.org) and log in with your usual Galaxy account
From the top menu bar, click User → Preferences
On the Preferences page, click Manage API Key
If you have never created a key before, click Create a new key (or Generate); if a key already exists you can simply copy it. Keys look like a long hexadecimal string, e.g. f9cad7b01a47213585a62adb4e8daa8d
Copy the key to your clipboard

Now paste that key into Orbit’s welcome screen (or Preferences → Galaxy) under the API key field, with the server URL filled in above. Click Save or Connect; the green dot in Orbit’s footer should light up to confirm the connection.

Treat the Galaxy API key like a password

Anyone who has your key can read your histories, launch jobs that cost compute time on your account, and delete your data. Do not paste it into chat, into a public notebook, or into a file inside a Git repo. Orbit stores it in ~/.loom/config.json on your laptop only.

If you think a key has leaked, return to User → Preferences → Manage API Key and click Create a new key—this immediately revokes the old one.

4.3 Working directory

This is the folder where Orbit will create (and keep updating) the project’s notebook.md—the durable record of every plan, decision, and result. Pick a fresh, empty folder for each new analysis, e.g.:

macOS / Linux: ~/analyses/mrsa-alignment
WSL2: same—use a path under ~/, not under /mnt/c/...

You can switch working directories any time from inside Orbit with Cmd/Ctrl+O; each folder becomes its own project.

4.4 Smoke test

Once configuration is saved, Orbit drops you into the chat. Try:

List the files in this directory and tell me what kind of project this looks like.

If the agent responds sensibly and you see its tool calls streaming in the Activity tab on the right, your install plus configuration are working.

If you connected a Galaxy server, also try:

Search the Galaxy tool catalog for fastp and tell me which versions are available.

A correct answer (or a meaningful “I cannot reach the server” error) confirms the Galaxy API key is wired up.

4.5 Where the configuration lives

Once you save, Orbit writes your settings to a single file:

~/.loom/config.json

The file holds your provider keys, Galaxy profiles, and skill repository list. You can edit it by hand if you prefer, but the safer path is to use Orbit’s Preferences dialog.

Updating Orbit later

Because you cloned a branch directly, updating to the latest development commit is just:

cd ~/pi-galaxy-analyst
git pull
npm install
cd app && npm install
npm start

What we covered

A skill is a markdown file with operational know-how that an agent reads only when it is relevant. Anthropic’s SKILL.md convention is the most portable and is what Loom/Orbit follow
MCP is a small shared protocol that lets any agent talk to any tool server. Bioinformatics-relevant servers exist for Galaxy, NCBI, bioRxiv/medRxiv, UniProt, Ensembl, and more—curated in the official and community awesome lists
Orbit is the desktop application for the Loom co-scientist. Install the notebook-rewire-pure-md branch from https://github.com/nekrut/pi-galaxy-analyst; the steps are nearly identical across macOS, Linux, and WSL2
Configuring Orbit means three things: the Anthropic API key (from Lecture 28), the Galaxy server URL + Galaxy API key (from Galaxy → User → Preferences → Manage API Key), and a working directory for notebook.md

5. Take-Home Exercise — Replicate a Published RNA-seq Study

You will use Orbit to independently replicate the RNA-seq analysis reported in:

PubMed 37769084

You should not pre-read the methods section in detail. The point of the exercise is to let the agent read the paper, explain it back to you, propose an analysis plan, run it on Galaxy (or locally), and then place its own results next to the paper’s. You will direct the agent and approve its decisions; the heavy lifting is what Orbit does between your prompts.

Submission

Submit your final PDF summary via this Google form:

https://forms.gle/zQNnxCqTD3TJH19W7

The deadline is the start of next Tuesday’s class. One PDF per student. Use your Penn State email address on the form.

5.1 Before you start

Confirm that everything from §3 and §4 above is in place:

Orbit launches with npm start from inside ~/pi-galaxy-analyst/app/
Your Anthropic API key is configured (Preferences → LLM)
Your Galaxy API key is configured (Preferences → Galaxy), pointing at https://usegalaxy.org (or another server you have access to)
The footer shows a green Galaxy connection dot

If any of those are missing, fix them before going further—this exercise relies on Galaxy doing most of the compute.

5.2 Step 1 — Start a fresh project and read the paper

Create a new, empty directory for this exercise and open Orbit pointing at it:

mkdir -p ~/analyses/pmid-37769084
cd ~/pi-galaxy-analyst/app && npm start

When Orbit opens, switch the working directory (Cmd/Ctrl+O) to ~/analyses/pmid-37769084 if it is not already there. A fresh notebook.md will be created and committed to git automatically.

Now ask Orbit to read the paper and tell you what is in it:

Read the paper at https://pubmed.ncbi.nlm.nih.gov/37769084/ and write a brief summary in the notebook of: (a) the biological question, (b) the experimental design (organism, conditions, replicates), (c) the type of sequencing data and where it is deposited (GEO, SRA, ENA accessions), and (d) the bioinformatics pipeline the authors used.

The agent will fetch the abstract, follow links to the full text where possible, and write the summary into notebook.md. Read what it wrote. If anything is missing or seems wrong, push back:

I do not see a SRA/GEO accession in your summary. Search again and confirm.

Iterate until the summary correctly identifies the public sequencing data backing the paper.

5.3 Step 2 — Generate a replication plan

Once the paper is summarized, ask for a plan:

Generate a plan for replicating the RNA-seq analysis described in this paper. Use Galaxy where possible. Map each step to a specific Galaxy tool (or a local command if Galaxy is not the right fit). Include parameter choices and explain where you got each parameter (paper text, default, your judgment).

Orbit will draft the plan in chat as a markdown section—not in the notebook yet. It will tag each step [local], [hybrid], or [remote] based on what Galaxy can run.

Review the plan critically:

Does the data fetch step use the correct accessions from Step 1?
Are the QC and alignment tools sensible?
Does the differential expression step match what the paper used (DESeq2, edgeR, limma-voom)?
Are read counts, genome build, and annotation versions called out?

Push back where needed:

Step 4 uses the GRCh38 reference, but the paper aligned to mm10. Revise.

When the plan looks right, approve it (yes, looks good, go ahead). Orbit will then show a parameter table for review. Adjust any parameters you want to change, then approve again. Only after both approvals does the plan get written into notebook.md and execution start.

5.4 Step 3 — Execute the plan

Tell Orbit to run the plan. For long-running Galaxy steps it will dispatch the job, embed a tracking block in the notebook, and either wait or move on, depending on dependencies.

While jobs run:

The Activity tab streams every command and shows the proc-monitor for local steps
The Notebook tab shows the live plan with [ ] / [x] / [!] step status
The footer shows token / cost usage

When a Galaxy job is in flight, you can ask /execute or just say “check on the running invocations” to advance.

If a step fails, do not retry blindly. Ask Orbit why:

Step 3 failed. Read the Galaxy job log and explain what went wrong.

Then decide whether to fix parameters, switch tools, or skip the step with a note.

This will take time

RNA-seq alignment and quantification against a mammalian genome are not fast. Expect Galaxy queue waits plus tens of minutes per step. Start early; do not begin Step 3 the night before the deadline.

5.5 Step 4 — Compare your results to the published results

When the plan completes, ask Orbit to compare its output to the paper’s:

Compare the differentially expressed genes you identified to those reported in the paper (look at the supplementary tables if available). Calculate overlap, agreement on direction of change, and note any major differences. Add the comparison as a new section in the notebook.

Then ask for a PDF:

Generate a PDF summary of this entire analysis. Include: (1) the paper summary, (2) the replication plan as executed, (3) the parameters used, (4) key result figures or tables, (5) the comparison with the published results, and (6) a short reflection on what matched, what did not, and why. Save the PDF as summary.pdf in this directory.

Orbit can generate PDFs through pandoc or a similar local tool. If the first attempt looks rough, iterate:

The PDF is missing the comparison table. Re-render including everything I just listed.

5.6 Step 5 — Submit the PDF

Once summary.pdf looks complete:

Open it and read it through. Confirm every section above is present

Commit your project to git:

cd ~/analyses/pmid-37769084
git add notebook.md summary.pdf
git commit -m "Replication of PMID 37769084"

Upload summary.pdf via the Google form: https://forms.gle/zQNnxCqTD3TJH19W7. One PDF per student. Use your Penn State email address on the form

5.7 What counts as a successful replication?

Full numerical agreement is not the bar. RNA-seq pipelines have many parameter choices, and even moderate differences (different aligner, different annotation version) can change individual gene-level results.

What we are looking for in your PDF:

You understood what the paper did. The summary section is correct
Your plan is defensible. Each step makes biological and technical sense; choices are justified
You actually ran it. The notebook shows real Galaxy invocations and real outputs, not just plans
You honestly compared. If your top differentially expressed genes do not match the paper’s, say so and offer a hypothesis (sample mix-up? different normalization? annotation version?)
The PDF is readable. A scientist who has not seen the paper should be able to follow what you did

5.8 Tips and gotchas

Start with the paper, not the data. If you go straight to “download these FASTQs and run an RNA-seq pipeline” without grounding the analysis in the paper’s design, your comparison will be impossible
Use /summarize periodically. It pulls a digest into notebook.md so you (and the agent) can stay oriented when the chat history gets long
Push back on the agent. If a plan step looks wrong, say so. Orbit will revise. Approving without thinking defeats the exercise
Use the Galaxy MCP search. Asking “search the Galaxy IWC for a published RNA-seq DE workflow” often yields a ready-made workflow that does most of the heavy lifting
Cost. Watch the cost indicator in the footer. Long, chatty sessions on Opus can add up; switch to Sonnet (/model sonnet) for routine steps
Save often. notebook.md is git-tracked automatically, but committing your own milestones gives you cleaner restore points if you need to back out a bad plan

If you get stuck for more than a couple of hours on the same step, post in the class channel—someone else is probably stuck on the same thing.