Skip to content
Back to search

blatant-why

AI-powered biologics design campaign agent — multi-agent orchestration with BoltzGen, PXDesign, Protenix, and 200+ cloud tools. Antibodies, nanobodies, de novo binders, and beyond.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/001tmf--blatant-why/badge.svg)](/listings/001tmf--blatant-why)

HTML

<a href="/listings/001tmf--blatant-why"><img src="/api/listings/001tmf--blatant-why/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

You don't need to be a developer. If you can open a terminal and paste commands, you can run BY.

1. Install prerequisites

| Tool | Install | Check | |------|---------|-------| | **Node.js 18+** | [nodejs.org](https://nodejs.org/) | `node --version` | | **Python 3.11+** | [python.org](https://www.python.org/) | `python3 --version` | | **uv** | `curl -LsSf https://astral.sh/uv/install.sh \| sh` | `uv --version` | | **Claude Code** | `npm install -g @anthropic-ai/claude-code` | `claude --version` |

2. Create your project

mkdir my-campaign && cd my-campaign
npx blatant-why init

This scaffolds everything: 11 MCP servers, 21 agents, 19 skills, 13 slash commands, and a CLAUDE.md orchestration file. Takes about 30 seconds.

3. (Optional) Configure compute

BY defaults to **local GPU** if one is available. Otherwise the first-run questionnaire will help you pick between local, HPC (RunPod / Modal / SLURM), or Tamarind cloud. See *Compute Options* below.

cp .env.example .env
# Add keys for whichever compute provider you'll use

4. Start designing

claude

Then just tell it what you want:

> "Design VHH nanobodies against PD-L1"

Or use the guided workflow:

> /by:plan-campaign

Or if it's your first time:

> /by:welcome

That's it. Claude Code handles the rest -- research, design, screening, and ranking.

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 511 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="assets/banner.png" alt="Blatant-Why" width="700">
  3. </p>
  4. <p align="center">
  5. <img src="https://img.shields.io/badge/v0.1.0--beta-Live_Beta-orange?style=flat-square" alt="v0.1.0-beta">
  6. <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square" alt="License: MIT"></a>
  7. <a href="https://github.com/001TMF/blatant-why/pulls"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square" alt="PRs Welcome"></a>
  8. <img src="https://img.shields.io/badge/Claude_Code-Agent-blueviolet?style=flat-square" alt="Claude Code Agent">
  9. <img src="https://img.shields.io/badge/Python-3.11+-3776AB?style=flat-square&logo=python&logoColor=white" alt="Python 3.11+">
  10. <img src="https://img.shields.io/badge/Node.js-18+-339933?style=flat-square&logo=node.js&logoColor=white" alt="Node.js 18+">
  11. </p>
  12. <h3 align="center">Open-source protein design agent for Claude Code</h3>
  13. <p align="center">
  14. Commercial platforms wrap open-source tools behind paywalls and call it a revolution.<br>
  15. BY gives you direct access through Claude Code. No platform fees. Your tools, your compute, your designs.
  16. </p>
  17. ---
  18. <p align="center">
  19. <img src="assets/by_timesaver.png" alt="Time comparison: traditional vs. agentic antibody design" width="400">
  20. </p>
  21. <p align="center"><sub>Source: trust us bro</sub></p>
  22. ---
  23. ## Quick Start (5 minutes)
  24. You don't need to be a developer. If you can open a terminal and paste commands, you can run BY.
  25. ### 1. Install prerequisites
  26. | Tool | Install | Check |
  27. |------|---------|-------|
  28. | **Node.js 18+** | [nodejs.org](https://nodejs.org/) | `node --version` |
  29. | **Python 3.11+** | [python.org](https://www.python.org/) | `python3 --version` |
  30. | **uv** | `curl -LsSf https://astral.sh/uv/install.sh \| sh` | `uv --version` |
  31. | **Claude Code** | `npm install -g @anthropic-ai/claude-code` | `claude --version` |
  32. ### 2. Create your project
  33. ```bash
  34. mkdir my-campaign && cd my-campaign
  35. npx blatant-why init
  36. ```
  37. This scaffolds everything: 11 MCP servers, 21 agents, 19 skills, 13 slash commands, and a CLAUDE.md orchestration file. Takes about 30 seconds.
  38. ### 3. (Optional) Configure compute
  39. BY defaults to **local GPU** if one is available. Otherwise the first-run questionnaire will help you pick between local, HPC (RunPod / Modal / SLURM), or Tamarind cloud. See *Compute Options* below.
  40. ```bash
  41. cp .env.example .env
  42. # Add keys for whichever compute provider you'll use
  43. ```
  44. ### 4. Start designing
  45. ```bash
  46. claude
  47. ```
  48. Then just tell it what you want:
  49. ```
  50. > "Design VHH nanobodies against PD-L1"
  51. ```
  52. Or use the guided workflow:
  53. ```
  54. > /by:plan-campaign
  55. ```
  56. Or if it's your first time:
  57. ```
  58. > /by:welcome
  59. ```
  60. That's it. Claude Code handles the rest -- research, design, screening, and ranking.
  61. ---
  62. ## What It Does
  63. Give it a target protein. It researches across PDB, UniProt, and SAbDab. It plans a design campaign with statistical-strategy debate when the target is novel. It runs compute jobs on your local GPU (default), on your HPC (RunPod / Modal / SLURM via the `by-deploy-compute` skill), or on Tamarind Bio cloud. It screens every design for structural quality, sequence liabilities, and developability. It ranks candidates by composite score. When you submit them to the lab and the results come back, it ingests the CSVs, diagnoses which in-silico features predicted reality, and feeds the calibration back into the next round.
  64. The whole pipeline runs inside Claude Code. No platform. No dashboard. No vendor lock-in.
  65. ---
  66. ## What's Inside
  67. | Component | Count | Description |
  68. |-----------|-------|-------------|
  69. | MCP Servers | 11 | Biological databases, compute (local + HPC + cloud), screening, campaign state, knowledge store |
  70. | Agents | 21 | Research, design, screening, evaluation, lab integration, prior-art, sequence/structure/epitope researchers |
  71. | Skills | 19 | BoltzGen, Protenix, PXDesign, scoring, screening, campaign management, HPC deployment, wet-lab feedback, mechanistic reasoning |
  72. | Slash Commands | 13 | Campaign control from the Claude Code prompt |
  73. <details>
  74. <summary><strong>MCP Servers (11)</strong></summary>
  75. | Server | Role |
  76. |--------|------|
  77. | `pdb` | Protein Data Bank queries |
  78. | `uniprot` | UniProt protein annotation |
  79. | `sabdab` | Structural Antibody Database |
  80. | `screening` | Screening battery orchestration |
  81. | `tamarind` | Tamarind Bio cloud compute |
  82. | `cloud` | Cloud compute abstraction |
  83. | `adaptyv` | Adaptyv Bio lab submission (gated) |
  84. | `campaign` | Campaign state management |
  85. | `research` | Literature and target research |
  86. | `local_compute` | Local GPU compute dispatch |
  87. | `knowledge` | JSON-backed campaign knowledge store |
  88. </details>
  89. <details>
  90. <summary><strong>Agents (21)</strong></summary>
  91. | Agent | Role |
  92. |-------|------|
  93. | `by-research` | Target analysis, literature review, prior art (8-phase research pipeline) |
  94. | `by-prior-art-researcher` | Prior-art deep dive for novel targets |
  95. | `by-sequence-researcher` | Sequence-level analysis (orthologs, conservation, motifs) |
  96. | `by-structure-researcher` | Structural analysis (PDB, AlphaFold, conformations) |
  97. | `by-epitope-researcher` | Epitope-focused literature and structural research |
  98. | `by-research-synthesizer` | Synthesize outputs from the research sub-agents |
  99. | `by-design` | Generate designs via local, HPC, or cloud pipelines |
  100. | `by-screening` | Score, filter, rank candidates |
  101. | `by-evaluator` | Structural evaluation and quality assessment |
  102. | `by-visualization` | Structure and results visualization |
  103. | `by-diversity` | Sequence and structural diversity selection |
  104. | `by-campaign` | Campaign lifecycle orchestration |
  105. | `by-knowledge` | Learning system and campaign memory |
  106. | `by-verifier` | Output verification and sanity checks |
  107. | `by-plan-checker` | Campaign plan validation |
  108. | `by-environment` | Environment setup and dependency checks |
  109. | `by-lab` | Adaptyv Bio lab submission (triple-gated) |
  110. | `by-epitope` | Epitope analysis and mapping |
  111. | `by-humanization` | Antibody humanization engineering |
  112. | `by-liability-engineer` | Sequence liability detection and fixes |
  113. | `by-formatter` | Output formatting and reporting |
  114. </details>
  115. <details>
  116. <summary><strong>Skills (19)</strong></summary>
  117. | Skill | Category | Description |
  118. |-------|----------|-------------|
  119. | `boltzgen` | tool | BoltzGen antibody/nanobody generation |
  120. | `protenix` | tool | Protenix structure prediction (AF3-class) |
  121. | `pxdesign` | tool | PXDesign de novo binder design |
  122. | `by-design-workflow` | orchestration | Tool routing + intent → preset matrix |
  123. | `by-campaign-manager` | orchestration | Campaign state, checkpoints, cost model |
  124. | `by-research` | research | 8-phase research pipeline with confidence tiers |
  125. | `by-database` | research | PDB / UniProt / SAbDab lookups |
  126. | `by-epitope-analysis` | research | Hotspot scoring + interface classification |
  127. | `by-hypothesis-debate` | strategy | 3+1 agent topology for novel-target strategy selection |
  128. | `by-scoring` | scoring | ipSAE algorithm + composite scoring |
  129. | `by-screening` | filtering | Full screening battery, liability + developability rules |
  130. | `by-failure-diagnosis` | analysis | Mann-Whitney U statistical failure analysis |
  131. | `by-experiment-results` | analysis | **NEW.** Ingest lab CSV/Excel, diagnose in-silico vs lab divergence, close design → screen → lab → learn loop |
  132. | `by-causal-reasoning` | analysis | **NEW.** Evidence-anchored mechanistic hypotheses from knowledge graph |
  133. | `by-campaign-optimizer` | optimization | Active learning + RF feature importance |
  134. | `by-knowledge` | persistence | Campaign knowledge graph (entities + relationships) |
  135. | `by-session` | session | Session init, config questionnaire, resume protocol |
  136. | `by-display` | display | Canonical output formats (banners, score bars, status tables) |
  137. | `by-deploy-compute` | deployment | **NEW.** Deploy Protenix / BoltzGen / PXDesign on local GPU, RunPod, Modal, or SLURM |
  138. See [`templates/.claude/skills/README.md`](templates/.claude/skills/README.md) for the canonical terminology table and full skill-linkage map.
  139. </details>
  140. <details>
  141. <summary><strong>Slash Commands (11)</strong></summary>
  142. | Command | Action |
  143. |---------|--------|
  144. | `/by:load` | Load a campaign from file |
  145. | `/by:screen` | Run screening battery on designs |
  146. | `/by:results` | Display campaign results table |
  147. | `/by:watch` | Live-watch running compute jobs |
  148. | `/by:status` | Campaign status dashboard |
  149. | `/by:approve-lab` | Approve Adaptyv Bio submission (gated) |
  150. | `/by:set-profile` | Switch compute profile |
  151. | `/by:setup` | Initialize environment and dependencies |
  152. | `/by:plan-campaign` | Generate a detailed campaign plan |
  153. | `/by:welcome` | Show welcome message and quick-start guide |
  154. | `/by:resume` | Resume an interrupted or paused campaign |
  155. </details>
  156. ---
  157. ## Setup
  158. ### API Keys
  159. | Key | Required? | Where to get it | What it enables |
  160. |-----|-----------|-----------------|-----------------|
  161. | `RUNPOD_API_KEY` | Optional | [runpod.io](https://runpod.io) | On-demand HPC GPU pods (~$0.40–$2.50/hr depending on GPU). Used by the `by-deploy-compute` skill. |
  162. | `TAMARIND_API_KEY` | Optional | [tamarind.bio](https://tamarind.bio) (free account) | Cloud compute fallback — BoltzGen, Protenix, 200+ models. Free tier: 10 jobs/month |
  163. | `ADAPTYV_API_TOKEN` | Optional | [adaptyvbio.com](https://www.adaptyvbio.com) | Lab testing submission (triple-gated) |
  164. Claude Code handles its own authentication. No separate Anthropic API key needed.
  165. **No keys needed for local-GPU mode** — if you have an NVIDIA card with enough VRAM, BY can run the whole pipeline without any cloud service.
  166. ### Configure your environment
  167. After `npx blatant-why init`:
  168. 1. Copy `.env.example` to `.env`.
  169. 2. **For local GPU (default)** — set the tool paths:
  170. ```
  171. PROTEUS_FOLD_DIR=/path/to/Protenix
  172. PROTEUS_PROT_DIR=/path/to/PXDesign
  173. PROTEUS_AB_DIR=/path/to/boltzgen
  174. ```
  175. 3. **For HPC** (RunPod, Modal, SLURM) — add your provider key and let the `by-deploy-compute` skill handle deployment:
  176. ```
  177. RUNPOD_API_KEY=your_key_here # or modal token, etc.
  178. ```
  179. 4. **For Tamarind cloud fallback** — add the API key:
  180. ```
  181. TAMARIND_API_KEY=your_key_here
  182. ```
  183. 5. **For SSH remotes** — add host configs to `.by/config.json` (`compute.ssh_hosts`).
  184. The first-run questionnaire (run by the `by-session` skill on session open) walks through this interactively. Default `compute.default_provider` is `"local"`; priority order is `["local", "hpc", "tamarind"]`.
  185. ### Compute Options
  186. BY defaults to local GPU. The `by-deploy-compute` skill knows how to deploy Protenix / BoltzGen / PXDesign (and supplementary tools like AlphaFold, RFAntibody, ImmuneBuilder, ThermoMPNN, Boltz-2) on any of the targets below.
  187. | Provider | Cost | Setup | Best for |
  188. |----------|------|-------|----------|
  189. | **Local GPU** *(default)* | Your hardware | Install tools + set env vars | Power users with GPUs |
  190. | **RunPod** | ~$0.40–$2.50/hr GPU pods | `RUNPOD_API_KEY` + `by-deploy-compute` | On-demand HPC bursts |
  191. | **Modal** | Serverless, free tier | Modal token + `by-deploy-compute` | Cold-start-tolerant batch jobs |
  192. | **SSH Remote** | Your infrastructure | Configure in `.by/config.json` | HPC clusters, in-house GPUs |
  193. | **Tamarind Bio** | Free tier: 10 jobs/month | `TAMARIND_API_KEY` | Cloud fallback when no local GPU |
  194. <details>
  195. <summary><strong>Setting up Tamarind Bio (recommended -- no GPU needed)</strong></summary>
  196. 1. Create a free account at [tamarind.bio](https://tamarind.bio)
  197. 2. Go to Settings → API Keys → Generate new key
  198. 3. Copy the key and add to `.env`:
  199. ```
  200. TAMARIND_API_KEY=your-key-here
  201. ```
  202. 4. That's it. BY will use Tamarind for all compute jobs.
  203. **Free tier:** 10 jobs/month. Enough for a preview campaign (~5-10 designs).
  204. **Paid tiers:** Contact Tamarind for production pricing.
  205. Tamarind provides access to 200+ structural biology tools including:
  206. - **BoltzGen** -- antibody/nanobody design (Boltzmann generator diffusion)
  207. - **Protenix v1** -- AlphaFold3-class structure prediction (368M params)
  208. - **PXDesign** -- de novo protein binder design (17-82% hit rates)
  209. - **TAP/TNP** -- developability profiling
  210. - **AbLang2** -- humanness scoring
  211. </details>
  212. <details>
  213. <summary><strong>Setting up local GPU compute</strong></summary>
  214. Requires an NVIDIA GPU with CUDA support. Install the tools you need:
  215. **Protenix (structure prediction):**
  216. ```bash
  217. git clone https://github.com/bytedance/protenix
  218. cd protenix && pip install -e .
  219. ```
  220. Add to `.env`:
  221. ```
  222. PROTEUS_FOLD_DIR=/path/to/protenix
  223. ```
  224. **PXDesign (de novo binder design):**
  225. ```bash
  226. # Follow PXDesign installation guide
  227. ```
  228. Add to `.env`:
  229. ```
  230. PROTEUS_PROT_DIR=/path/to/pxdesign
  231. ```
  232. **BoltzGen (antibody/nanobody design):**
  233. ```bash
  234. git clone https://github.com/jostorge/boltzgen
  235. cd boltzgen && pip install -e .
  236. ```
  237. Add to `.env`:
  238. ```
  239. PROTEUS_AB_DIR=/path/to/boltzgen
  240. ```
  241. BY will detect these automatically and offer local compute as an option.
  242. </details>
  243. <details>
  244. <summary><strong>Setting up SSH remote compute (Lambda.ai, RunPod, HPC)</strong></summary>
  245. For cloud GPU instances or HPC clusters:
  246. 1. Ensure SSH key-based authentication is set up
  247. 2. Add host configuration to `.by/config.json`:
  248. ```json
  249. {
  250. "compute": {
  251. "ssh_hosts": [
  252. {
  253. "name": "lambda-gpu",
  254. "host": "your-instance.cloud.lambdalabs.com",
  255. "user": "ubuntu",
  256. "key": "~/.ssh/lambda_key",
  257. "gpu": "A100",
  258. "tools": ["protenix", "boltzgen"]
  259. }
  260. ]
  261. }
  262. }
  263. ```
  264. 3. BY will detect SSH hosts and offer them as compute options.
  265. </details>
  266. ---
  267. ## Your First Campaign
  268. After setup, here's what to expect when you run your first design campaign.
  269. **Start Claude Code:**
  270. ```bash
  271. claude
  272. ```
  273. **Tell it what you want:**
  274. ```
  275. > "Design VHH nanobodies against PD-L1"
  276. ```
  277. **What happens next:**
  278. 1. **Research** (~1-2 min) -- BY searches PDB, UniProt, and SAbDab for your target. It pulls crystal structures, known binders, epitope data, and literature context.
  279. 2. **Campaign plan** (~30 sec) -- You get a plan showing how many designs will be generated, which models will be used, and estimated compute cost. You approve before anything runs.
  280. 3. **Design generation** (~5-15 min) -- Compute jobs run on Tamarind Bio (or your local GPU). BY monitors progress and reports back.
  281. 4. **Screening** (~2-5 min) -- Every design is scored for structural quality (ipSAE), binding confidence (ipTM), and sequence liabilities. Problem candidates are flagged.
  282. 5. **Ranking** -- You get a ranked table of candidates with composite scores, ready for lab ordering.
  283. **Typical first campaign:** 5-10 nanobody designs, ~20 minutes end-to-end, zero GPU required (Tamarind free tier).
  284. You can also use slash commands for more control:
  285. | Command | What it does |
  286. |---------|--------------|
  287. | `/by:welcome` | Guided walkthrough for first-time users |
  288. | `/by:plan-campaign` | Generate and review a campaign plan before running |
  289. | `/by:status` | Check progress on a running campaign |
  290. | `/by:results` | View ranked results table |
  291. ---
  292. ## Architecture
  293. ```mermaid
  294. flowchart TB
  295. User([User]) -->|prompt| Claude[Claude Code + CLAUDE.md]
  296. Claude -->|delegates| Agents[21 Agents]
  297. Claude -->|invokes| Skills[19 Skills]
  298. Claude -->|slash cmds| Commands[13 Commands]
  299. Agents --> MCP[11 MCP Servers]
  300. Skills --> MCP
  301. subgraph Data["Biological Databases"]
  302. PDB[(PDB)]
  303. UniProt[(UniProt)]
  304. SAbDab[(SAbDab)]
  305. end
  306. subgraph Compute["Compute (local-first)"]
  307. LocalGPU["Local GPU -- Default"]
  308. HPC["HPC: RunPod / Modal / SLURM"]
  309. Tamarind["Tamarind Bio -- Cloud Fallback"]
  310. end
  311. subgraph Models["Models"]
  312. BoltzGen["BoltzGen -- Ab/Nb Design"]
  313. Protenix["Protenix v1 -- Structure Prediction"]
  314. PXDesign["PXDesign -- Binder Design"]
  315. end
  316. subgraph Screening["Screening"]
  317. ipSAE["ipSAE Scoring"]
  318. Liabilities["Liability Scan"]
  319. Developability["Developability"]
  320. Diversity["Diversity Selection"]
  321. end
  322. subgraph Lab["Lab Integration"]
  323. Adaptyv["Adaptyv Bio -- Triple-Gated"]
  324. end
  325. MCP --> Data
  326. MCP --> Compute
  327. Compute --> Models
  328. MCP --> Screening
  329. MCP --> Lab
  330. Knowledge[("Knowledge Store")] <--> MCP
  331. ```
  332. <details>
  333. <summary><strong>Model Profiles</strong></summary>
  334. | Model | Type | What It Does |
  335. |-------|------|--------------|
  336. | **Protenix v1** | Structure prediction (368M params) | AlphaFold3-class folding -- protein, nucleic acid, ligand |
  337. | **PXDesign** | De novo binder design | 17-82% hit rates on published benchmarks |
  338. | **BoltzGen** | Antibody/nanobody design | Boltzmann generator + Protenix confidence scoring |
  339. </details>
  340. <details>
  341. <summary><strong>Learning System</strong></summary>
  342. Every campaign writes results to a JSON knowledge store. The `by-knowledge` skill provides structured queries (entity types, relationships) over past campaigns, so the system learns which design strategies work for which target classes.
  343. Stored per campaign:
  344. - Target metadata and research context (with HIGH / MEDIUM / SPECULATIVE confidence tiers)
  345. - Design parameters and compute profiles
  346. - Screening results and composite scores
  347. - Lab outcomes (via `by-experiment-results` — see below)
  348. - Validated / contradicted / inconclusive findings
  349. Over time, the agent develops institutional memory about what works.
  350. </details>
  351. <details>
  352. <summary><strong>Design → Screen → Lab → Learn loop</strong></summary>
  353. BY closes the loop between in-silico predictions and wet-lab reality:
  354. 1. `by-screening` flags candidates as PASS in silico.
  355. 2. You submit them to the lab (Adaptyv Bio or your own).
  356. 3. Lab results arrive as CSV/Excel.
  357. 4. `by-experiment-results` ingests the readouts, joins with the original in-silico features, and runs **Mann-Whitney U** stratified by REAL lab outcome — identifying which in-silico features actually predicted reality and which didn't.
  358. 5. The calibration report goes to `by-campaign-optimizer` (which retrains the active-learning model) and to `by-knowledge` (storing validated/contradicted findings with confidence tiers).
  359. 6. `by-causal-reasoning` produces evidence-anchored mechanistic hypotheses for any persistent failure pattern, ranked with HIGH / MEDIUM / SPECULATIVE confidence and falsifiable predictions. Confidence is assigned mechanically by an evidence-precedence table — the LLM only fills the claim and prediction slots, not the confidence scoring.
  360. This is what separates a designer from a scientist.
  361. </details>
  362. <details>
  363. <summary><strong>Repository Structure</strong></summary>
  364. ```
  365. blatant-why/
  366. ├── assets/ # Banner and diagrams
  367. ├── src/
  368. │ ├── init-cli/ # npx blatant-why init CLI
  369. │ └── proteus_cli/ # Python CLI (scoring, screening, campaign)
  370. ├── templates/ # Deployed by init CLI
  371. │ └── .claude/
  372. │ ├── agents/ # 21 specialized agents
  373. │ ├── commands/by/ # 13 slash commands
  374. │ ├── skills/ # 19 skills (see skills/README.md for catalog)
  375. │ └── mcp_servers/ # 11 MCP server implementations
  376. ├── tests/ # Test suite
  377. ├── CLAUDE.md # Agent orchestration rules
  378. ├── package.json # npm package
  379. ├── pyproject.toml # Python package (uv)
  380. └── README.md
  381. ```
  382. </details>
  383. ---
  384. ## Credits
  385. **Built by** [Tristan Farmer](https://www.linkedin.com/in/tristan-farmer-973b7a17a/)
  386. - [Hannes Stark](https://github.com/jostorge/boltzgen) and the MIT team for BoltzGen
  387. - [Deniz Kavi](https://tamarind.bio) and Sherry Liu at Tamarind Bio
  388. - [Julian Englert](https://www.adaptyvbio.com) at Adaptyv Bio
  389. - The [Claude Code](https://docs.anthropic.com/en/docs/claude-code) team
  390. ---
  391. ## License
  392. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.