Atlas + Graffold for Drug Discovery¶
Every research program should make the next one smarter.
Atlas runs the discovery reasoning. Graffold makes it permanent, connected, and queryable — fusing institutional knowledge, published literature, and AI reasoning into one source of truth that compounds with every program.
The opportunity¶
Atlas's 22-agent pipeline produces extraordinary output — target maps, kill decisions, mechanism analyses, evidence trails. But on its own, each run is an island: the intelligence is scattered across files and forgotten once the program ships. Every new program starts from a blank slate:
The same markers and targets are found again and again, run after run.
Targets that were already killed get re-proposed — the lesson is lost.
Insight from one disease area never transfers to the next.
Graffold closes the loop — turning Atlas's per-run brilliance into durable, compounding institutional intelligence.
How they fit together¶
Atlas reasons. Graffold remembers and connects. The knowledge graph fuses institutional memory, published literature, and every prior program's accumulated reasoning into one deduplicated, provenance-tracked graph — and Atlas runs its discovery reasoning on top of it, writing its decisions back so the graph compounds:
flowchart TB
S["Institutional Knowledge<br/><small>intake forms, prior programs,<br/>known dead ends, constraints</small>"] --> KG[("Unified<br/>Knowledge Graph")]
L["Published Literature<br/><small>PubMed + Europe PMC full-text,<br/>1,000+ papers auto-extracted</small>"] --> KG
P["Prior programs' graph<br/><small>every past run's evidence,<br/>decisions & dead ends</small>"] --> KG
KG --> A["Atlas Reasoning<br/><small>22-agent pipeline reasons<br/>over the graph</small>"]
A --> Q["Ask anything<br/><small>natural-language queries,<br/>cited answers</small>"]
A -.->|"decisions + novel proposals<br/>written back as new nodes"| KG
linkStyle 5 stroke:#888,stroke-dasharray:5 5The knowledge graph is the substrate: institutional memory, literature, and every prior program's graph fuse into it. Atlas reasons over that graph — and its decisions and novel proposals are written back as new nodes, so the graph compounds. Each run starts from everything the last one learned; you ask Atlas, and Atlas is standing on the accumulated graph.
Case study: post-weaning ETEC in pigs¶
We built a complete drug-discovery knowledge graph for a live program — enterotoxigenic E. coli (ETEC) post-weaning diarrhea — fusing all three layers across 1,000 papers of literature.
Explore the graph¶
7,880 connected nodes shown (of 8,752 total — 872 isolated single-mentions are omitted from the layout), 18,274 of 20,150 relationships. Node size = connectivity, color = type. Drag to explore, scroll to zoom, click any node to inspect. Use the Fullscreen button for presentation.
The 150 most-connected entities — the backbone of the graph. Easier to read; shows where the evidence converges.
GPU-accelerated layout of the full graph via Graphistry — handles the complete node set with smooth interaction.
What went in — the three layers¶
Each tab shows a sample of what Graffold ingested. All three merge into the single graph above.
46-node backbone from the program intake form — encodes what the team already knows so the graph never re-proposes a dead end. Pushed via the structured entity API (no LLM needed).
# Institutional knowledge is pushed directly — no extraction needed
curl -X POST http://localhost:8001/v1/entities \
-H "Content-Type: application/json" \
-d @etec-intake.json
Program: Post-weaning ETEC in pigs
"Disarm virulence, feed-additive pathway, delivered at weaning"
Targets: FedF — F18 fimbrial adhesin tip (mediates gut attachment)
FaeG — F4 (K88) major fimbrial subunit
LT/ST — heat-labile / heat-stable enterotoxins
GM1 — LTB binding receptor
Constraints: feed-additive only · pellet-stable · no vaccine · no small-molecule
KILLED (do not re-propose):
• Organic acids • Carvacrol
• Essential oil blends • Standard Bacillus blends
• Zinc nanoparticles • Insoluble fiber
Assays: FITC-D · TEER · IPEC-1/J2 adhesion
Benchmark: ZnO (state-of-art being replaced)
46 entities · institutional backbone · $0 — 7 dead ends, 3 internal programs, 5 constraints, 2 hypotheses, assays, and the ZnO benchmark being displaced.
1,000 papers pulled straight from Europe PMC (full-text, Open Access) with PubMed abstract fallback, extracted by Llama 3.3 70B. A broadened 49-query sweep across ETEC core + adjacent biology — a single product command, no custom scripts.
graffold-ingest pipeline --source europepmc \
--query "F18 ETEC adhesion piglet FedF" \
--full-text --limit 50 \
--service bedrock-llama
fetched: F18 ETEC adhesion piglet FedF (13 new)
fetched: F4 ETEC FaeG fimbriae adhesion swine (34 new)
fetched: post-weaning diarrhea enterotoxigenic E. coli (52 new)
fetched: edema disease pig Shiga toxin STx2e (70 new)
fetched: ETEC heat-labile enterotoxin LT neutralization (89 new)
fetched: LTB GM1 ganglioside binding epithelium (121 new)
fetched: nanobody VHH F18 fimbriae inhibition E. coli (268 new)
fetched: FaeG LTB vaccine ETEC mucosal immunity (276 new)
...
1,000 papers (207 full-text) → 2,035 chunks → 15,388 entities
- Full text, not abstracts — Europe PMC OA gives ~20K chars/paper vs ~1,800 for an abstract
- Relevance gate drops off-topic contamination before it enters the graph
- Fuzzy dedup (rapidfuzz) collapses name variants ("heat-stable toxin" → STa)
- Checkpointed — long runs resume after interruption
- ~$8 for the full 1,000-paper sweep on Llama 3.3 70B (~50 min, ~5× cheaper than Claude)
A real Atlas 22-agent run on the phibro-etec program — adds decisions, kill rationale, and novel proposals. Ingested by watching the filesystem; zero Atlas code changes.
# Point graffold at the finished Atlas program directory
graffold-ingest ingest ~/atlas/programs/phibro-etec/v1/
Ingesting Atlas ETEC run: v1
Source: gpt-oss-120b bakeoff, phibro-etec
Loaded 14 phase files
Chunked into 204 pieces
Extracted: 3,761 entities, 3,550 relationships
Resolved: 1,162 entities (2,599 merged into existing)
Runtime: 517s
The graph now has:
literature (external) + Atlas (decisions)
+ institutional seed (kills, constraints, hypotheses)
Atlas contributes the reasoning layer: which targets to pursue, why others were killed, and novel proposals no literature search would surface. The resolver merges 2,599 of its entities into existing literature/seed nodes — that overlap is exactly where the three layers reinforce each other.
Harmonization — one entity, one node¶
Extraction across 1,000 papers inevitably fragments the same entity into dozens of variants — "F18 ETEC", "F18 fimbriae", "E. coli F18" all describe one thing. A post-hoc harmonization pass collapses these into canonical nodes:
Harmonization is layered for scientific safety — it never over-merges:
- Deterministic alias rules with a type guard (a Target rule never swallows an internal Program)
- Protected types — Program, Hypothesis, Killed, and Constraint nodes are never merged
- Embedding similarity (0.90 cosine) with a differing-code guard so F17 ≠ F18, IL-6 ≠ IL-10, STa ≠ STb stay distinct
The result is a graph where each biological entity is one node with all its evidence attached — not scattered across dozens of near-duplicates.
What the graph reveals¶
Scope: this POC is the knowledge graph, not the molecule proposal
Graffold builds and serves the knowledge graph — it maps the disease biology (virulence factors, toxins, host pathways, chokepoints), remembers every prior decision, and surfaces what is known, ruled out, or unproven. It does not propose the intervention molecule. Turning a chokepoint (“the LT/STb enterotoxins drive secretory diarrhea”) into a candidate (“a binder that neutralizes the toxin / blocks F4/F18 adhesion”) is Atlas's job — the 22-agent reasoning pipeline. The candidate shortlist below comes from a real Atlas run; Graffold makes it durable, connected, and queryable.
What Graffold (the graph) surfaces¶
The graph does not rank targets by connectivity or node degree — degree mostly measures how often the literature mentions something, which rewards the already-famous and buries the novel. It answers the questions no single run or document can: what disease biology have we mapped, what was ruled out and why, which claims lack validating evidence, and what connections exist that no individual source stated.
Disease-biology map (graph support). These are the ETEC virulence factors and disease entities the graph has mapped, with a coarse “present and connected” degree in parentheses. These are the disease's chokepoints — the intervention points Atlas reasons over — not a druggable-target ranking (the enterotoxins are the disease agents themselves; you neutralize or block them, you don't inhibit them like an enzyme):
| Disease chokepoint / virulence factor | Type | Graph support (degree) |
|---|---|---|
| Adhesin system (F18/F4 attachment) | Adhesion | high (402) |
| LT enterotoxin | Toxin | high (160) |
| Heat-stable enterotoxin (STb) | Toxin | high (154) |
| Shiga toxin (Stx2e) | Toxin | high (138) |
| F4 fimbriae | Adhesion | present (115) |
Structural inference — connections no single source made¶
This is what generic graph-RAG cannot do: it retrieves what a document says, not what the graph's structure implies. Shared-neighbor analysis surfaces entity pairs that are indirectly linked across many intermediates but never directly stated in any one paper. On the ETEC graph the strongest are the fimbrial-adhesin family relationships — real disease biology recovered purely from structure (again: this is mapping the disease, not proposing a drug):
| Entity A | Entity B | Shared neighbors |
|---|---|---|
| F5 fimbriae | F6 fimbriae | 21 |
| Adhesin system | Shiga toxin (Stx2e) | 21 |
| F41 | F4 fimbriae | 20 |
| F5 fimbriae | F4 fimbriae | 19 |
The takeaway for the program team
Atlas — reasoning over the graph's disease-biology map — proposed a shortlist of 150 feed-additive-compatible candidates. Graffold's contribution is making that reasoning durable and queryable: every proposal, its supporting evidence, and every kill decision live in one graph the next program inherits. The value split across three buckets:
- Corroborated the team's own untapped hypotheses — STb-binding agents and recombinant LTB were in the intake form but under-explored; the graph's literature layer links them to strong supporting evidence, so Atlas could weigh them properly.
- New leads from Atlas reasoning over the fused graph — egg yolk IgY, insect-meal feed additives (H. illucens, T. molitor), and a bivalent VHH nanobody construct emerged from Atlas cross-referencing literature + prior reasoning; the graph is why that context was available in one place.
- Dead ends stay dead — the seven killed approaches (organic acids, carvacrol, zinc nanoparticles…) are stored as first-class nodes, so a future run querying “should we try carvacrol?” gets an immediate, sourced “no.” This memory is Graffold's, and it's the moat.
Net result: Atlas does the discovery reasoning; Graffold ensures the next program starts from everything this one learned — an hour of compute keeps the graph current, and every program makes the next one sharper.
Entity composition¶
The maturity path¶
Atlas generates discovery reasoning; Graffold remembers and connects it. Together they compound — and the roadmap points to a fine-tuned model that queries the accumulated graph directly. Microsoft GraphRAG is shown as the closest graph-RAG baseline; note that the shared primitives are commoditized — the moat is everything below the first row.
| Classic research | Microsoft GraphRAG | Atlas alone | Atlas + Graffold | + Fine-tuned KG model (roadmap) | |
|---|---|---|---|---|---|
| Discovery speed | Months per review | Fast retrieval, no reasoning | ~30 min per program | Minutes — prior work pre-loaded | Seconds — direct KG reasoning |
| Graph-RAG primitives (extraction, Leiden, DRIFT, Parquet) | No | Yes (commoditized) | No | Yes (parity) | Yes + model priors |
| Entity resolution | Manual | Name-match only | Per-run | 5-strategy + semantic harmonization | Canonical in weights |
| Biomedical + literature connectors | Manual | No | No | UniProt/MONDO/PubChem + Europe PMC | Built-in domain knowledge |
| Memory across programs | Tribal knowledge | None | None — each run isolated | Permanent, cross-program graph | Internalized in model weights |
| Dead-end avoidance | Rediscovered the hard way | No decision layer | Re-proposes killed targets | Kills preserved, never repeated | Model refuses known dead ends |
| Evidence grounding | Manual citation checking | Retrieval citations | Per-run, not retained | Cited links + fact verification | Grounded with provenance |
| Deployment | — | Azure-centric | Local pipeline | Neo4j / Neptune / Spanner / DuckDB | Any + hosted model |
| Competitive moat | None | Open-source tool | Pipeline quality | Accumulated proprietary graph | A model no competitor can replicate |
On graph-RAG primitives: Graffold shares the graph-RAG foundations — LLM extraction, Leiden communities, local/global/DRIFT retrieval, Parquet output — with Microsoft GraphRAG, LlamaIndex, and LangChain. Those primitives are commoditized and reproducible; they're table stakes, not the moat. What a generic graph-RAG tool cannot retrofit cheaply is the rest of this table: canonical domain resolution (80K HGNC aliases, UniProt/MONDO/PubChem grounding, a code-aware harmonizer that collapsed F18 from 32 nodes to 3), per-customer memory that compounds across programs, and fusion of a discovery pipeline's actual kill/advance decisions with evidence. Graffold was developed independently — the biomedical discovery-memory thesis was the starting point, not a bio layer added on top. The graph is a means; the discovery-memory system is the product.
Each step compounds the last. Atlas produces the reasoning. Graffold makes it permanent and queryable. A fine-tuned model — trained on the accumulated graph — turns years of institutional discovery into a conversational domain expert that no competitor starting fresh can match.
flowchart LR
C["Classic<br/>research"] --> GR["GraphRAG<br/>(graph retrieval)"]
GR --> AT["Atlas<br/>(AI reasoning)"]
AT --> AG["Atlas + Graffold<br/>(persistent KG)"]
AG --> FT["+ Fine-tuned<br/>KG model"]
style AG fill:#2ecc71,stroke:#27ae60,color:#0d1117
style FT fill:#6366f1,stroke:#4f46e5,color:#fffMeasured value: reliability, speed, cost { #value-study }¶
What "the graph buys a discovery pipeline" means¶
A discovery pipeline like Atlas has to answer the same kinds of questions over and over: is this target worth pursuing or should it be killed? what evidence supports this claim? what's already been tried? There are two ways to answer them:
- Ask the model — let the LLM reason from its training + whatever context is in the prompt. Fast, but the answer isn't reproducible and isn't grounded in a specific evidence base.
- Do live research — send the question out to PubMed/literature each time, read the results, synthesize. Grounded, but slow and expensive, and repeated for every query.
The knowledge graph is a third path: the literature research is done once, at ingestion, and distilled into a graph. Every subsequent question is then a cheap, deterministic lookup against that graph instead of a fresh model guess or a fresh literature sweep. "What the graph buys" is the measurable difference between those paths — in reliability (does the answer stay the same?), speed (how long per query?), and cost (tokens + external calls per query?).
How the study was run¶
Controlled comparison on three real disease programs (Zoetis mastitis, Elanco coccidiosis, Alltech mucin), model = Bedrock DeepSeek-v3.2, KGs served over the /v1/atlas/* API from their harmonized graphs. Two experiments:
Experiment 1 — verdict stability. A pre-registered probe set of 6 targets per disease (a deliberate mix of likely-validated, likely-killed, and ambiguous, so there's room to flip). Each target is asked the identical question 7 times:
"For {disease} drug discovery, is target '{X}' VALIDATED or should it be KILLED? Answer one word."
- Model arm: the LLM answers directly (temperature 0.7).
- KG arm: the same question hits
validate_targetsagainst the graph. - Metric — flip rate: the fraction of the 7 runs that disagree with the most common answer. 0% = perfectly stable (same verdict every time); 50% = a coin-flip.
Experiment 2 — speed & cost. The same target-proposal question run 30 times per arm across the three diseases, three arms:
- KG-grounded — model reasons over graph context.
- Live research — model does real PubMed retrieval per query.
- Control — model alone, no grounding.
- Metrics: wall-clock latency, total tokens (prompt + completion), and PubMed API calls per query — all captured per-run from the pipeline's own metrics.
The scorecard¶
The honest result — what's proven (including corroboration as a truth proxy), and the one thesis ruled out (full per-run numbers and the reproduce-it scripts are in the KG Value Study):
| Axis | Result | Status |
|---|---|---|
| Reliability | The model flips its validated/killed verdict on ~25% of targets across identical prompts; the KG's verdict is deterministic — 0% flip | Demonstrated |
| Speed | KG grounding is 1.8× faster than live PubMed research (18s vs 33s/query) | Demonstrated |
| Cost | 5.7× fewer tokens/query (~32k saved), ~6 PubMed round-trips avoided — research is paid once at ingest, then amortized to a cheap lookup | Demonstrated |
| Traceability | Per-edge provenance (evidence_ref) — ~38% of edges carry a real citation on fresh ingest, so a verdict can show its sources | Demonstrated |
| Contradiction detection | The differentiator. Surfaces entity pairs where different papers assert opposing relationships, with per-side source counts — a contested-claim / risk-triage signal a single confident model call structurally hides | Demonstrated |
| Novel cross-disease insight | On well-published diseases, a strong model generates equally-good cross-disease bridges unaided — the KG does not beat it here | Ruled out (honest) |
| Corroboration as a truth proxy | Multi-source support is proven non-random (agreement null, p≤0.001) and predictive — corroborated edges recur in held-out literature 8–14× more than single-source ones. A strong label-free proxy; ground-truth labelling still owed. See the source study | Demonstrated (proxy) |
The raw numbers¶
Verdict stability — flip rate across 7 identical runs per target:
| Program | Model flip rate | KG flip rate |
|---|---|---|
| Zoetis — mastitis | 29% | 0% |
| Elanco — coccidiosis | 29% | 0% |
| Alltech — mucin | 21% | 0% |
Speed & cost — mean over 30 queries/arm, all three diseases:
| Arm | Latency | Tokens/query | PubMed calls |
|---|---|---|---|
| KG-grounded | 18.4s | 6,928 | 0 |
| Live PubMed research | 33.3s | 39,179 | 5.6 |
| Model only (control) | 17.0s | 4,058 | 0 |
KG vs live research: ~1.8× faster, ~5.7× fewer tokens (~32k saved/query), ~6 PubMed round-trips avoided. Live research is a fixed cost paid once at ingestion; the graph amortizes it to a cheap reusable lookup, so the KG wins on cost from the first reuse onward.
Why reliability matters most. A model at temperature returns a different validated/killed call on roughly one in four targets across identical prompts — a real liability for an auditable pipeline. The KG's verdict is a deterministic query: bit-identical every run. It stabilizes the decision layer.
The honest boundary. Reliability measures consistency, not truth — the KG returns the same answer every time, but whether that answer is right depends on ingestion quality. Corroboration has since been tested rigorously and holds up as a proxy: multi-source support is non-random (agreement null, p≤0.001) and predicts recurrence in held-out literature (8–14× lift) — a strong, label-free correctness proxy, though ground-truth labelling is still owed. One thesis was ruled out and we state it plainly: "novel cross-disease insight beats the model" — on well-published diseases a strong model generates equally-good bridges unaided. The value is operational reliability + risk triage + corroboration you can audit, not a raw-intelligence upgrade.
Contradiction detection — the differentiator¶
The one capability a single model call structurally cannot reproduce: the graph surfaces entity pairs where different papers assert opposing relationships — e.g. a compound reported as both ACTIVATES and INHIBITS a pathway, or a target both KILLED and PROPOSED — each with per-side source counts.
- A single LLM call collapses a contested literature into one confident answer and hides the controversy.
- The KG shows the contested distribution: "5 papers say X activates this, 3 say it inhibits it." That's a risk-triage flag — contested targets are the ones to scrutinize before committing spend.
- The trustworthy subset filters to distinct-paper (not same-paper extraction noise) and well-sourced (≥2 papers each side) contradictions.
This is a contested-claim capability that lives only in the accumulated graph — the model, by construction, gives you its single best guess and no view of the disagreement behind it.
Read these numbers honestly
All figures are from DeepSeek-v3.2 on Bedrock over specific animal-health and CKD corpora — they're real measurements, not universal constants. Contradiction detection flags controversy, it does not adjudicate it, and its yield scales with full-text corpus richness. Reliability is consistency, not proven correctness.
This is the defensible story: the KG makes discovery deterministic, fast, cheap, auditable, and contradiction-aware — where the model alone is a nondeterministic, expensive, unciteable, over-confident guess. It's an operational-reliability and risk-triage tool, and correctness compounds as the graph scales.
Beyond GraphRAG: where the moat lives¶
GraphRAG (and LlamaIndex, LangChain) provide the plumbing — extraction, communities, retrieval. Those primitives are commoditized and reproducible. The moat is what sits on top of them — and it's exactly what a generic graph-RAG tool cannot retrofit cheaply:
80K HGNC aliases, UniProt/MONDO/PubChem grounding, and a code-aware harmonizer (F18: 32 nodes to 3, without merging F17≠F18 or STa≠STb). A substantial biomedical engineering effort plus ongoing curation — not a weekend of prompt-wiring.
Every kill decision, evidence link, and target trajectory accumulates across programs. The accumulated graph is proprietary — it can't be downloaded, and a new entrant can't replicate years of discovery history.
Atlas's actual advance/kill decisions fuse with literature and institutional knowledge into one graph. Not just "what the papers say" — what the discovery pipeline decided and why, grounded in evidence.
The primitives are a means; the compounding discovery-memory the graph holds is the defensible asset. Each program deepens it, and the deeper it gets the harder it is for anyone starting fresh to catch up.
What makes the moat durable¶
| Capability | Why it compounds |
|---|---|
| Atlas + Graffold together | Reasoning engine + permanent memory — neither alone delivers compounding returns |
| Three-layer fusion | Institutional + literature + AI reasoning in one graph |
| Full-text literature | Europe PMC OA (~20K chars/paper), not just abstracts |
| Canonical resolution | UniProt/MONDO/PubChem + fuzzy dedup — variant names collapse automatically (F1 = 1.00) |
| Graph-verified answers | DRIFT-diamond search fans out parallel sub-queries, then a checker node validates each answer's cited entities against the graph — hallucinated paths are dropped before synthesis, not "ask the LLM if it looks right" |
| Cheap inference | Llama 3.3 70B backend — a 1,000-paper sweep costs ~$8 in ~50 min |
| Full provenance | Every literature-extracted fact traces to its source sentence and document; seed and decision nodes carry their run/origin — audit-ready |
| No lock-in | Parquet source of truth — rebuild any graph database from files |
| Fine-tuning-ready | Our graph becomes a labeled corpus for training a domain-expert model |
Get started¶
Install with uv (recommended) or pip. Requires Python 3.12+.
# Clone + install everything (LLM backends, graph, storage)
git clone https://github.com/graffold/graffold-ingest
cd graffold-ingest
uv sync --extra all
# Or install just what you need
uv sync # core only
uv sync --extra llm # + Bedrock / OpenAI backends
uv sync --extra graph # + Leiden community detection
uv sync --extra storage # + DuckDB analytics
# Or the standalone binary (no Python needed, source stays private)
curl -fsSL https://github.com/graffold/graffold-ingest-releases/releases/latest/download/install.sh | sh
One-time setup writes ~/.graffold/config.toml and validates your API key.
graffold-ingest init \
--api-key sk-ant-... \
--atlas-dir ~/atlas/programs/
# Verify config, backend connectivity, and store
graffold-ingest status
Config captures your default LLM service, graph backend, parquet output dir, and the Atlas programs directory — so later commands need no flags.
Feed the graph from any source. For a full literature corpus, one command runs fetch → extract → resolve → publish → harmonize:
# Literature corpus — many queries, deduplicated, checkpointed, harmonized
graffold-ingest ingest-corpus \
--queries queries.txt --source pubmed \
--service bedrock-llama \
--per-query 40 --paper-cap 1000 \
-o ~/.graffold/parquet/etec --harmonize
# Watch Atlas output — incremental, config-aware daemon
graffold-ingest watch
# One-shot ingest of a single program directory
graffold-ingest ingest ~/atlas/programs/etec-pigs/v1/
# Collapse fragmented entities into canonical nodes
graffold-ingest harmonize ~/.graffold/parquet/etec
# Natural-language question over the graph (DRIFT search)
graffold-ingest ask "What feed-additive candidates target F18 adhesion?"
# Generate prior-knowledge.md for the next Atlas run
graffold-ingest context "post-weaning ETEC" -d ~/atlas/programs/etec-v2/v1/
# Trace a single target's full history across runs
graffold-ingest trajectory FedF
From install to accumulating institutional memory. See the onboarding guide, API + CLI reference, live benchmark, or cross-program memory demo.
Atlas does the discovery reasoning. Graffold makes it permanent, connected, and compounding — so every program starts where the last one ended.