AI Agents Solve the Vault Structure Puzzle: From Sequence Search to Atomic Model

1. A 40-Year-Old Mystery: The “Phantom Cathedral” Inside Cells

In 1986, a research team isolated a previously undescribed particle from rat liver. Under electron microscopy, its raised ends and narrowed middle resembled the dome of an ancient Roman cathedral, giving rise to the name “vault.”

From an assembly standpoint, it is one of the most intricate machines inside the cell:

• Unusual size: Its mass is about three times that of the ribosome, making it one of the largest protein complexes in the cell. Individual particles can reach tens of nanometers in diameter.
• Elaborate architecture: In mammalian vaults, 78 major vault protein (MVP) chains are arranged in two tiers of 39, closing together to form a hollow container. Eukaryotic vaults also package various RNAs and accessory proteins.
• High copy number: Many mammalian cells contain tens of thousands of vault particles.

Despite this structural elegance, the function of the vault has remained disputed for four decades. The controversy has centered on three points:

1. Poor evolutionary conservation: Vaults are not found in common model organisms such as yeast, fruit flies, and nematodes.
2. Apparent dispensability: Mice lacking vault genes still develop normally, without obvious phenotypes.
3. No decisive functional evidence: Hypotheses involving transport, nucleocytoplasmic exchange, stress response, and innate immune regulation all have supporting evidence, but none has been supported by decisive structural clues.

In a review published nearly two decades ago, Mongo et al. described vaults as “cathedrals in the cell.” Compared with the functional clues available at the time, the long absence of high-resolution structures was one of the key reasons progress stalled. Without atomic-level detail, it was difficult to determine how the channels open and close, which sites participate in binding, or where functional clues should be sought.

2. A Different Approach: Looking for Answers in Simpler Bacterial Systems

Eukaryotic vaults are assembled from multiple proteins and RNAs. Their complex composition makes them difficult to reproduce faithfully in conventional expression systems. The research team therefore shifted the search from complex animal systems to prokaryotes.

• Simpler assembly: Bacterial vault proteins are composed of only one type of MVP homolog. Compared with eukaryotic vaults, this greatly reduces uncertainty in cloning, expression, and purification.
• Possible genomic clues: Known prokaryotic vault proteins are scattered across only a few bacteria. If more distant homologs could be found, their neighboring genes might provide clues about function.

The idea was simple, but executing it was a needle-in-a-haystack problem:

• These proteins may differ greatly from known MVP sequences.
• They are often longer than 800 amino acids, substantially larger than many common bacterial globular proteins.
• The candidate sequences numbered in the billions.

3. Finding a Needle in 15 Billion Sequences: Expanding the Family by About 36-Fold

Using large-model AI agents, the research team searched through approximately 15 billion protein sequences.

1. How agents search at billion-scale

Distant homology search is rarely completed in a single comparison. A common approach is iterative: known sequences are first used to find similar fragments, a profile model is built from the hits, the model is used to search the database again, and the cycle repeats until new hits converge.

As data volume grows, each step becomes more complex: computational cost increases, candidate noise rises, and result interpretation becomes harder. The value of an agent is precisely to automate a workflow that is multi-round, parameter-sensitive, and requires interpretation. For example, an agent can:

• Orchestrate search tasks and schedule computational resources;
• Adjust the next-round strategy based on the hits from each round;
• Filter candidates by domain composition and length;
• Summarize species distribution and analyze gene neighborhoods.

The workflow can be outlined as follows (the code below is illustrative and does not correspond to any specific tool or platform):

def iterative_search(known_mvps, database, max_rounds=5):
    hits, profile = set(known_mvps), build_profile(known_mvps)
    for _ in range(max_rounds):
        new = [s for s in database.search(profile, min_identity=0.15)
               if not hit_signature(s)]          # Deduplicate by sequence features
        new = [s for s in new if has_mvp_domain_arch(s)   # Validate domain architecture
                              and 700 <= len(s) <= 1200]
        if not new:
            break
        hits |= set(new)
        profile = build_profile(list(hits)[:500])          # Limit model drift
    return hits

Several engineering details are especially important:

• Deduplication: As iterative rounds accumulate, the profile model becomes more divergent and more likely to include proteins with similar structures by mistake. Deduplication is therefore needed at every round.
• Domain validation: Sequence similarity alone can easily produce false positives. Comparing the candidate protein’s domain composition with the MVP architecture—N-terminal tandem cap-like domains, a long rod-like region, and a C-terminal globular domain—can significantly reduce false positives.
• Profile update strategy: The number of sequences used to build the profile and the sampling method directly affect sensitivity and specificity in subsequent rounds.

2. Results: From 41 to 1,507, and clues hidden in gene neighborhoods

The search produced the following results:

• These proteins are widely distributed across 29 bacterial phyla and 4 archaeal phyla. Large numbers of related genes were also found in phage genomes that infect bacteria.
• The known family expanded from 41 members to 1,507, roughly a 37-fold increase and often described as a 36-fold expansion.
• Within bacteria, they remain a minority: they occur in less than 1% of species and are often arranged next to antiviral defense gene clusters.

The combination of “rare distribution” and “defense gene neighborhood” led the team to propose a testable hypothesis: vault proteins may be specialized bacterial equipment for responding to phages. The team then selected 44 candidates from the 1,507 hits. The agent handled synthetic DNA design, expression regulatory element configuration, and even ordering plans. After transfer into Escherichia coli, 15 candidates yielded soluble protein.

4. Faster Purification: Compressing a Three-Day Sucrose Workflow into 90 Minutes

1. The bottleneck of the old method

Traditionally, vault isolation relied on sucrose density gradient ultracentrifugation: particles are separated according to sedimentation coefficient in a gradient medium, then fractions are collected and tested one by one. This method is mature and reliable, but a single run can take hours or even longer. With sample preparation, detection, and recovery, the full workflow often takes about three days. When candidates increase from a few to dozens, a “three-day-per-round” pace cannot support large-scale screening.

2. Size-exclusion chromatography: letting the largest particles leave first

The team tried size-exclusion chromatography (SEC). Its principle can be summarized in one sentence:

The column is packed with porous beads. Small molecules can enter the pores, repeatedly moving in and out, traveling longer paths and eluting later. Large particles cannot enter the pores and can only move through the spaces between beads, so they are eluted first.

For vaults, this separation method is almost tailor-made:

• Separation is based on size, not density: Larger particles elute earlier. With a resin whose exclusion limit is high enough, vaults can appear concentrated near the exclusion volume, clearly separated from contaminating proteins.
• Online monitoring: The elution curve itself is a diagnostic report. A symmetric peak with a stable position indicates particle homogeneity; tailing or an early-eluting peak often indicates aggregation or degradation.
• Naturally suited to automation: Sample injection, gradient elution, fraction collection, and detection can all be performed by the system according to preset methods.

The full purification workflow was compressed to about 90 minutes, improving efficiency by roughly twentyfold. What was accelerated here was not a single separation step, but the experiment–detection–judgment feedback loop: candidates were queued, methods were prewritten, and results were automatically interpreted, allowing the agent to screen multiple targets continuously without waiting for a human to operate the centrifuge each round.

If this pipeline were reproduced at the code level, a simplified skeleton would look like this:

class VaultPurificationPipeline:
    """Illustrative pipeline connecting candidate queue, SEC method, and automated interpretation."""
    def __init__(self, candidates, column, buffer_system):
        self.queue = list(candidates)      # Candidate queue awaiting analysis
        self.method = SECMethod(column, buffer_system)   # Chromatography method parameters
    def run(self, reviewer=None):
        results = {}
        while self.queue:
            sample = self.queue.pop(0)
            # 1) Automated injection, gradient elution, UV online detection, and fraction collection
            trace = self.method.run(sample)
            # 2) Automated interpretation: main peak position, peak width, aggregation or degradation peaks
            verdict, detail = analyze_chromatogram(trace)
            if reviewer:                   # 2.5) Critical judgments submitted for human review
                verdict = reviewer.confirm(verdict, detail)
            results[sample.id] = verdict
            # 3) Failed candidates enter the next round of condition optimization instead of being discarded
            if verdict == "poor":
                self.queue.append(sample.variant(next_buffer()))
        return results

Beyond the pipeline itself, the model also plays an important role. SEC is highly empirical. Buffer pH and salt concentration, column choice, and loading amount can all affect the result. A model can read the literature like an experienced experimentalist, organize the physicochemical properties of vaults from different species, propose multiple buffer conditions for parallel testing, and suggest directions for the next adjustment based on each round of elution curves. What is shortened is the trial-and-error cycle, not the experiments themselves.

5. From Microscopy Images to a 3D Model: A 34-Hour Structure-Solving Loop

Once purification efficiency improved, the real test began. Giant particles such as vaults have traditionally been studied using cryo-electron microscopy (cryo-EM).

1. Why cryo-EM is the standard tool for vaults

The basic cryo-EM workflow is to rapidly freeze the sample in vitreous ice to preserve the native conformation of biological macromolecules, image it with an electron beam, and then calculate a 3D structure through image processing.

When analyzing giant complexes, it has three clear advantages:

• No crystal growth is required;
• A single imaging session can capture millions of views of the same particle;
• Much less sample is required than with crystallographic methods.

2. Five steps, with agents involved at each stage

From a microscopy image to an interpretable 3D model, the process usually involves the following five steps. Agents mainly assist with parameter tuning, result interpretation, and workflow handoff, while the final judgment is still made by researchers.

Step	Core task	Traditional bottleneck	Work agents can handle
Grid preparation	Freeze the sample in holes on the grid	Repeated trial and error for ice thickness and particle orientation	Suggest grids and preparation parameters based on sample properties; summarize historical preparation records
Data collection	Automatically collect large numbers of micrographs	Long waits for microscope time	Write acquisition strategies, monitor quality metrics, and decide in real time whether to stop
Preprocessing and particle picking	Motion correction, contrast transfer function (CTF) estimation, and particle selection	Heavy manual inspection workload	Train or invoke automated picking models; handle low signal-to-noise images
2D/3D classification and reconstruction	Sort particles by conformation and calculate 3D density maps	Number of classes and parameters often require repeated empirical testing	Analyze classification results, suggest parameters, and identify anomalous classes
Model building and validation	Place amino acid sequences into the density map and refine	Manual modeling is slow and requires many revisions	Automatically build the backbone from sequence, identify modeling errors, and generate validation reports

Single-chain prokaryotic vaults are relatively regular in assembly, which is favorable for automated modeling. Once one chain is built, it can be copied and positioned according to the particle’s symmetry, quickly generating an initial model of the entire shell, which is then iteratively refined against the experimental density map.

This workflow can be summarized by the following illustrative code as a cycle of “data-driven processing—classification and reconstruction—modeling and validation”:

def solve_structure(dataset, template_chain, symmetry, max_iter=3):
    particles = preprocess(dataset)                # Motion correction, CTF estimation, particle picking
    best = None
    for i in range(max_iter):
        classes = classify_2d(particles, n_classes=50)      # 2D classification for denoising
        good = select_good_classes(classes, size_threshold=0.05)
        half_a, half_b = split_half_sets(good)              # Two independent data subsets
        map_a = reconstruct(half_a, symmetry=symmetry)
        map_b = reconstruct(half_b, symmetry=symmetry)
        fsc = fourier_shell_correlation(map_a, map_b)       # Independent half-map cross-validation
        model = build_model(template_chain, map_a, symmetry)
        model = refine(model, map_a)                        # Refine against the density map
        report = validate(model, map_a, map_b, fsc)         # Resolution, geometry, cross-validation
        best = keep_best(best, report, fsc)
        if report.passed:
            break
        particles = reweight_particles(particles, model)    # Reweight signals based on the model
    return best, report

Behind the illustrative code lies an unshakeable validation principle: resolution cannot rely only on self-consistency within the same dataset. The data must be split into two independent subsets, reconstructed separately, and then compared for agreement. Otherwise, a model can easily “prove itself correct” and count noise as structure.

3. What 34 hours means

Normally, for a giant complex with no homologous model available for reference, obtaining an interpretable 3D model from the first usable image can take weeks or even months. In the vault project, this loop was compressed into 34 hours.

It is important to view this rationally: 34 hours does not mean “press a button and get a structure.” It is more like a high-speed assembly line: every step is prepared in advance, intermediate results can be interpreted quickly and accurately, and anomalies can be detected and corrected in time. What is truly compressed is the waiting time between steps and the number of trial-and-error cycles.

6. What the Structure Reveals—and What It Leaves Open

The significance of structure determination goes beyond “seeing what it looks like.” For complexes like vaults, where the structure is known but the function is unknown, a 3D model is more like a functional map: the pore diameter and inner-wall properties of the channel, how the “caps” at both ends control the passage of molecules, and which surfaces may participate in interactions with other molecules.

Combined with the distribution pattern that prokaryotic vaults are often adjacent to antiviral defense genes, one question worth further investigation is: could vaults be a kind of “molecular container” used by bacteria to defend against phages, storing or isolating a certain signaling molecule?

This is somewhat similar to how the scientific community came to understand another bacterial immune system: before the relevant cyclic signaling pathway was discovered, bacteria had already evolved mechanisms in which specialized synthases produce signaling molecules and effector complexes trigger defense. Whether vaults can be incorporated into a similar framework still requires more experimental evidence.

From structure to function, this puzzle is far from finished. But the full participation of AI agents has moved an exploration that once proceeded in months and years into a rhythm measured in days.

7. Lessons for AI for Science and Engineering Teams

The value of the vault case is not that one model is “smarter,” but that AI was embedded into a real research workflow and formed a workable closed loop. For teams hoping to use AI to empower R&D and scientific computing, at least five lessons are worth borrowing.

1. Agents solve process bottlenecks, not replace judgment

In the vault project, the most direct contribution of AI was to turn serial manual steps into a parallel, automatically interpretable pipeline, such as compressing a three-day purification workflow into 90 minutes and reducing weeks of modeling to 34 hours. The algorithms for each step were already mature; the real bottleneck was the handoff between people and between steps.

The same applies to software development: time-consuming processes such as code review, test regression, and log analysis can first be accelerated through agent orchestration and automated interpretation.

2. Constrain agents with tools and validation to prevent plausible-looking errors

In distant sequence search, hits based only on sequence similarity may be structural analogies. Only by adding multiple constraints—domain validation, deduplication, and human review—can the results be trusted.

In engineering practice, several principles can be followed:

• Every agent action should call a validated tool rather than freely generate results;
• Every step should have objective checkpoints, such as unit tests, statistical significance, or physical constraints;
• Key decisions should retain human review nodes.

3. Make data flow and shorten feedback loops

From sequence search, expression screening, and chromatographic elution curves to microscopy images and 3D density maps, if data in different formats are stored in isolation, agents cannot use the result of one step to inform the next.

General cloud capabilities—such as object storage, container services, and message queues offered by platforms including Baidu AI Cloud—can be used to unify these heterogeneous data sources. Combined with task orchestration, logging, and monitoring/alerting, an experimental pipeline can truly become “data-driven decision-making.”

Illustrative code is as follows:

pipeline = (Pipeline("vault-structure")
            .source("objstore://vault-project/sequences")     # Unified sequence data ingestion
            .map(search_stage, concurrency=64)                # Containerized parallel search
            .filter(apply_domain_check)                       # Domain architecture validation
            .send("queue://purification-tasks")               # Purification task queue
            .sink("objstore://vault-project/candidates")
            .on_failure(alarm("chan://ops-alerts")))          # Automatic alerts on failure
pipeline.run()

4. Human-in-the-loop: scientists define problems, agents execute and return evidence

The project shows a clear division of labor: human scientists raise core questions such as “why is the function unknown?” and “can prokaryotes provide an entry point?” and set validation standards. Agents handle retrieval, design, analysis, and orchestration, and return evidence to humans.

This model—scientists ask questions, agents run experiments, and humans judge conclusions—can be transferred directly to enterprise R&D:

• Engineers define requirements and acceptance criteria;
• Agents handle code generation, test execution, and defect localization;
• Humans make architecture decisions and final reviews.

5. Reproducibility must run through the entire workflow

Paper-level conclusions require every step to be traceable: which sequences were used, which parameters were selected, and which model version was applied. The same is true for engineering:

• Experiment records, scripts, and data versions should be archived together;
• Intermediate products should be stored immutably;
• Audit logs should be fully retained so that results can be independently reproduced.

8. Conclusion

The story of the vault is a story about “waiting.” From its discovery in 1986 to the determination of its atomic-level structure from prokaryotic sources with the help of AI agents decades later, what really changed was not only computing power or algorithms, but the way the research process is organized: retrieval, experimentation, imaging, and modeling are no longer isolated, lengthy procedures, but a closed loop that can be accelerated, tracked, and validated.

The structure is in place; the function is still ahead. But it is foreseeable that as agents become more deeply integrated into research and development workflows, an exploration rhythm measured in days may become the norm for scientific discovery.