Ansatz Neural Reconstruction: Compression That Rebuilds Instead of Storing

Every conventional codec, from JPEG to H.266, is built on the same basic move: to make a file smaller, store less of it. Throw away the detail a viewer is least likely to notice, keep the rest, and accept that quality and size trade off against each other along that one axis. Decades of engineering have made that trade remarkably efficient. But it is still the same trade, and it has a ceiling, because there is only so little of an image you can store before it stops looking like the image.

Neural reconstruction takes a different path. Instead of storing a compressed version of the pixels, it stores the essence of what the content is and how it changes, then rebuilds the pixels on the other side. It does not ask "how few bits can represent this picture." It asks "how little information do I need to reconstruct this picture." Those turn out to be very different questions, and the second one has a far lower floor.

This is the idea behind Ansatz, our neural reconstruction codec. This piece is about the concept it is built on, why it changes what is possible, and where it does and does not apply.

Key Takeaways

• Conventional codecs shrink files by storing less detail. Neural reconstruction stores the essence of the content and rebuilds the rest, a fundamentally different and lower floor.
• For structured content like a talking head, this means sending a reference frame plus a compact description of how it moves, rather than a full stream of pixels.
• The risk with any generative approach is fidelity drift. Ansatz addresses it with a verify-and-fallback floor: if reconstruction fails a quality check, it falls back to a conventional codec, so it never ships a result it cannot stand behind.

What does "reconstruction" actually mean here?

It means the decoder does real work to rebuild the content, rather than just unpacking it. A conventional decoder is essentially a reverse of the encoder: it takes the stored, compressed data and expands it back toward the original. The information in equals the information out, minus what was discarded. A reconstruction decoder is different. It is given a small amount of information and a learned model of what the content is, and it generates the full result from both.

Think about the difference between mailing someone a photograph and mailing them a description detailed enough that a skilled artist could repaint it. The photograph is conventional compression: the bits you send are a version of the pixels. The description is reconstruction: the bits you send are instructions, and the intelligence to turn them back into an image lives in the model, not in the file. When the model already knows a great deal about the kind of content it is rebuilding, the instructions can be tiny.

That is the whole leverage. The more the model knows in advance, the less you have to send.

Why does the type of content matter so much?

Because reconstruction wins biggest when the content is predictable in a way a model can learn, and a talking head is one of the most predictable things on the internet. Consider what a video call actually is: a mostly static background, and a face that moves in a constrained, well-understood way. Eyes blink, lips form speech, the head turns and tilts. The space of things a face can do is large but far from arbitrary, and it is exactly the kind of structure a model can learn deeply.

So instead of sending every frame as pixels, a reconstruction codec can send a reference frame once, then, for each following frame, a compact description of how the face has moved and changed since that reference. The reference frame carries the identity and appearance. The per-frame description carries only the motion and expression. Reconstruction combines them to regenerate each frame. The per-frame cost drops from "a compressed image" to "a small set of numbers describing a change," which is a different order of magnitude.

This is why the approach is content-specific rather than universal. A talking head, a screen recording, a fixed-camera scene, these have the kind of learnable structure that makes reconstruction pay off. A codec built this way is not trying to beat conventional compression everywhere. It is picking the places where a fundamentally different representation wins by a wide margin, and using conventional compression for the rest.

In Ansatz, where does Epiron fit?

The reference frame has to be sent, and it should be sent well, so it rides on Epiron, our neural codec. This is where the two pieces of what we build reinforce each other. Ansatz sends a reference frame plus motion; that reference frame is a still image, and compressing still images extremely well is exactly what Epiron does. The better the reference compresses, the lower the fixed cost of each reconstructed segment. The image codec and the reconstruction codec are not two separate products; they are two layers of the same idea, essence sent efficiently, detail rebuilt on arrival.

The honest problem: what if the reconstruction is wrong?

This is the question that matters most, and it is where a lot of generative compression gets uncomfortable. A model that rebuilds a face from a description can rebuild it wrong. It can drift the identity, so the person looks subtly like someone else. It can get the expression or the lip movement wrong, so the reconstruction says something the original did not. Unlike conventional compression, which fails in visible, familiar ways (blocking, blur), a generative failure can look completely clean while being subtly false. That is a real risk, and pretending otherwise would be dishonest.

Ansatz is built around that risk rather than around it. The core discipline is a verify-and-fallback floor. During encoding, every reconstructed segment is checked against the original on the axes that matter: does it stay the same person, and does it preserve the expression and the mouth movement? If a segment passes, it ships as reconstruction, tiny and fast. If it fails, the codec does not ship a questionable reconstruction. It falls back to a conventional codec for that segment and sends real pixels instead. The result is a hybrid: reconstruction where it provably preserves the person, conventional compression where it does not.

That floor is the difference between a demo and something you can put in front of real content. It means the savings are captured on the majority of frames that reconstruct faithfully, while the hard frames, an occlusion, a hand across the face, an extreme angle, are handled safely rather than hallucinated. The codec never ships a result it cannot stand behind, because the verification is the gate, not an afterthought.

What this does and does not claim

Neural reconstruction is not a universal replacement for conventional compression, and Ansatz is not pitched as one. It is a targeted approach for content with learnable structure, backed by a fidelity floor that keeps it honest. On the content it is built for, it changes the ceiling, because it stopped asking how few bits can store the video and started asking how few bits can rebuild it. Where that reconstruction can be verified as faithful, the difference is not incremental. Where it cannot, the system falls back, and you lose nothing.

We will have detailed results to share, with the methodology to examine them, in their own post. This one is about the idea, because the idea is the part worth understanding first: compression that rebuilds instead of stores, applied where a model's knowledge of the content does the heavy lifting, with verification as the guarantee that what gets rebuilt is still true.