Jeden Skill in Manus ausführen
mit einem Klick

Jeden Skill in Manus mit einem Klick ausführen

genie3

Sterne2

Forks0

Aktualisiert12. Mai 2026 um 11:07

Run de-novo protein design with Genie 3 — a fast, all-atom, SE(3)-equivariant diffusion model. Use this skill when: (1) Generating unconditional monomeric protein backbones (length 50–600+), (2) Solving motif-scaffolding problems (single- and multi-motif), (3) Designing protein binders for a target with hotspot residues, (4) Running beam search or iterative-conditioning binder pipelines, (5) Loading legacy Genie 2 (Cα-trace) checkpoints, (6) Training the Genie 3 model from scratch. This skill covers installation, the unified `genie3` CLI (run / generate / evaluate / status / train), the experiment YAML schema, the three application workflows, multi-GPU + multi-node sharding, problem-set preparation, output layout, and the in-silico success filters. Pairs with: `proteinmpnn` (inverse folding), `colabfold` / `esmfold` (structure prediction back-ends used by the evaluation pipeline), `foldseek` (cluster successful designs), `protein-qc` (QC thresholds), and `binder-design` (tool selection between Genie 3, BindCr

Installation

Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.

In Manus ausführen

Quelle

LiorZ

LiorZ/protein-design-skills

GitHub-Repository öffnen Creator-Repositorys ansehen

Download

In Manus ausführen

Verwandte BerufeSOC

Basierend auf der SOC-Berufsklassifikation

Biochemiker und BiophysikerNatur- und Sozialwissenschaften·SOC 19-1021

Datei-Explorer

21 Dateien

SKILL.md

readonly

Mehr aus diesem Repository

gleiches Repository

bioemu

LiorZ/protein-design-skills

Run BioEmu (Biomolecular Emulator) — Microsoft Research's deep generative model that samples from the **approximated equilibrium (Boltzmann) distribution** of structures for a protein monomer, given its amino acid sequence. BioEmu is **not** a single-structure predictor: it's the AF3-class "many predictors" diffusion model whose output is an **ensemble** (an `.xtc` trajectory of backbone frames) approximating MD-style equilibrium, at orders-of-magnitude lower cost than running MD. Use this skill when: (1) Sampling a **conformational ensemble** of a protein monomer from its sequence (the headline use case — chignolin, folded/unfolded coexistence, fast-folder benchmarks, etc.), (2) Mapping **conformational changes** relevant to function — formation of **cryptic pockets**, local **unfolding** events, large-scale **domain rearrangements**, (3) Predicting **folding free energies / protein stability** (ΔG_fold) directly from the sampled ensemble (the v1.1 and v1.2 checkpoints were trained wi

2026-06-052

bindcraft

LiorZ/protein-design-skills

Run BindCraft — a hallucination-based de novo binder design pipeline that couples **AF2 backpropagation** (ColabDesign), **ProteinMPNN** redesign, **AF2 reprediction**, and a full **PyRosetta** interface-score filter pass against a single target PDB. One `bindcraft.py` (or `sbatch bindcraft.slurm`) call runs an endless trajectory loop until the requested number of designs that pass every filter is reached. Use this skill when: (1) De novo designing **mini-protein binders** (~65–150 aa) against a protein target — the canonical BindCraft use case, (2) Designing **peptide binders** (≤ ~25 aa) using the dedicated `peptide_3stage_multimer` advanced preset + `peptide_filters`, (3) Designing for a **β-sheet-rich** target or a target where the binder *should* be β-sheet (`betasheet_4stage_multimer` preset), (4) Selecting a **hotspot patch** (`target_hotspot_residues`: `"56"`, `"A1-10,B1-20"`, `"A"`, or `null`) to focus AF2 on a specific epitope, (5) Producing AF2-validated designs ranked by **interfac

2026-06-052

caver

LiorZ/protein-design-skills

Run **CAVER 3.0 / 3.01** — the canonical tool from the Loschmidt Laboratories / Masaryk University for **identification, geometric characterization, clustering, and visualization of transport pathways (tunnels, channels, pores)** in macromolecular structures. CAVER operates on PDB files (a single static structure or an ensemble of MD snapshots) and returns the tunnels leading from a user-specified starting point inside the protein to the bulk solvent. Use this skill when: (1) Finding the access tunnel(s) connecting a buried active site / cofactor / co-substrate / catalytic residue to the protein surface, with their bottleneck radius, length, curvature, throughput, and priority — the headline CAVER use case, (2) Analyzing tunnel **dynamics** across a molecular-dynamics trajectory (10 / 100 / 1 000+ snapshots), clustering equivalent tunnels across frames into a small number of stable channels and ranking them by `Priority` (averaged throughput), (3) Comparing tunnels across **multiple ho

2026-05-312

esm-biohub

LiorZ/protein-design-skills

Run the **Biohub `esm` repository** (formerly EvolutionaryScale) — the world model of protein biology that ships **ESMC** (state-of-the-art protein language model), **ESMFold2** (AF3-class structure prediction with proteins + DNA + RNA + ligands), **ESM3** (generative model over sequence / structure / function), and **ESMC Sparse Autoencoders** (interpretable feature decomposition of ESMC's internal representations). Use this skill when: (1) Producing **per-residue or pooled embeddings** of one or many sequences with ESMC (300M / 600M / 6B) for downstream classification, regression, retrieval, clustering, or representation learning, (2) **Zero-shot mutation scoring / pseudo-perplexity / entropy** on a sequence by sampling masked logits (the headline ESMC use case for variant-effect prediction), (3) **Fine-tuning** ESMC for a task (PEFT / LoRA classification or regression head) or doing a **layer sweep** to find the best feature layer for a downstream probe, (4) Predicting **all-atom 3D

2026-05-282

biotite

LiorZ/protein-design-skills

Use Biotite — a fast, NumPy-backed Python library for computational molecular biology — to read, manipulate, analyze, and write biomolecular structures and sequences, and to fetch data from biological databases. This is the toolkit/"glue" library of the collection: it does not fold or design proteins, it lets you operate on the structures and sequences that the predictors/designers consume and produce. Use this skill when: (1) Parsing, editing, or writing **structure files** — PDB, mmCIF / PDBx, BinaryCIF, MOL / SDF, GRO, and MD trajectories (XTC / TRR / DCD / NetCDF), (2) Selecting / filtering atoms, residues, or chains with NumPy boolean masks over annotation arrays (the `AtomArray` / `AtomArrayStack` data model), (3) **Superimposing** structures and computing **RMSD / RMSF / lDDT / TM-score** — e.g. comparing a designed backbone to its AlphaFold3 / Boltz / Chai prediction, or two predictions to each other, (4) Structural analysis: **SASA**, **secondary-structure** assignment, **hydrogen

2026-05-282

protenix

LiorZ/protein-design-skills

Run Protenix — ByteDance's open-source, trainable reproduction of AlphaFold 3 for high-accuracy biomolecular structure prediction. Protenix folds complexes of proteins, DNA, RNA, small-molecule ligands, and ions in one pass, with post-translational/nucleotide modifications, covalent bonds, MSAs, templates, and optional pocket/contact constraints. Use this skill when: (1) Predicting the 3D structure of a **protein / nucleic-acid / ligand complex** from sequences + ligand specs (the headline use case), (2) Folding a **single protein** (monomer or homo-/hetero-oligomer via `count` / `id`) with an MMseqs2 MSA searched automatically, (3) Modeling **protein–ligand** binding where the ligand is a CCD code, a SMILES string, or a 3D structure file (SDF/MOL/MOL2/PDB), (4) Predicting **protein–DNA / protein–RNA** complexes, optionally with RNA MSA, modified bases, and double-stranded DNA (two complementary strands), (5) Adding **covalent bonds** (e.g. glycosylation, covalent inhibitors, cyclic peptid

2026-05-252

name	genie3
description	Run de-novo protein design with Genie 3 — a fast, all-atom, SE(3)-equivariant diffusion model. Use this skill when: (1) Generating unconditional monomeric protein backbones (length 50–600+), (2) Solving motif-scaffolding problems (single- and multi-motif), (3) Designing protein binders for a target with hotspot residues, (4) Running beam search or iterative-conditioning binder pipelines, (5) Loading legacy Genie 2 (Cα-trace) checkpoints, (6) Training the Genie 3 model from scratch. This skill covers installation, the unified `genie3` CLI (run / generate / evaluate / status / train), the experiment YAML schema, the three application workflows, multi-GPU + multi-node sharding, problem-set preparation, output layout, and the in-silico success filters. Pairs with: `proteinmpnn` (inverse folding), `colabfold` / `esmfold` (structure prediction back-ends used by the evaluation pipeline), `foldseek` (cluster successful designs), `protein-qc` (QC thresholds), and `binder-design` (tool selection between Genie 3, BindCraft, RFdiffusion, BoltzGen).
license	MIT
category	design-tools
tags	["structure-design","backbone-generation","motif-scaffolding","binder","diffusion","equivariant"]
repo	https://github.com/aqlaboratory/genie3
preprint	https://www.biorxiv.org/content/10.64898/2026.05.01.722168v1

Genie 3 — Fast All-Atom SE(3)-Equivariant Protein Design

What this is

Genie 3 is a single diffusion model with three application modes selected by the YAML config:

`generation.dataset.source`	`evaluation.version`	What it does
`unconditional`	`unconditional`	De-novo monomers; sweep length range
`motif`	`scaffold`	Motif scaffolding (single or multi)
`target`	`binder`	Binder design against a target PDB + hotspots

All workflows are driven by one CLI: genie3 {run, generate, evaluate, status, train}. A single genie3 conda env covers everything (incl. ColabFold, ESMFold, ProteinMPNN, FoldSeek, TMscore, DSSP).

Prerequisites

Requirement	Minimum	Notes
OS	Linux (x86_64)	Setup script targets Linux
GPU	NVIDIA, CUDA 12+	Required for generation, ColabFold, ESMFold
GPU VRAM	24 GB	40+ GB for long monomers / beam search / large complexes
Conda	Any modern conda	The setup script creates the `genie3` env (Python 3.10)
Disk	~30 GB	ColabFold AF2 multimer weights + pretrained Genie 3 checkpoint + datasets
Network	Internet at setup	HuggingFace + ColabFold MSA server (only at problem-prep time)

Three-step quick start

1) Install (one-time)

git clone https://github.com/aqlaboratory/genie3.git
cd genie3
bash scripts/setup/setup.sh        # creates conda env "genie3", installs all deps
bash scripts/setup/download.sh     # downloads pretrained weights + training data
conda activate genie3

The setup script installs into the genie3 conda env: torch 2.7.1, ColabFold (alphafold-multimer-v3 weights), ESMFold (openfold + ESM2), ProteinMPNN, FoldSeek, TMscore/TMalign, DSSP. See references/setup.md.

2) Pick an example config

genie3 run -c examples/unconditional/experiment.yaml      # de-novo monomers
genie3 run -c examples/motif_scaffolding/experiment.yaml  # motif scaffolding
genie3 run -c examples/binder_design/experiment.yaml      # binder design

run chains generate → evaluate → reduce in three child processes (so GPU memory is freed between stages). To split stages or run multi-node, see step 3.

3) Inspect outputs

Every config sets paths.rootdir. Results land under <rootdir>/results/ (or <rootdir>/<problem_name>/results/ for per-problem tasks). The most useful files:

info.csv — per-design metrics (one row per generated sample)
successful_*_generations/ and v0_success/ — PDBs that passed in-silico filters
successful_*_cluster.csv — FoldSeek clusters at TM 0.5/0.6/0.8

See references/outputs.md for full schema and success criteria.

CLI at a glance

Command	Description
`genie3 run -c <CFG>`	Generate + evaluate + reduce, all in one
`genie3 generate -c <CFG>`	Generation only (one shard)
`genie3 evaluate -c <CFG>`	Evaluate one shard
`genie3 evaluate --reduce -c <CFG>`	Merge shard outputs and produce final CSVs
`genie3 status -c <CFG>`	Show shard/round progress
`genie3 train --config <CFG> -d N`	Train the model

Shared flags: -c/--config, --num-devices N, --shard-id ID, --num-shards N, --verbose, --log-dir <DIR>. Full reference in references/cli.md.

Choosing the right reference doc

You want to…	Read
Install the env or download weights	references/setup.md
Understand every CLI flag and process model	references/cli.md
Author or modify an experiment YAML	references/configuration.md
Run unconditional generation	references/unconditional.md
Run motif scaffolding (single or multi-motif)	references/motif-scaffolding.md
Run binder design (basic)	references/binder-design.md
Use beam search or iterative conditioning for binders	references/iterative-and-beam.md
Build a new binder problem set from PDB targets	references/problem-prep.md
Distribute work across many GPUs / nodes	references/multi-node.md
Read the per-design CSV columns and success filters	references/outputs.md
Train the model from scratch	references/training.md
Diagnose failures	references/troubleshooting.md

Quick decision tree (which application?)

You want diverse de-novo monomers, no constraint → unconditional. Tune direction_scale (0.8 short / 0.0 long) and length range.
You have a functional motif (active site, epitope) and want a scaffold around it → motif. Define the motif PDB with REMARK 999 headers + a problem JSON (segment_config_str).
You have a target PDB and want a binder for it → target. Provide hotspot residues and binder length range. Choose folding mode: template (no MSA) for speed or msa for accuracy.

If you don't know whether Genie 3 is the right tool vs BindCraft / RFdiffusion / BoltzGen, consult the binder-design skill (tool selection guide).

Hard rules / gotchas

Always activate the env first: conda activate genie3. The CLI dispatches to itself via subprocess, so genie3 must be on PATH.
paths.rootdir is the single source of truth for output. Do not also set generation.io.outdir — the loader will reject conflicting values.
Do not set generation.dataset.datadir — use paths.dataset instead. Same for reward.reward.datadir.
First chain in any binder PDB must be the binder chain. The reducer extracts chain A as the binder.
Re-running genie3 run resumes from the last incomplete stage (sharded or iterative). Sentinel files (.generate_done, .evaluate_done, .shard_markers/) drive this.
genie3 evaluate --reduce runs once after all evaluation shards finish. Don't shard the reduce step.
direction_scale heavily affects quality/diversity. Defaults: 0.8 for short monomers (≤300), 0.0 for long monomers (>300) and binders, 0.1 for motif scaffolding.
ColabFold MSAs are only needed for problem prep (prepare.py) and for evaluation.folding.mode: msa. The MSA server is queried over the network at prep time.
Beam search batches: n_sample in beam mode means number of beam-search runs, and the loader auto-divides by beam_width to hit your requested total. See references/iterative-and-beam.md.
Iterative cond_strategy: iter_common* computes the common interface from prior rounds' successes and caches it under <rootdir>/problems/<problem>.json — that is the dataset path used by subsequent rounds.

Where to install the skill

This directory (skill/) is the skill payload. To make it discoverable to a Claude Code agent on this machine:

mkdir -p ~/.claude/skills
ln -s "$(pwd)/skill" ~/.claude/skills/genie3
# or copy:
cp -R skill ~/.claude/skills/genie3

After that, an agent can invoke it via the Skill tool with skill: genie3 (or you can include the marketplace structure if publishing). Skills are loaded by name from ~/.claude/skills/<name>/SKILL.md and may reference files in their own directory.

Citation

@article{lin2026genie3,
  title   = {Fast and Ultra-Capable Protein Design: Advancing the Frontier
             Through Atomistic SE(3)-Equivariance with Genie 3},
  author  = {Lin, Yeqing and Lee, Minji and Vermani, Aakarsh and Jiang, Ellena
             and {De Cooman}, Sebastiaan and Spetko, Matej and AlQuraishi, Mohammed},
  journal = {bioRxiv},
  year    = {2026},
  doi     = {10.64898/2026.05.01.722168}
}