Most generative protein models inherit a pipeline from image and video work: train an autoencoder to compress data into latents, then train a generative model inside that compressed space. It works, but it means two training runs, two sets of hyperparameters, and a latent representation that can quietly discard the detail you care about.
Apple’s ML research team published a paper in September 2026 arguing that this two-stage setup may not be necessary for protein co-design. Their model, SimpleDesign, is trained directly in data space with a single end-to-end objective.
What the single-stage objective actually is
The supplied paper page describes one loss combining two parts: discrete cross-entropy for amino acid sequences and a regression objective for 3D structures. No separate tokenizer stage, no frozen latent space in the middle.
To handle the fact that sequence and structure are different kinds of data, the authors use Transformer-based multimodal backbones that allow modality-specific processing while keeping global self-attention across both modalities. The model was trained on over 2M sequence-structure pairs, and the paper reports competitive performance on co-design and unconditional sequence/structure generation benchmarks.
The claim worth noting is not that one stage is faster. It is that the multi-stage assumption itself was never validated for this problem. The authors state their hypothesis directly: multi-stage training is not necessary to get a performant co-design model.
Why this matters if you build on protein models
If you have ever wired a protein design pipeline together, you know where the friction lives. The autoencoder is a separate artifact with its own version, its own evaluation, and its own failure modes. When generated structures come out wrong, you have to decide whether the problem is the generative model or the compression step underneath it. A single-stage objective removes that ambiguity — there is one model to debug, one loss curve to read, one checkpoint to ship.
That is a real reduction in operational surface area, and it is the kind of change that matters more to a small team than a benchmark point or two. The same instinct shows up in other parts of the stack: a single persistent kernel changes how you serve code models, because collapsing stages removes coordination overhead you were paying for without noticing.
What the paper does not settle
The supplied page reports competitive benchmark results but does not give per-benchmark numbers, training compute, or inference cost. It also does not say whether the single-stage approach scales the same way as latent-space training when you push dataset size or model size further. Those are the questions that decide whether this becomes a default or stays one lab’s result.
There is also a related thread worth reading alongside it. Apple’s earlier SimpleFold work, published September 24, 2025, asked whether heavy domain-specific architectural design is required for folding models at all. The same skepticism about inherited pipeline complexity runs through both papers.
A practical way to read this
If you are evaluating protein design models for a product, treat “single-stage” as a question to ask vendors and open-source projects, not a settled advantage. Ask what the loss combines, what data the model saw, and whether the reported benchmarks include the tasks you actually need. The interesting part of SimpleDesign is the hypothesis it tests — that a simpler training recipe can hold up — and that is testable against your own evaluation set rather than taken on faith.
Sources
AI-assisted summary compiled from the sources above, reviewed by a human before publishing.