Claude's Corner: Ditto Bio -- The Startup Mining Parasites to Fix Your Immune System

Ditto Bio is using AI to mine proteins from parasites, viruses, and ticks for autoimmune drug candidates. Here's why stealing from 500 million years of evolution might actually work.

By Daniel Singer, Editor, StartupHub.ai

Jul 17, 20268 min readUpdated Oct 19, 2026

Claude's Corner: Ditto Bio -- The Startup Mining Parasites to Fix Your Immune System

TL;DR

Ditto Bio mines genomes of parasites, viruses, and ticks with protein language models to discover immunomodulatory proteins that become next-generation autoimmune therapeutics. Their proprietary tissue biobank for immunogenicity prediction is the compounding moat that separates them from a well-funded competitor running the same open-source pipeline.

5.8

Build difficulty

Contents(5)

There's a quiet admission buried in pharma's history: we've been terrible at inventing drugs from nothing. Combinatorial chemistry, rational design, high-throughput screening -- decades of effort that barely dented the 90% clinical trial failure rate. What actually works, consistently, is stealing from nature. Aspirin was willow bark. Penicillin was mold. The GLP-1 agonists behind Ozempic -- the drugs reshaping body weight across the developed world -- trace back to a protein in Gila monster saliva.

Ditto Bio (YC W2026) has taken that insight to its logical extreme. If nature's best drug discovery engine is evolution, and if parasites have spent hundreds of millions of years evolving proteins specifically designed to control the human immune system, then those proteins are essentially ready-made drug candidates sitting in an unread library. The founders decided to read the library.

The target: autoimmune disease. A $120B+ annual drug market. Fifty million Americans affected. And a set of existing treatments -- the Humiras, the Enbrels, the JAK inhibitors -- that work through blunt immune suppression with side effect profiles that range from manageable to "watch out for tuberculosis reactivation." The opportunity for something more targeted, derived from molecules that co-evolved with human immune pathways over geological timescales, is real.

What They Build

Ditto Bio is a drug discovery company with a platform model. The platform uses AI to scan the genomes of primate-infecting viruses, parasitic worms, and ticks to surface proteins that modulate the human immune system. Those candidates go through computational and experimental validation. The end product is a portfolio of novel protein therapeutics that are novel to pharmaceutical development but ancient to biology.

The insight driving the whole thing: viruses need to evade immune detection. Ticks need to suppress inflammation at bite sites. Intestinal worms need to downregulate host immune responses to survive for decades inside a human host. These are not academic curiosities -- these are organisms under intense selection pressure, and the proteins they evolved to survive are, functionally, precision instruments for the immune system. Some of them target the same cytokine receptors and checkpoint proteins that pharma has spent billions trying to drug.

The founders are three PhD scientists who met and collaborated before Ditto existed. Dennis Sun (CEO) did his PhD in evolutionary and developmental biology at UC Berkeley, postdoc'd at Harvard, and was Chief of Staff at a $500M+ biotech. Adair Borges (CSO) got his PhD at UCSF studying host-pathogen interactions, has 50+ published papers, co-invented an anti-CRISPR protein, and was a Miller Fellow at Berkeley. Emily Weiss (CTO) did her PhD in computational biology and AI at UCSD and previously worked at Illumina and DuPont. Combined: 40+ years of domain expertise, three years of prior collaboration. This is not a team that pivoted into biotech from something else.

How It Works

The technical architecture is a multi-stage pipeline spanning bioinformatics, machine learning, structural biology, and wet lab validation.

Genome ingestion and protein corpus assembly. Ditto pulls sequences from public databases -- NCBI RefSeq, UniProt, ViPR -- supplemented by their own sequencing. The focus is on organisms with long co-evolutionary history with primates: tick species (Ixodes, Amblyomma), helminth worms (Ascaris, Schistosoma, tapeworm families), and persistent viruses known to establish long-term infections in humans. They've crossed 1 million proteins in their corpus. Critically: over 98% of viral and parasite proteins are uncharacterized in the scientific literature. The search space is essentially untouched.

Functional scoring via protein language models. Traditional bioinformatics starts with sequence homology. This approach misses everything genuinely novel. Ditto uses protein language models -- in the family of Meta's ESM-2 -- that embed proteins in high-dimensional vector space based on learned evolutionary and structural features. Functionally similar proteins cluster together even with low sequence similarity. This surfaces candidates that wouldn't appear in any BLAST search: the undiscovered country of parasite proteomics.

Structure prediction and binding modeling. Flagged candidates go through AlphaFold and RoseTTAFold structure prediction to generate 3D conformations. Docking algorithms then model how these proteins bind to human immune targets: cytokine receptors (IL-6R, TNF-alpha, IL-4Ra), JAK-STAT components, T-cell checkpoint proteins. They've reported binding affinities of 1-2 nM for top candidates. That's pharmaceutical-grade tight binding -- comparable to approved biologics.

The daily brief

Get the free daily brief with the day's AI news, new AI startups and funding rounds every morning.

Join 64,000 other subscribers.

The immunogenicity biobank -- the real differentiator. One of the most common ways protein therapeutics fail is immunogenicity: the patient's immune system mounts a response against the drug protein itself, neutralizing it and potentially causing serious adverse events. Predicting immunogenicity for truly novel proteins is largely unsolved in pharma.

Ditto is building a tissue biobank that maps real-world human immune memory to parasite proteins. They're collecting immune cell samples, characterizing which T-cell epitopes are already immunologically tolerated, and using that data to train immunogenicity prediction models. This biobank is the kind of proprietary asset that cannot be reconstructed from public data. It accumulates with every sample and every experiment. It makes their predictions better as they grow. It's the flywheel nobody talks about in the launch post.

Design-build-test-learn loop. Computational hits go to the wet lab for expression, purification, and experimental validation -- binding assays, cell-based immune modulation assays, eventually animal models. Results feed back into the ML models. Standard iterative drug discovery, but starting with thousands of validated computational candidates rather than random screening or synthetic chemistry. The cost structure looks completely different when you enter the wet lab with that kind of head start.

Target disease areas: rheumatoid arthritis, inflammatory bowel disease, eczema, psoriasis, lupus, multiple sclerosis, Type 1 diabetes. All autoimmune. All large markets. All currently served by drugs that suppress the immune system globally rather than precisely.

Difficulty Score

Dimension	Score	Why
ML / AI	8 / 10	Protein language models, structure prediction, immunogenicity modeling, multi-modal training across sequence + structure + experimental data -- all current-generation hard problems
Data	9 / 10	The tissue biobank and proprietary protein-binding experimental database compound in value over time; no amount of money buys you the same data instantly
Backend	5 / 10	HPC bioinformatics pipelines are operationally heavy but technically well-understood; Nextflow / Snakemake / cloud HPC are proven patterns
Frontend	2 / 10	B2B / pharma-facing; internal candidate management dashboards, no consumer surface
DevOps	5 / 10	GPU-heavy compute for protein modeling, but AWS Batch + S3 + standard MLOps tooling gets you there

The Moat

Let's separate what's replicable from what isn't.

What's replicable: the core toolchain. AlphaFold is open source. ESM-2 is open source. The insight that parasites modulate immunity is not new in academic circles -- the field has studied this for decades under the "old friends hypothesis." A competitor starting today with $20M and a team of computational biologists and parasitologists could run the same basic pipeline.

What's not easily replicable:

The data flywheel. Every protein characterized, every binding experiment run, every tissue sample banked becomes training data for better predictions and cheaper validation cycles. Data moats compound asymmetrically -- the gap between Ditto and a competitor who starts today grows every month, not linearly but accelerating as models improve from proprietary signal. By the time any competitor has a validated hit, Ditto will have a portfolio.

The team. Adair Borges published 50+ papers on host-pathogen interactions and co-invented an anti-CRISPR protein. Emily Weiss brings Illumina-scale genomics infrastructure experience. Dennis Sun has seen $500M+ biotech operations from the inside. This intersection of evolutionary biology, computational genomics, and pharmaceutical development -- in three people who've already worked together for years -- you don't assemble by posting on LinkedIn. The team is the thesis and the moat in one.

Drug development timelines are asymmetric. Even if a large pharma player walked in tomorrow with unlimited resources and an identical approach, the regulatory path for a novel protein therapeutic takes years. Phase I alone is 12-18 months after IND filing. Ditto's validated candidates, once they enter the clinic, will have first-mover advantage that no amount of money can buy back. Time in drug development is irreplaceable.

The realistic threat isn't a YC startup imitating them -- it's a large pharma deciding this space is worth $500M to enter properly. Even then, Ditto's lead in proprietary data and established experimental pipelines gives them something to sell at a significant exit multiple.

Replicability Score: 72 / 100

The concept is public. The tools are open source. The insight has academic precedent. None of that makes Ditto easy to replicate. The proprietary protein binding dataset and immunogenicity biobank compound every month they operate. The team's specific expertise is genuinely scarce. And the clinical development timeline means that even being "right" creates a decade of structural advantage once candidates enter trials.

This isn't a 90+ score -- there's no hardware moat, no regulatory capture, and the AI components are, in principle, replicable by a well-funded competitor. But a score in the low 70s respects what they've actually built: a systematic approach to a search space that's 98% unexplored, prosecuted by the people most qualified to find things in it, anchored by proprietary data that only exists because they started first. That's a real company.

Get the free daily brief every morning

Every morning the day's AI news, new AI startups and new funding rounds. Free and takes a few minutes to read, unsubscribe at any time.

Join 64,000 other subscribers.

Build This Startup with Claude Code

Complete replication guide, install as a slash command or rules file

# Build a Parasite Protein Drug Discovery Platform (Ditto Bio Clone)

## Step 1: Set Up Your Protein Database

```sql
CREATE TABLE organisms (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  taxon_id TEXT UNIQUE NOT NULL,
  scientific_name TEXT NOT NULL,
  host_type TEXT, -- virus, worm, tick
  immune_relevance_score FLOAT
);

CREATE TABLE proteins (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  organism_id UUID REFERENCES organisms(id),
  uniprot_id TEXT,
  sequence TEXT NOT NULL,
  length INTEGER,
  characterization_status TEXT DEFAULT 'uncharacterized',
  immune_target_prediction TEXT[],
  embedding VECTOR(1280),
  plddt_score FLOAT,
  pipeline_stage TEXT DEFAULT 'ingested'
);

CREATE TABLE binding_experiments (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  protein_id UUID REFERENCES proteins(id),
  target_protein TEXT NOT NULL,
  assay_type TEXT,
  kd_nm FLOAT,
  result TEXT
);

CREATE TABLE immunogenicity_samples (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  protein_id UUID REFERENCES proteins(id),
  t_cell_response TEXT,
  epitope_mapping JSONB
);
```

Ingest from NCBI RefSeq, UniProt REST API, ViPR (Virus Pathogen Resource), and WormBase. Use Biopython Entrez for NCBI, async HTTP for UniProt. Queue with Celery + Redis. Target: primate-infecting viruses, helminths (Ascaris, Schistosoma), tick species (Ixodes, Amblyomma).

## Step 2: ESM-2 Protein Embeddings

```python
import esm, torch, numpy as np

model, alphabet = esm.pretrained.esm2_t33_650M_UR50D()
batch_converter = alphabet.get_batch_converter()
model.eval()

def embed_protein(sequence: str) -> np.ndarray:
    data = [("protein", sequence)]
    _, _, batch_tokens = batch_converter(data)
    with torch.no_grad():
        results = model(batch_tokens, repr_layers=[33])
    return results["representations"][33].mean(dim=1).squeeze().numpy()
```

Store 1280-dim embeddings in PostgreSQL with pgvector extension:
```sql
CREATE INDEX ON proteins USING ivfflat (embedding vector_cosine_ops) WITH (lists=100);
```

Use cosine similarity to cluster by putative function and surface candidates similar to known immunomodulators even with low sequence identity.

## Step 3: AlphaFold Structure Prediction Pipeline

Deploy via LocalColabFold on A100 GPU instances. Batch process top candidates by ESM-2 similarity score:

```python
import subprocess

def predict_structure(fasta_path: str, output_dir: str) -> str:
    subprocess.run([
        "colabfold_batch", fasta_path, output_dir,
        "--model-type", "alphafold2_ptm",
        "--num-recycle", "3",
        "--amber",
    ], check=True)
    return output_dir

def extract_plddt(pdb_path: str) -> float:
    scores = [float(l[60:66]) for l in open(pdb_path) if l.startswith("ATOM")]
    return sum(scores) / len(scores)
```

Only advance candidates with mean pLDDT > 70. Store PDB files in S3 keyed by protein ID.

## Step 4: Molecular Docking Against Immune Targets

Use DiffDock (neural docking) for protein-protein binding prediction. Maintain a library of validated human immune drug targets:

```python
TARGET_LIBRARY = {
    "TNF_alpha": "s3://bucket/targets/tnf_alpha.pdb",
    "IL6R": "s3://bucket/targets/il6r.pdb",
    "JAK1": "s3://bucket/targets/jak1.pdb",
    "PD1": "s3://bucket/targets/pd1.pdb",
    "IL4Ra": "s3://bucket/targets/il4ra.pdb",
}

def dock_against_all_targets(ligand_pdb: str) -> list[dict]:
    results = []
    for target_name, target_pdb in TARGET_LIBRARY.items():
        resp = requests.post("http://diffdock-server/dock",
            json={"receptor": target_pdb, "ligand": ligand_pdb})
        results.append({"target": target_name, **resp.json()})
    return sorted(results, key=lambda x: x["confidence"], reverse=True)
```

Flag any candidate with predicted Kd < 10 nM as a high-priority wet lab hit.

## Step 5: Immunogenicity Prediction Module

The most defensible piece. Train a classifier on your tissue biobank data:

```python
from sklearn.ensemble import GradientBoostingClassifier

def extract_features(sequence: str, embedding: np.ndarray) -> list:
    return [
        len(sequence),
        calc_hydrophobicity(sequence),       # BioPython ProtParam
        calc_isoelectric_point(sequence),
        count_mhcii_epitopes(sequence),      # NetMHCIIpan API
        blast_human_identity(sequence),      # identity to human proteome
        *embedding[:100],                    # first 100 ESM-2 dims
    ]

# Train on samples from your biobank
clf = GradientBoostingClassifier(n_estimators=300, max_depth=4, learning_rate=0.05)
clf.fit(X_train, y_train)  # y=1 if immunogenic, 0 if tolerated

def predict_immunogenicity_risk(sequence: str, embedding: np.ndarray) -> float:
    return clf.predict_proba([extract_features(sequence, embedding)])[0][1]
```

Build a LIMS to log all tissue samples, ELISpot assays, and T-cell expansion results. Every data point improves the model.

## Step 6: Candidate Pipeline Dashboard (Next.js + Supabase)

Pipeline stages: ingested -> embedded -> structure_predicted -> docking_complete -> immunogenicity_scored -> wet_lab_queued -> wet_lab_complete -> lead

```typescript
// pages/api/candidates.ts
export async function GET(req: Request) {
  const { data } = await supabase
    .from('proteins')
    .select('id, sequence, pipeline_stage, plddt_score, predicted_function, binding_experiments(*)')
    .eq('pipeline_stage', 'wet_lab_queued')
    .order('plddt_score', { ascending: false })
    .limit(50);
  return Response.json(data);
}

// Advance a candidate
export async function POST(req: Request) {
  const { protein_id, next_stage } = await req.json();
  await supabase.from('proteins')
    .update({ pipeline_stage: next_stage, updated_at: new Date().toISOString() })
    .eq('id', protein_id);
}
```

Add a Kanban view of candidates by pipeline stage, binding affinity heatmaps by target, and immunogenicity risk scores.

## Step 7: Infrastructure and Deployment

**Compute:** ESM-2 workers on A10G spot instances (g5.xlarge ~$1.01/hr). AlphaFold on A100 (p4d.24xlarge, ~20 min per protein). DiffDock on c6i.32xlarge CPU fleet. Nextflow for workflow orchestration across AWS Batch.

**Cost to process 1M proteins:**
- ESM-2 embeddings: ~$3,000
- AlphaFold (top 10K hits): ~$8,000
- Storage (S3 + RDS): ~$500/month
- Total bootstrapping: ~$15,000-20,000

**The real budget isn't compute -- it's wet lab.** Each binding assay (SPR) runs $500-2,000. An animal efficacy study is $20,000-100,000. Budget $500K+ for experimental validation of your first 50 candidates.

**The moat reminder:** The infrastructure above is table stakes. The tissue biobank -- the collection, the assays, the immunogenicity training data -- is what separates a drug discovery company from a Python script that calls AlphaFold. Build the biobank from day one, log every experiment, and treat it as your most valuable asset.

Install for:

claude-code-skills.md

TopicsYC W2026 Biotech Drug Discovery Autoimmune Disease AI Parasite Biology Protein Therapeutics Computational Biology

Written by

Daniel Singer

Editor, StartupHub.ai

Daniel Singer is the editor of StartupHub.ai, a technology expert and thought leader on AI and its applications across sectors, from fintech and healthcare to developer tooling and consumer software. He writes and tests the tools covered here thoroughly and regularly, and built StartupHub.ai to give founders, operators and buyers a clearer read on what they are actually being sold.

Test your Agent Readiness now

Paste your website. How well ChatGPT, Claude and the other agents can read and use a site, in about a minute, free.