🤖 AI

Jolt Atlas: Verifiable Inference via Lookup Arguments in Zero Knowledge

Jolt Atlas is a zero-knowledge machine learning framework that extends the Jolt proving system to directly verify ONNX tensor operations via lookup arguments, enabling memory-efficient, on-device cryptographic inference with succinct proofs for privacy-centric and adversarial applications.

Original authors: Wyatt Benno, Alberto Centelles, Antoine Douchet, Khalil Gibran

Published 2026-02-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Wyatt Benno, Alberto Centelles, Antoine Douchet, Khalil Gibran

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a brilliant, secretive chef (the AI model) who cooks a complex dish for you. You want to know two things:

Did they actually cook the dish correctly? (Verification)
Can you trust them without seeing their secret recipe or the ingredients they used? (Privacy/Zero-Knowledge)

Traditionally, to prove the dish was cooked right, you'd have to invite the chef into your kitchen, watch every single chop and stir, and check every ingredient. This is slow, requires a huge kitchen (lots of computer memory), and ruins the secrecy of the recipe.

Jolt Atlas is a new, magical "proof system" that lets the chef prove they cooked the dish correctly in seconds, without you ever seeing the kitchen, the recipe, or the ingredients. It does this by changing how we look at the cooking process.

Here is a simple breakdown of how it works, using everyday analogies:

1. The Old Way vs. The New Way: The "Instruction Manual" vs. The "Menu"

The Old Way (zkVMs): Imagine trying to prove a chef cooked a meal by watching them follow a generic instruction manual for every single tool in the kitchen. "Pick up the knife. Move the knife 2 inches. Cut the carrot." This is like a Zero-Knowledge Virtual Machine (zkVM). It's incredibly detailed but slow and clunky because it treats a complex meal like a series of tiny, unrelated mechanical steps.
The Jolt Atlas Way (ONNX): Jolt Atlas ignores the tiny mechanical steps. Instead, it looks at the Menu (ONNX). The menu says: "Take the carrots, chop them, then mix them with the sauce." It treats the whole operation as a single, big block.
- The Benefit: By skipping the "pick up the knife" steps and focusing on the "chop carrots" result, the system becomes much faster and lighter. It doesn't need a massive kitchen (RAM) to do this; it can run on a standard laptop or even a phone.

2. The Magic Trick: The "Lookup Table" (The Cheat Sheet)

AI models use "non-linear" functions (like deciding if a pixel is part of a cat's ear or just background). In math, proving these is like trying to solve a giant, impossible puzzle.

The Problem: If you try to prove the math of a "cat ear" decision from scratch every time, it takes forever.
The Jolt Atlas Solution: Imagine the chef has a Cheat Sheet (Lookup Table). Instead of calculating "Is this a cat ear?" from scratch, the chef just points to the sheet and says, "Look, this specific shape is on line 42, and the answer is 'Yes'."
The Magic: Jolt Atlas uses a protocol called Sumcheck to verify that the chef is actually pointing to the right line on the sheet, without the chef having to show you the whole sheet or explain the math behind why line 42 is "Yes." It's like a librarian verifying you have the right book by checking a barcode, not by reading the whole book.

3. Fitting a Whale in a Fishbowl: "Streaming" and "Neural Teleportation"

AI models are huge. Proving they worked usually requires a computer with more memory than exists on Earth.

Streaming (The Conveyor Belt): Instead of trying to hold the entire ocean (the model's data) in a bucket (RAM) at once, Jolt Atlas uses a conveyor belt. It processes the data in small, manageable chunks, one after another. It proves the first chunk, then the second, then the third, without ever needing to hold them all at once. This allows the proof to run on devices with limited memory.
Neural Teleportation (The Zoom Lens): Some parts of the AI (like the "Tanh" function) are very sensitive and require a massive lookup table. Jolt Atlas uses a trick called Neural Teleportation. Imagine you are looking at a mountain range. Instead of mapping every single pebble, you use a zoom lens to focus only on the peaks that matter. It slightly "compresses" the data range (like zooming in) so the lookup table becomes tiny, while still keeping the final result accurate enough for the AI to work perfectly.

4. The Invisible Shield: "BlindFold"

How do we keep the proof "Zero-Knowledge" (hiding the secret data)?

The Analogy: Imagine the chef sends you a sealed envelope containing the proof. Inside, there are numbers. If you open the envelope, you see the numbers, but you can't tell what the original ingredients were.
BlindFold: This is a cryptographic technique that takes the proof and "folds" it with random noise. It's like taking a clear photo of the chef's work and running it through a kaleidoscope. The verifier can still mathematically confirm the photo is real and the work was done correctly, but the original image (the secret data) is completely scrambled and unrecoverable.

5. Why This Matters (The Real-World Impact)

Speed: In the paper, they proved a small AI model (nanoGPT) in 14 seconds. Previous methods took nearly 4 minutes (and required much more setup). That's a 17x speedup.
Privacy: You can verify that an AI made a decision (like approving a loan or diagnosing a disease) without the AI revealing its secret training data or the user revealing their private medical/financial records.
Accessibility: Because it's so efficient, you can run these proofs on a regular laptop or phone, not just on massive supercomputers.

Summary

Jolt Atlas is like upgrading from a slow, manual accountant who checks every single receipt in a stack of millions, to a smart auditor who uses a barcode scanner and a conveyor belt. It proves the AI did its job correctly, keeps everyone's secrets safe, and does it fast enough to run on your phone. It turns "verifiable AI" from a theoretical dream into a practical reality.

1. Problem Statement

The paper addresses the significant bottlenecks in Zero-Knowledge Machine Learning (zkML), specifically the high computational overhead and memory requirements associated with proving the correctness of neural network inference.

Scalability Issues: Modern neural networks contain millions to billions of parameters. Proving their execution using general-purpose zkSNARKs (like those used in zkVMs) incurs a massive overhead (100,000x to 1,000,000x) compared to native execution.
Non-Linearity: Neural networks rely heavily on non-linear activation functions (e.g., ReLU, Softmax, GELU). Representing these in low-degree arithmetic constraint systems often leads to an explosion in constraint counts and degrees, making them the dominant cost.
Memory Constraints: Standard SNARK constructions often require materializing large portions of the witness and intermediate polynomials in memory. This results in multi-gigabyte peak memory usage, rendering on-device proving (e.g., on mobile phones) infeasible.
Framework Limitations: Existing zkML frameworks (like EZKL) often rely on circuit-based arithmetic constraints or Halo2, which struggle with large lookup tables and do not natively exploit the sparsity or algebraic structure of tensor operations.

2. Methodology

Jolt Atlas adapts the Jolt proving system (originally designed for RISC-V CPU instructions) to the ONNX computational model for machine learning. Instead of emulating CPU instructions, it treats tensor operations as the primary unit of verification.

Core Architectural Shifts

ONNX as the Execution Model: Jolt Atlas uses ONNX (Open Neural Network Exchange) graphs. This eliminates the need for CPU registers and arbitrary RAM access, simplifying memory consistency verification to tensor buffer consistency.
Lookup-Centric Proving: Rather than arithmetizing non-linear functions directly, Jolt Atlas uses lookup arguments. The prover demonstrates that input-output pairs for non-linear operations exist in precomputed tables. This avoids complex polynomial constraints for non-linearities.
Sumcheck Protocol & DAG Structure: The proof is organized as a Directed Acyclic Graph (DAG) of Sumcheck instances.
- Staging: Computations are broken into stages where sumchecks verify specific claims (e.g., instruction transitions, memory reads).
- Virtual Polynomials: Large sparse polynomials are defined virtually as algebraic combinations of smaller, low-degree polynomials, avoiding direct commitment to massive data structures.
Streaming Proving (Small Space): To address memory constraints, the system employs prefix-suffix decomposition of large lookup tables. By algebraically decomposing tables, the prover can trade time (multiple streaming passes) for space, reducing peak memory from $O(|T|)$ to $O(|T|^{1/C})$ . This enables proving on memory-constrained devices.

Key Technical Components

Neural Teleportation: To compress lookup tables for saturating activation functions (like $\tanh$ or $\text{erf}$ ), the system applies a global scaling factor $\tau$ to inputs ( $y' = \sigma(x/\tau)$ ). This shrinks the effective input range, allowing smaller lookup tables while maintaining acceptable accuracy (errors are concentrated in the linear region near zero, which is rarely the dominant factor in trained models).
Zero-Knowledge via BlindFold: To hide the witness (model weights and inputs), Jolt Atlas integrates the BlindFold technique.
- It encodes the Sumcheck verifier logic into a small R1CS circuit.
- It uses Nova-style folding to combine the actual proof instance with a random satisfying instance.
- All prover messages (coefficients, evaluations) are sent as Pedersen commitments, ensuring the verifier learns nothing about the underlying data.
Polynomial Commitments: Unlike Jolt (which uses Dory for large witnesses), Jolt Atlas uses HyperKZG (based on KZG and the Gemini transformation). This is better suited for multilinear polynomials and offers succinct openings suitable for on-chain verification, though it requires a trusted setup.

3. Key Contributions

First Lookup-Centric zkML Framework: Successfully extends the Jolt paradigm from CPU instructions to ONNX tensor operations, leveraging the DAG structure of neural networks for optimization.
Streaming Prover for On-Device Verification: Demonstrates the ability to prove model inference in memory-constrained environments by utilizing prefix-suffix decomposition and streaming passes.
Neural Teleportation for Table Compression: Introduces a practical adaptation of teleportation to reduce lookup table sizes for non-linear activations without re-committing weights, balancing table size and model accuracy.
Zero-Knowledge Integration: Provides a robust implementation of BlindFold to achieve zero-knowledge properties over the Sumcheck transcript, hiding model weights and inputs.
Performance Benchmarks: Shows practical proving times for classification, embedding, and small language models (e.g., nanoGPT, GPT-2) that significantly outperform existing frameworks.

4. Results

The paper presents benchmarks comparing Jolt Atlas against EZKL (a leading Halo2-based zkML framework) on a MacBook Pro (M3, 16GB RAM).

nanoGPT (0.25M parameters, 4 layers):
- Jolt Atlas: Proof generation time of ~14 seconds.
- EZKL: Proof generation time of ~237 seconds (excluding >400s key generation).
- Result: Jolt Atlas achieves approximately a 17x speed-up in proof generation.
GPT-2 (125M parameters):
- Jolt Atlas: End-to-end proving time of ~38 seconds.
- Breakdown includes: Witness generation (~~7.5s), Commitment (~~3.5s), Sumcheck proving (~~16s), and HyperKZG proving (~~3s).
Verification: Verification times remain succinct (sub-second), making the proofs suitable for on-chain or lightweight verification.

5. Significance

Privacy-Preserving AI: Jolt Atlas enables cryptographic verification of AI inference where model weights and user inputs remain private. This is crucial for "agentic commerce" and "trustless AI context" (AI memory), where agents need to prove they acted correctly without revealing their internal logic or data.
On-Device Feasibility: By solving the memory bottleneck via streaming, Jolt Atlas makes it possible to run zkML proofs on commodity hardware (like smartphones) without specialized accelerators, democratizing verifiable AI.
Efficiency over Generality: By moving away from general-purpose CPU emulation (zkVMs) to a specialized tensor model (ONNX), the system avoids the overhead of simulating registers and memory, achieving near-native efficiency for ML workloads.
Future-Proofing: The paper outlines a path toward post-quantum security by suggesting a future migration to lattice-based Polynomial Commitment Schemes (like Hachi) to replace HyperKZG, addressing current on-chain verification limitations regarding pairing operations.

In summary, Jolt Atlas represents a paradigm shift in zkML, moving from "proving the CPU" to "proving the tensor," utilizing lookup arguments and streaming techniques to make verifiable inference practical, private, and efficient for real-world models.