aipoch/open-science

# AlphaFold2 (ColabFold runner)

This skill wraps AlphaFold2 and AlphaFold2-Multimer through `colabfold_batch`,
which replaces DeepMind's local-database MSA pipeline with a call to the public
MMseqs2 server — so a prediction is one command and one FASTA, not a 2 TB
database mount. AF2 remains the reference monomer predictor and the multimer
model is still a strong protein–protein validator, but it does not handle
ligands or nucleic acids; for those, route to `boltz`, `chai1`, or `openfold3`.
The ColabFold code is MIT (github.com/sokrypton/ColabFold) and the AlphaFold2
code is Apache-2.0 (github.com/google-deepmind/alphafold); the AF2 model
parameters are CC-BY-4.0 with DeepMind's terms of use.

## Running it

# Boltz-2

Boltz-2 is the open-weights diffusion co-folder closest in surface to
AlphaFold3: a YAML describing protein, DNA, RNA, and ligand chains in, mmCIF
plus pTM/ipTM/pLDDT confidences out, with an optional small-molecule affinity
head. Among our four co-fold skills it is the default for binder-validation
campaigns — fully open MIT weights and the fastest sampler; pick `chai1` when
you want a second independent model for consensus, `openfold3` when AF3-faithful
settings matter, and `esmfold2` when you can live without an MSA. Code and
weights are MIT (PyPI `boltz`, github.com/jwohlwend/boltz).

## Running it

```yaml

# Borzoi — DNA → Functional Track Prediction

## Prerequisites

| Requirement | Minimum | Recommended |
| ----------- | ------- | ----------- |
| Python      | 3.10+   | 3.11        |
| CUDA        | 12.1+   | 12.4+       |
| GPU VRAM    | 16 GB   | 24 GB+      |

## How to run

```python
from borzoi_pytorch import Borzoi

# Chai-1

Chai-1 is an all-atom diffusion co-folder in the same family as Boltz-2 and
AlphaFold3: a multi-entity FASTA in, mmCIF plus pTM/ipTM/pLDDT out, with
protein, RNA, DNA, and SMILES-ligand chains all first-class. It and `boltz`
cover the same surface; running both and keeping designs that pass either is a
common consensus filter, and Chai's Python entry point makes it the easier of
the two to embed in a loop. Code and weights are Apache-2.0 — commercial use
including drug discovery is explicitly permitted
(github.com/chaidiscovery/chai-lab).

## Running it

```python

# Compute environment setup

Prepare one reproducible environment definition and instructions for one small user-managed host
activation file. Open-Science resolves `submitJob(..., { environment: '<name>' })` by sourcing
`~/.open-science/environments/<name>.sh` before the workload. Existing `~/.openscience/environments/<name>.sh` definitions remain readable in place. Before creating an activation, check both names: update the existing definition at its exact location; if both exist, ask the user which to retain. Never create a second activation just to rename the brand. The file contains activation only; it
does not install packages when a job starts.

Software environment setup and Slurm accounting service configuration are separate concerns.
An unavailable `sacct` service is not evidence that Python, Conda, modules, or the named activation
file are missing. Use the Remote Compute Skill's Slurm troubleshooting reference for scheduler
status and cancellation problems; do not make enabling accounting the only recovery path or assume
the user has administrator privileges.

The environment, package caches, images, and activation file are user-managed durable resources,

# Customize

This Skill routes conversational customization to one of two native composers. It is **not a security
boundary**: it helps the user draft, review, confirm, and report changes, while the application decides
whether a destructive or identity-affecting operation actually takes effect.

> Important: this is a framework Skill, not hard isolation. Do not claim that this Skill provides hard
> security isolation; it is workflow guidance only.

## Route first

- For creating, revising, publishing, inspecting, or deleting a Skill, call
  `host.skills.read('skill-creator')` and follow that internal Skill completely. Do not duplicate its
  authoring workflow here.

# DiffDock-L

DiffDock-L is a blind pose predictor: given a protein structure and a ligand,
it samples ligand placements over the whole surface with a diffusion model and
ranks them with a separately trained confidence head. The confidence score
correlates with pose correctness, not with binding free energy — DiffDock does
not predict whether or how tightly the ligand binds, so for hit triage you
still pair it with a scorer (GNINA, MM-GBSA) or with `boltz`'s affinity head.
For protein–protein and nucleic-acid co-folding, route to `boltz` or `chai1`.
Code and weights are MIT (github.com/gcorso/DiffDock).

## Running it

```bash

# DOCX generation and editing

Choose a workflow that preserves the user's requested content, structure, and presentation. User requirements take precedence over defaults. Keep tables, headings, and lists as native document structures.

## Markdown to a new DOCX

For ordinary reports, use the bundled converter with an existing Pandoc 3.12.1 executable and Python 3.9 or newer. It uses a versioned reference document, separates ordinary table paragraphs from the Compact style shared by lists, and records converter/template provenance inside the DOCX. It does not install software. Run this converter rather than a bare `pandoc source.md -o output.docx` command: that command bypasses the report template and its typography, page geometry, table spacing, and provenance.

In Open Science, first prepare the workflow through the registered Notebook helper:

```json
{
  "kernelSkillIds": ["docx-generation"],
  "code": "docx_workflow = prepare_docx_conversion('.')\nprint(docx_workflow)"

# Environment and package management

The notebook runs against the session's **bound runtime**: the app-managed default (`default-python` / `default-r`) unless you bind another one with `notebook_bind_runtime` — a named environment you created, or one of the user's own detected interpreters. You never activate environments by hand, and you never install packages from inside a cell. Installs happen in the trusted main process through a single tool, `manage_packages`, and always land in the currently bound runtime. This page is the workflow for getting a package installed and for knowing when a package is not something you can install yourself.

## When a package is missing

A run that fails with `ImportError` / `ModuleNotFoundError` (Python) or `Error in library(x): there is no package called 'x'` (R) means the package is not in the environment yet. The fix is one `manage_packages` call, not a code change. Do not rewrite the cell to use a different library that "does roughly the same thing" — install the package the task actually needs. Do not fall back to reading data or computing results a worse way to dodge the missing import.

## Check an installed version

Use `inspect_packages(language, packages)` when the user asks whether a package is installed in an app-managed runtime or which version is present, or when your code depends on a version-specific feature. It reads package metadata from the session's bound app-managed runtime without importing the package or changing the environment. An `installed` result does not prove the import will succeed; use `notebook_execute` when importability itself is the question.

Inspection does not provision a missing app-managed default runtime. If it reports `DEFAULT_RUNTIME_NOT_READY`, use `notebook_execute` in that language to prepare the runtime under notebook execution approval, then retry `inspect_packages`.

# ESMFold2 (Biohub)

All-atom diffusion co-folding from the Biohub ESM release (2026). ESMFold2 =
48 pair layers with MSA support; ESMFold2-Fast = 24 layers, single-sequence
only, ~1.7x faster.

**License:** MIT (code github.com/Biohub/esm + weights HF `biohub/*`).
**Paper:** "Language Modeling Materializes a World Model of Protein Biology" (2026).

## Install

CUDA 12.x GPU (H100/A100-class); Python **3.12 only**. Fresh venv; needs
egress to HF Hub, GitHub, PyPI:

# Evo 2 — DNA Language Model

## Prerequisites

| Requirement | Minimum         | Recommended  |
| ----------- | --------------- | ------------ |
| Python      | 3.11            | 3.12 (<3.13) |
| CUDA        | 12.1+           | 12.4+        |
| GPU VRAM    | 24 GB (7B bf16) | 80 GB (40B)  |
| RAM         | 32 GB           | 128 GB       |

## How to run

### Installation

# fair-esm2 — ESM-2 (Meta AI)

ESM-2 code and weights are MIT (Meta AI, github.com/facebookresearch/esm).

> **Package disambiguation.** `pip install fair-esm` gives you `import esm`
> with `esm.pretrained.*` (ESM-1/2). Biohub's github.com/Biohub/esm fork
> (MIT) gives you `from esm.models.esmfold2 import ESMFold2InputBuilder` —
> see the **`esmfold2`** skill. Both share the `esm` namespace but are
> different libraries. This skill covers **fair-esm** (the Meta package).

## Prerequisites

| Requirement | Minimum                 | Recommended        |
| ----------- | ----------------------- | ------------------ |

# Figure Composer — narrative → panels → compose → adversarial loop

`figure-composer` is the outer workflow for one multi-panel figure. Use the
`figure-style` rules while planning and reviewing; every panel worker uses those
rules independently. Run `paper-narrative` first when the paper-level figure
sequence is still undecided.

## Open-Science Notebook call

Every `notebook_execute` request whose `code` uses a function named in this skill
includes this skill ID:

```json
{ "kernelSkillIds": ["figure-composer"], "code": "print(figure_outline_schema())" }

# Publication-Grade Figure Rules

_A checklist for correct, legible, internally-consistent scientific figures. This
skill does not impose a visual house style — frame, font, and palette are
parameters. Before plotting, follow the Notebook call below and invoke
`apply_figure_style()`._

## Open-Science Notebook call

Every `notebook_execute` request whose `code` uses a function named in this skill
includes this skill ID:

```json
{ "kernelSkillIds": ["figure-style"], "code": "apply_figure_style()\n..." }

# Indication Dossier

Produces a structured research dossier on a single indication, framed as a
patient population: who they are, what's wrong, how they're treated today,
and how clinical trials can be designed to help them. Runs as five phases
that write resumable waypoint files; after a brief identity check at the end
of Phase 1, the remaining phases run straight through.

## Framing

**Think of an indication as a patient population.** Frame everything
from the patient perspective: "Who are these patients?" not "What is this
disease?"; "How are these patients identified and managed?" not "What causes
this condition?"; population nesting: "all patients in {child} are patients

# LigandMPNN

LigandMPNN extends the ProteinMPNN graph with non-protein atoms — small
molecules, nucleic acids, and metals are visible to the network — so it is the
right inverse-folding tool whenever the design surface includes a bound ligand
or cofactor that vanilla `proteinmpnn` would ignore. The same `run.py` is also
the most convenient runner for the other MPNN families because, unlike the
original ProteinMPNN script, it threads designs back onto the input structure
and writes PDBs alongside the FASTA. Code and weights are MIT
(github.com/dauparas/LigandMPNN). The model is small enough to run on CPU —
for a handful of designs on one structure that is seconds and usually faster
than dispatching, so the normal path is local with
`pip install torch numpy biopython ProDy ml_collections dm-tree`; a GPU helps
for batched campaigns.

# Literature review

A literature question has two halves: finding the papers a domain expert would point to, and turning them into something more useful than a reading list — a synthesis that says what's established, what's contested, what's new, and where the holes are. Both halves can fail quietly and look like competent output until someone checks.

## Setup (any agent, no API key)

This is a **pure skill** — `kernel.py` is deterministic Python (plain HTTP/stdlib calls to CrossRef and OpenAlex) and _you_ (the base model) do all the reasoning: the finding, the synthesis, the prose. There is no `host` runtime and no LLM API. Load the helpers once per session in a Python cell:

```python
exec(open("<this skill's directory>/kernel.py").read())
```

Nothing auto-loads it outside Claude Science. Then call the helpers directly — `verify_dois`, `crossref_lookup`, `search_openalex`, `expand_citations`, `extract_dois`, `style_pass`. If a helper name is not defined, you haven't exec'd `kernel.py`.

# OpenFold3 Structure Prediction

## Prerequisites

| Requirement    | Minimum | Recommended |
| -------------- | ------- | ----------- |
| Python         | 3.10+   | 3.11        |
| CUDA           | 12.1+   | 12.4+       |
| GPU VRAM       | 24GB    | 80GB (H100) |
| RAM            | 32GB    | 64GB        |
| Disk (weights) | 3GB     | -           |

## How to run

# Paper Narrative — manuscript → brief → figure arc → editorial loop

`paper-narrative` is the outermost figure workflow. It judges the paper-level
story before `figure-composer` designs any one figure. The inputs are the work
itself: a manuscript (or abstract), figure captions, and the current full deck.

## Open-Science Notebook call

Every `notebook_execute` request whose `code` uses a function named in this skill
includes this skill ID:

```json
{ "kernelSkillIds": ["paper-narrative"], "code": "print(paper_brief_schema())" }
```

# ProteinMPNN

ProteinMPNN is the default inverse-folding step in the binder pipeline: a
message-passing network that sees backbone geometry only, so it is the right
choice when the design surface is protein–protein and the wrong one as soon as
a ligand, nucleic acid, or metal is part of the interface — `ligandmpnn` adds
those atoms to the graph with a near-identical CLI, and `solublempnn` swaps in
weights trained on soluble structures for an expression-biased prior. Code and
weights are MIT (github.com/dauparas/ProteinMPNN). The model is small enough
to run on CPU — for a handful of sequences on one backbone that is seconds and
usually faster than dispatching a remote job; a GPU helps for batched
campaigns (hundreds of backbones or large `--num_seq_per_target`). Either way
the repo is cloned in-job — there is no PyPI dist and the checkpoints are
bundled in the repo.

This skill covers remote compute over SSH, including direct execution and Slurm submission:
listing hosts, creating handles, running short remote commands (callCommand), reading/writing host
knowledge docs, and the full async job lifecycle — submit → save `job_id` → read non-blocking
snapshots by that ID →
harvest → analysis turn → publish artifacts.

**Where host.compute runs:** `host.compute` lives ONLY on the control-plane REPL kernel — run
every example below with the `repl_execute` tool (JavaScript), the same kernel that hosts
`host.mcp`. The `python`/`r` data kernels have NO `host.compute` (SSH and approvals stay outside
the sandbox workspace); calling it from a python/r cell will fail with `host.compute is undefined`.

## Choose an execution location

Only Compute Hosts enabled for this Session are visible or callable. Discover them in one catalog;

# scGPT — Single-Cell Foundation Model

## Prerequisites

| Requirement | Minimum | Recommended |
| ----------- | ------- | ----------- |
| Python      | 3.10+   | 3.11        |
| CUDA        | 12.1+   | 12.4+       |
| GPU VRAM    | 16 GB   | 24 GB+      |

## How to run

### Loading the vocabulary and checkpoint

# scvi-tools — scVI / scANVI

scvi-tools (Gayoso et al. 2022, github.com/scverse/scvi-tools, BSD-3-Clause)
wraps a family
of deep generative models for single-cell omics. The scRNA-seq core is **scVI**
(unsupervised batch-corrected latent embedding) and **scANVI** (scVI + a
classifier head for semi-supervised cell-type label transfer). Both expect
**raw integer UMI counts** and emit a low-dimensional `X_scVI` / `X_scANVI`
that drops into the scanpy neighbors → leiden → umap pipeline.

## Setup (any agent, no API key)

This is a **pure skill** — `kernel.py` is deterministic Python and _you_ (the
base model) do all the reasoning. There is no `host` runtime and no LLM API.

# Self-awareness

Use `repl_execute` for every `host.*` call. The `host` object exists only in the persistent
JavaScript control REPL; Python and R data kernels do not receive it.

## Inspect available capabilities

```javascript
const caps = await host.capabilities()
```

The current project-native result contains 20 known boolean keys:

- `mcp` gates connector calls through `host.mcp(server, method, args?)`.

# Skill Creator

Create one focused, reusable Skill package. Skills are application-managed packages, not Artifacts.
Use the JavaScript control-plane REPL and the native `host.skills` composer for lifecycle operations.

## Native composer

```javascript
await host.skills.list()
await host.skills.read(name)
await host.skills.read(name, path)
await host.skills.validate(name)
await host.skills.edit(name, path, content)
await host.skills.edit(name, path, replacement, oldString)

# SolubleMPNN

SolubleMPNN is not a separate package — it is the ProteinMPNN architecture
retrained on a soluble-PDB subset, which shifts the output distribution away
from the surface hydrophobics that the full-PDB model happily places (because
many of them are buried at crystallographic or membrane interfaces in the
training set). Reach for it when the goal is soluble yield in a heterologous
host; stick with `proteinmpnn` when native-like recovery matters more, since
the soluble prior trades a few points of recovery for the surface bias. Code
and weights are MIT (github.com/dauparas/ProteinMPNN, `soluble_model_weights`;
also exposed via github.com/dauparas/LigandMPNN). The model is small enough to
run on CPU — for a handful of sequences on one backbone that is seconds and
usually faster than dispatching; a GPU helps for batched campaigns. Either way
the repo is cloned in-job (no PyPI dist; checkpoints bundled).