BACKGROUND & MOTIVATION
Human genomes contain millions of genetic variants, but identifying which changes may contribute to disease is a much harder problem than simply detecting that a mutation exists. A variant can alter a DNA sequence without necessarily producing a harmful biological effect, while other variants may disrupt important genomic patterns and contribute to disease. Interpreting these differences is therefore an important problem in genomics and precision medicine.
MutaScope began as an exploration of how recent advances in biological foundation models could be applied to this problem. Instead of training a new genomic model from scratch, I investigated Evo2, a large genomic foundation model trained to learn patterns from biological sequence data. The central idea was to use the model as an inference engine and examine how its evaluation of a DNA sequence changes when a specific genetic variant is introduced.
The project became both an AI experiment and a software-engineering challenge. Beyond generating model scores, I wanted to build an interface where a user could specify a genomic variant, retrieve the corresponding reference sequence, introduce the mutation, analyse both sequences with Evo2, and compare the result with known clinical information when available.
THE PROBLEM
Modern sequencing technologies can identify differences between an individual’s genome and a reference genome, but the presence of a variant alone does not explain whether that change is harmless, potentially damaging, or associated with disease. Variant interpretation therefore requires additional evidence and is particularly challenging for variants whose clinical significance is uncertain or poorly documented.
MutaScope explores whether a genomic foundation model can provide another computational signal for investigating this problem. Given a genomic location and an alternative allele, the system constructs the corresponding reference and mutated DNA sequences and evaluates both using Evo2. The difference between the resulting model scores is then used as the basis for estimating how strongly the mutation disrupts the sequence patterns learned by the model.
The project does not attempt to replace clinical genetic testing or professional variant interpretation. Instead, it investigates how a large pretrained genomic model can be incorporated into an experimental variant-analysis workflow.
Can changes in sequence likelihood produced by a genomic foundation model provide a useful computational signal for investigating the potential effect of genetic variants?
EXPERIMENT OBJECTIVE
The objective of MutaScope was to design and implement an experimental system for analysing single genetic variants using Evo2. Rather than developing or fine-tuning the underlying foundation model, the project focused on inference: retrieving the genomic context surrounding a variant, constructing reference and mutated sequences, evaluating both sequences with Evo2, and interpreting the difference between their model scores.
A second objective was to make this process accessible through a web application. Genomic model inference normally requires code, biological sequence handling, model infrastructure, and substantial computing resources. MutaScope therefore explores how these components can be abstracted behind a simpler interface and API-driven workflow.
EXPERIMENT PIPELINE
The MutaScope pipeline begins with information describing a genetic variant. The system retrieves the surrounding reference DNA sequence and verifies the nucleotide present at the specified genomic position. It then constructs a second version of that sequence in which the reference allele is replaced with the submitted alternative allele.
Both sequences are evaluated independently by Evo2. This produces a score for the original genomic context and another for the mutated sequence. MutaScope calculates the difference between these scores and uses that change as the primary computational signal for analysing the variant.
Where corresponding information is available, the result can also be compared with ClinVar, providing an external clinical reference alongside the model-derived analysis.
GENOMIC VARIANT
↓
GENOMIC COORDINATE + ALTERNATE ALLELE
↓
REFERENCE SEQUENCE RETRIEVAL
↓
VARIANT VALIDATION
↓
REFERENCE DNA SEQUENCE
+
MUTATED DNA SEQUENCE
↓
EVO2 7B INFERENCE
↓
REFERENCE SCORE vs VARIANT SCORE
↓
SCORE DIFFERENCE
↓
VARIANT EFFECT ESTIMATE
↓
CLINVAR COMPARISON
FOUNDATION MODEL
WHY EVO 2?
MutaScope uses Evo2 7B as its underlying genomic foundation model. The project does not train Evo2 or claim ownership of the model. Instead, Evo2 is treated as a pretrained inference engine whose learned representation of biological sequences can be applied to the variant-analysis experiment.
The reasoning behind the experiment is that a genomic foundation model learns statistical structure from large quantities of biological sequence data. If a mutation changes a sequence in a way that is less consistent with patterns learned by the model, the likelihood assigned to the mutated sequence may differ from that assigned to the original reference sequence.
MutaScope therefore compares the model’s evaluation of two nearly identical sequences. One contains the reference allele and the other contains the submitted mutation. This makes the change between the two model scores, rather than either score in isolation, the central signal investigated by the project.
SEQUENCE ANALYSIS
For every analysis, MutaScope needs to ensure that the difference observed by the model is associated with the submitted mutation rather than unrelated sequence changes. The system therefore begins by obtaining the reference genomic sequence surrounding the selected position.
The nucleotide at the requested position is checked against the expected reference allele. A mutated copy of the sequence is then created by replacing that nucleotide with the alternative allele while keeping the surrounding genomic context unchanged.
This produces two comparable inputs: the original reference sequence and the corresponding variant sequence. Because the sequences differ at the mutation being investigated, their Evo2 scores can be compared directly as part of the experiment.
REFERENCE SEQUENCE
... A C G T C A G T A ...
↓ MUTATION
VARIANT SEQUENCE
... A C G T T A G T A ...
↓
EVO2 evaluates both sequences independently
VARIANT SCORING
After constructing the two sequences, MutaScope sends each one through Evo2 and obtains a model score. The reference score represents how the model evaluates the original genomic sequence, while the variant score represents its evaluation after the mutation has been introduced.
The system then calculates the difference between these values. Conceptually, this allows the experiment to ask whether introducing the mutation makes the sequence appear more or less compatible with the genomic patterns represented by the model.
This score difference is used as an experimental signal for estimating variant effect. It should not be interpreted as direct biological proof of pathogenicity. Evo2 is providing a computational assessment of sequence likelihood, and MutaScope builds an interpretation layer around that signal.
Core concept
Reference Sequence → Evo2 → Reference Score Variant Sequence → Evo2 → Variant Score Variant Effect Signal = Variant Score − Reference Score
EXTERNAL VALIDATION
A model-generated score becomes more informative when it can be examined alongside existing biological evidence. MutaScope therefore incorporates ClinVar information when a corresponding variant record is available.
ClinVar contains submitted interpretations describing relationships between genetic variants and health conditions. Within MutaScope, this information serves as an external reference rather than training data for Evo2. The system can place the model-derived analysis beside an existing clinical classification so that the two sources of information can be compared.
This comparison is particularly important because agreement with an existing annotation can provide useful context, while disagreement can reveal cases that require deeper investigation. It does not establish that the model is clinically correct, and variants without suitable ClinVar evidence remain an important limitation for evaluation.
SYSTEM ARCHITECTURE
MutaScope was designed as a distributed application because running a large genomic foundation model requires substantially more computational resources than a conventional web application. The frontend was developed with Next.js and TypeScript, while the backend exposes the genomic analysis workflow through Python-based API services.
The backend coordinates the main stages of analysis: receiving variant information, retrieving the required genomic sequence, constructing the mutated sequence, invoking Evo2, calculating the score difference, and returning the result to the interface. Genomic reference data is retrieved through the UCSC Genome API, while ClinVar provides external information for comparison when available.
Evo2 inference is separated from the frontend and executed using GPU-backed infrastructure on Modal. This allows the computationally expensive model to run remotely while the user interacts with MutaScope through a conventional web interface.
USER ↓ NEXT.JS + TYPESCRIPT INTERFACE ↓ PYTHON / FASTAPI BACKEND ↓ GENOMIC DATA RETRIEVAL ↓ UCSC GENOME API ↓ REFERENCE + VARIANT SEQUENCES ↓ MODAL GPU INFRASTRUCTURE ↓ EVO2 7B ↓ VARIANT EFFECT ANALYSIS ↓ CLINVAR COMPARISON ↓ RESULT PRESENTATION
APPLICATION EXPERIENCE
One of the engineering goals behind MutaScope was to hide the complexity required to perform genomic model inference. Instead of manually retrieving DNA sequences, modifying nucleotides, loading a large model, and comparing outputs through Python code, the application coordinates these operations behind a web interface.
The user provides the information required to identify a variant, and the backend handles sequence retrieval, validation, mutation construction, model inference, score comparison, and available clinical-reference lookup. The resulting analysis is then returned to the frontend in a form that makes the reference sequence, mutation, model output, and interpretation easier to examine.
This interface transforms the project from a standalone model experiment into an interactive system for exploring genomic variants.
KEY FINDINGS
MutaScope demonstrated that a large pretrained genomic foundation model can be incorporated into an end-to-end variant-analysis workflow without retraining the underlying model. By evaluating reference and mutated versions of the same genomic context, the system can derive a comparative model signal that can be used to investigate how a mutation affects the sequence representation learned by Evo2.
The project also demonstrated an important systems challenge associated with foundation models. The AI model is only one component of the final application. Genomic coordinates must be handled correctly, reference sequences must be retrieved and validated, mutations must be introduced accurately, large-model inference must be executed on suitable hardware, and the resulting scores must be translated into information that can be examined by a user.
For me, this made MutaScope as much an experiment in AI systems engineering as it was an experiment in computational genomics.
LIMITATIONS
The most important limitation of MutaScope is that a difference in Evo2 sequence scores does not by itself establish whether a genetic variant causes disease. Pathogenicity is a complex biological and clinical question that can depend on gene function, protein consequences, inheritance patterns, population frequency, phenotype, experimental evidence, and other forms of clinical information that are not represented by a single model score.
The system should therefore be treated as an experimental research tool rather than a clinical genetic diagnostic system. ClinVar comparison provides useful external context when annotations are available, but it does not replace systematic validation across large, carefully curated variant datasets.
Another limitation is computational cost. Evo2 7B is substantially larger than the models typically embedded directly inside web applications, requiring remote GPU infrastructure for practical inference. This introduces dependencies on compute availability, latency, and infrastructure cost.
MutaScope therefore demonstrates technical feasibility and provides a platform for further experimentation, but additional benchmarking and biological validation would be required before making strong claims about pathogenicity-prediction performance.
FUTURE RESEARCH
The most important next step would be to evaluate MutaScope systematically against a large curated collection of variants with established clinical classifications. This would make it possible to measure how well Evo2-derived score differences separate pathogenic and benign variants using metrics such as sensitivity, specificity, precision, recall, F1 score, and AUROC.
Future experiments could also investigate whether the magnitude and direction of the score difference behave consistently across different genes, genomic regions, mutation types, and sequence-context lengths. Cases where the model disagrees with established annotations would be particularly valuable for error analysis.
The system could eventually incorporate additional biological evidence rather than relying primarily on sequence likelihood. Combining foundation-model signals with population frequency, conservation information, functional annotations, protein-level effects, and established variant databases could support a more comprehensive computational interpretation framework.
RESEARCH REFLECTION
MutaScope changed how I think about working with foundation models. The difficult part was not simply calling Evo2 and receiving an output. The more important questions were what that output actually represented, how two outputs could be compared meaningfully, and how much evidence would be required before turning a model-derived signal into a claim about a real biological phenomenon.
It also exposed me to a different scale of AI engineering. Unlike the smaller vision model I worked with in EyeNet, Evo2 requires specialised computational infrastructure and sits inside a larger pipeline involving genomic coordinates, external biological data, sequence construction, GPU inference, APIs, and application-level interpretation.
The project strengthened my interest in applied AI research because it demonstrated the difference between using a sophisticated model and scientifically evaluating what that model can actually tell us. MutaScope is therefore less about claiming that AI has solved genetic variant interpretation and more about exploring how genomic foundation models can become useful components of carefully designed biological analysis systems.
EXPLORE THE EXPERIMENT
Source Code
Explore the implementation of the MutaScope genomic variant analysis pipeline, including the web interface, genomic data processing, Evo2 inference integration, and variant scoring workflow.
Live Prototype
Explore the interactive MutaScope interface and genomic variant analysis workflow.
