Jeveration: System One Models Now Generate

Summary (Overview)

  • New generation paradigm: Jeveration introduces a third paradigm for image generation—parallel typed decisions in a single forward pass—contrasting with autoregressive and diffusion approaches that require sequential sampling.
  • Shared random state for coherence: The key innovation is conditioning all code positions on a shared random state ξ, enabling parallel predictions to converge on globally coherent images despite the many-to-one prompt-to-image mapping.
  • Two-phase training: The method first learns the image distribution via masked prediction, then uses distribution matching (Di[M]O-style) with confidence-guided correction to teach the model to use the random state effectively.
  • Unified architecture: A single frozen VLM (Qwen3.5-4B) with shared LoRA adapters handles text-to-image, image-to-image, and dense prediction tasks in one checkpoint.
  • Exceptional efficiency: Generates 512×512 images in 78 ms on one H200, achieving 122× speedup over Janus-Pro-7B while maintaining competitive quality (0.74 GenEval).

Introduction and Theoretical Foundation

Background and Motivation

Image generation is dominated by two paradigms:

  • Autoregressive models [11, 40, 44]: generate image tokens sequentially
  • Diffusion models [8, 25, 48]: iterative denoising

Both require many sequential model evaluations, increasing inference latency. Jeveration introduces a third paradigm built on System One models (e.g., Jev [1]) that return typed decisions (Choices, Scores) in a single parallel query without extended reasoning.

The Core Challenge: Global Consistency

A single prompt admits many valid images, yet parallel predictions must converge on a coherent whole. The theoretical foundation rests on a key information-theoretic insight:

For independent parallel predictions, the best forward-KL approximation to the true target distribution p(c∣y)p(c|y) satisfies:

min⁡qindKL(p∥qind)=∑i=1NH(ci∣y)−H(c∣y)\min_{q_{\text{ind}}} \mathrm{KL}(p \| q_{\text{ind}}) = \sum_{i=1}^{N} H(c_i \mid y) - H(c \mid y)

where HH denotes entropy. The gap is the target's total correlation—the measure of how strongly codes depend on each other. A coherent image requires this dependence, but independent sampling matches only the marginals p(ci∣y)p(c_i|y), producing incompatible image regions.

Solution: Shared Random State

Jeveration conditions every code position on a shared random state sequence ξ:

qθ(c∣y)=Eξ∼p0[∏i=1Nqθ,i(ci∣y,ξ)]q_{\theta}(c \mid y) = \mathbb{E}_{\xi \sim p_0} \left[ \prod_{i=1}^{N} q_{\theta,i}(c_i \mid y, \xi) \right]

Although codes are sampled independently given (y,ξ)(y, \xi), their shared dependence on ξ allows the image distribution to capture inter-position dependencies.

Methodology

Architecture

The system builds on a frozen Qwen3.5-4B VLM with:

  • Shared LoRA adapters (rank-256) across all tasks
  • Task-specific output heads
  • TA-TiTok image tokenizer with N = 128 codes per image

Decision tokens are appended to the input:

  • Image generation: Initialized from sampled random state ξ (masking with probability ρ = 0.6, uniform random codes for unmasked positions, Gaussian noise σ = 0.1)
  • Dense prediction: Serve as spatial queries aligned with visual tokens

Image Code Prediction

Each decision token's final hidden state uiu_i feeds two complementary branches:

qθ,i(⋅∣y,ξ)=softmax⁡(fcb(ui)+fwide(ui))q_{\theta,i}(\cdot \mid y, \xi) = \operatorname{softmax}\left(f_{\mathrm{cb}}(u_i) + f_{\text{wide}}(u_i)\right)
  • Codebook branch fcbf_{\mathrm{cb}}: projects to code space with classifier initialized from tokenizer's codebook
  • Wide branch fwidef_{\mathrm{wide}}: zero-initialized direct mapping to code logits

Two-Phase Training

Phase 1: Learning the image distribution (masked prediction)

Lmask(ϕ)=E[1∣M∣∑i∈M−log⁡pϕ,i(ci∣cMˉ,y)]\mathcal{L}_{\mathrm{mask}}(\phi) = \mathbb{E} \left[ \frac{1}{|M|} \sum_{i \in M} - \log p_{\phi,i}(c_i \mid c_{\bar{M}}, y) \right]

The visible codes supply image-specific context, enabling the model to learn inter-position dependencies.

Phase 2: Learning image decisions (distribution matching)

LDM(θ)=E[1∣M∣∑i∈Msg(pψ,i−pϕ,i)⊤ℓθ,i]\mathcal{L}_{\mathrm{DM}}(\theta) = \mathbb{E} \left[ \frac{1}{|M|} \sum_{i \in M} \mathrm{sg}(p_{\psi,i} - p_{\phi,i})^{\top} \ell_{\theta,i} \right]

where:

  • ϕ\phi = frozen first-phase model (represents image distribution)
  • ψ\psi = auxiliary model tracking θ's current distribution
  • ℓθ,i\ell_{\theta,i} = logits from the decision model
  • sg = stop-gradient

Confidence-guided correction: Re-mask the half of positions with lowest confidence qθ,i(c^i∣y,ξ)q_{\theta,i}(\hat{c}_i|y,\xi), complete via frozen model, then train θ to predict corrected codes:

Lgen=LDM+λLcorr\mathcal{L}_{\mathrm{gen}} = \mathcal{L}_{\mathrm{DM}} + \lambda \mathcal{L}_{\mathrm{corr}}

Empirical Validation / Results

Text-to-Image Generation

Key results (Table 1):

ModelUnifiedParams (B)StepsRes. (px)Speedup↑GenEval↑Latency (ms)↓
Janus-Pro-7B√7.05763841.0×0.809,508.4
Show-o Turbo-512√1.34512101.0×0.6394.1
Jeveration√5.21512122.2×0.7477.8
  • 122× faster than Janus-Pro-7B
  • 0.11 GenEval improvement over Show-o Turbo-512 at same resolution
  • Higher GenEval than SANA-Sprint 0.6B, FLUX.1-schnell, and SDXL-DMD2 (one-step 1024-px models)

Image-to-Image Generation (Table 2)

ModelHEDDepthColorizeStyle PSNR↑
Jeveration0.8800.8020.93715.40
Copy the input0.8280.7130.998-
Decoder without source0.7920.7670.75714.37

Strong structural fidelity across edge maps, depth maps, colorization, and style transfer (anime, Studio Ghibli, watercolor).

Dense Prediction on NYUv2 (Table 3)

ModelSeg. mIoU↑Depth abs.↓Depth δ₁↑Normal mean (°)↓
Jeveration67.70.2670.89824.2
Dense-only (one task)67.80.2460.91521.2
DeepLabV3+ R5053.50.393-22.0

Jeveration outperforms DeepLabV3+ by 14.2 mIoU and reduces depth error by 32%.

Ablation Studies (Table 4)

VariantGenEval↑HPS↑
w/ random state0.7328.27
w/ fixed state0.7026.63
w/ correction target0.7428.03
w/o correction target0.7327.92
Image head (wide + codebook)0.6425.42
Image head (wide only)0.6025.34
Image head (codebook only)0.5925.04

Key findings:

  • Random state improves coherence: +0.03 GenEval, +1.64 HPS over fixed state
  • Correction target refines details (HPS +0.11)
  • Combined head branches outperform either alone (complementary benefits)

Joint Training (Table 5)

Training on all tasks costs almost no text-to-image quality (GenEval 0.74 vs 0.73; HPS 28.06 vs 28.28), demonstrating minimal task interference.

Theoretical and Practical Implications

Theoretical Contributions

  1. Extends System One paradigm: Demonstrates that decision models can generate, not just decide—broadening the theoretical scope of parallel typed decision frameworks.
  2. Information-theoretic framing: Formally characterizes why independent parallel prediction fails (total correlation gap) and how shared randomness bridges this gap.
  3. Distribution matching for parallel generation: Shows that masked models can serve as training targets for single-pass generators within a frozen backbone, avoiding the need to train generative models from scratch.

Practical Implications

  1. Dramatic latency reduction: 78 ms per image enables real-time and edge deployment scenarios previously infeasible with autoregressive or diffusion approaches.
  2. Unified visual intelligence: One checkpoint serving generation, editing, and perception tasks simplifies deployment and reduces memory footprints.
  3. Frozen backbone reuse: Leveraging pretrained VLMs with lightweight adapters makes the approach accessible—training takes only ~4 days on 4× RTX PRO 6000 GPUs.
  4. Controllable generation at near-zero cost: Image-to-image tasks add only ~14 ms over text-to-image, making conditional generation practical for interactive applications.

Conclusion

Jeveration establishes a third paradigm for image generation where System One models return complete images as single joint decisions. The key innovations—shared random state conditioning and two-phase distribution-matching training—enable globally coherent images from parallel predictions.

Main takeaways:

  • A frozen VLM can generate high-quality images (0.74 GenEval) in a single forward pass (78 ms)
  • One checkpoint unifies text-to-image, image-to-image, and dense prediction with minimal task interference
  • The paradigm extends naturally to diverse visual tasks

Future directions:

  • Extension to further visual tasks and modalities (video, 3D, audio)
  • Scaling to higher resolutions and larger backbones
  • Exploring additional applications of the shared random state mechanism
  • Potential integration with other System One decision interfaces (e.g., Box, Scores) for richer multimodal interaction

Related papers