DeepGen packs image generation and editing into one 5B model

One model for five jobs, and the argument about scale

The claim in the introduction is specific and testable. DeepGen 1.0 is a lightweight unified multimodal model with only 5B parameters, split as a 3B vision language model plus a 2B diffusion transformer, and it integrates five core capabilities in a single model: general image generation, general image editing, reasoning image generation, reasoning image editing and text rendering. The benchmark claim that follows is that across multiple authoritative benchmarks the model is competitive with or surpasses unified multimodal models three to sixteen times larger, and the conclusion the authors draw is that massive scaling is not the sole path to high-performance multimodal generation. The paper is on arXiv at 2602.12205 and the project page is on GitHub pages. Everything was released on the same day, February 13, 2026, as the model, the training code and the technical report, and there is also a separate repository for the reinforcement learning part. The interesting framing is the contrast with a large model. A 5B unified model is small enough to fine-tune on a single machine and to run inside a research iteration loop, and the model card on Hugging Face is where the checkpoints live, with a separate diffusers-format copy provided for convenience.

Stacked Channel Bridging is how a small model gets a large model's judgement

The Method section is where the engineering claim lives, and it starts from an observation: a lightweight model, when given a good architecture and good data, can be competitive with or even better than much larger counterparts. The two named contributions are an architecture change and a training recipe. The architecture is Stacked Channel Bridging, described as a deep alignment framework that extracts hierarchical features from multiple vision language model layers and fuses them with learnable think tokens to give the generative backbone structured, reasoning-rich guidance. The problem it is solving is stated directly, namely the limitations of lightweight models in semantic understanding and fine-grained control. The mechanism is a channel bridge between two networks of different kinds. The vision language model has layers with different levels of abstraction, and rather than taking the last one, the framework takes several and fuses them, then passes guidance into the diffusion transformer through learnable tokens. The think tokens are the interesting part, because they are a small learned interface between a model that understands and a model that paints, and they are what allows one set of weights to serve both jobs.

Three training stages, ending in MR-GRPO

The training strategy is described as data-centric and spans three progressive stages, and the staging is where most of the practical work is. The first is Alignment Pre-training on large-scale image-text pairs and editing triplets, with the stated purpose of synchronising the vision language model and the diffusion transformer representations so that the two halves of the model are talking about the same things. The second is Joint Supervised Fine-tuning on a high-quality mixture of generation, editing and reasoning tasks, described as building all of those capabilities at once, and the point of mixing the task types at this stage is that the model has to keep all five capabilities alive at once rather than specialise. The third is Reinforcement Learning with MR-GRPO, a mixture of reward functions and supervision signals, which the authors say results in substantial gains in generation quality and alignment with human preferences while maintaining stable training progress and avoiding visual artifacts. That last clause is the one to watch, because the mixture of reward functions is where the tuning burden sits, and the reinforcement learning code is in a separate repository, deepgen_rl, which means the stage three recipe is maintained apart from the main training code. The repository layout reflects the same split, with a DeepGen-RL/ directory alongside src/, configs/, scripts/, a figure/ directory with the architecture diagram, and separate DATA.md, TRAIN.md, INFERENCE.md and EVAL.md guides.

Installing it is a pinned environment and a flash attention build

The setup section is a conda environment with Python 3.12 and a list of pinned installs, and the pins are the interesting part because they are not the versions you would choose yourself.

git clone https://github.com/deepgenteam/deepgen.git
cd deepgen
conda create -n deepgen python=3.12 -y
conda activate deepgen
pip install -r requirements.txt
pip install flash_attn==2.8.3 --no-build-isolation
pip install xtuner==0.2.0
pip install transformers==4.56.1
pip install triton==2.3.0
pip install -U opencv-python-headless

The requirements file is a full training environment rather than an inference one, and it is worth reading for the shape of the stack. It pins diffusers at 0.35.2, deepspeed at 0.17.5, accelerate at 1.10.1, peft at 0.17.0, bitsandbytes at 0.45.0, mmengine at 0.10.6, datasets at 3.5.1, einops at 0.8.1, liger_kernel at 0.6.2, and a set of pinned nvidia CUDA 12 libraries for cuBLAS, cuDNN, NCCL, cuSPARSE and the rest. The inference path is therefore the same environment as the training path, which is convenient for a research workflow and heavy for anyone who only wants to run the model. The flash attention install with --no-build-isolation is the step that catches people out, since it has to compile against the local CUDA toolchain rather than build in an isolated environment.

Inference through the diffusers pipeline, with one code path for editing

The diffusers format is published separately as deepgenteam/DeepGen-1.0-diffusers, and the README says it is diffusers-compatible, with the native pipeline documented separately in INFERENCE.md. The text to image example is the standard diffusers shape, loading a DiffusionPipeline from the model id with bfloat16 and trust_remote_code enabled, moving it to cuda, and calling it with a prompt, a height and width, a step count, a guidance scale and a seed.

import torch
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained(
    "deepgenteam/DeepGen-1.0-diffusers",
    torch_dtype=torch.bfloat16,
    trust_remote_code=True,
)
pipe.to("cuda")

The editing example is the same pipeline object called again with an image argument, which is the detail that makes the unified claim concrete at the API level rather than only in the architecture diagram. The same pipe handles a text prompt to generate and a prompt plus an input image to edit, with the negative prompt spelled out in full for the editing case, listing blurry, low quality, low resolution, distorted, deformed and a long tail of other terms, which reads as a default recipe for suppressing the failure modes of an edit rather than a hand tuned value for one image.

The benchmark tables are where the claim is won or lost

The Benchmarks section is a set of tables comparing against named systems, and reading them carefully is the fastest way to see what the model is good at. The general image generation table compares Geneval, DPGBench and UniGenBench across OmniGen2 at 3B plus 4B, BAGEL at 14B, X-Omni at 7B plus 12B, Lumina-DiMOO at 8B, Hunyuan-Image-3.0 at 80B, Qwen-Image at 7B plus 20B and LongCat-Image at 7B plus 6B, with the parameter column making the size difference explicit and medal markers showing the best score in each column. A Papers with Code badge puts the paper at number three on RISEBench for the image editing task, which is a useful independent check on the self reported numbers. The honest reading of the table is that DeepGen competes rather than dominating. In the visible rows, the best Geneval score belongs to Lumina-DiMOO and the best DPGBench to Qwen-Image, both of which are larger, and the README's own framing of competitive with or surpassing is the accurate description rather than best everywhere. There is also a visible gap in the table, since Hunyuan-Image-3.0 has an em dash for UniGenBench, meaning no result was available for that entry, and the table is cut off before the rows covering DeepGen's own numbers.

What is not in the box yet

Two gaps are visible in the README and both are worth knowing before you plan around the project. The first is the data. The Hugging Face badge for the dataset reads Data Coming Soon, and the DATA.md file is described as holding a detailed description of the data download and usage procedures for both the pre-training stage and the supervised fine-tuning stage, which means the procedures are documented but the artefact is not yet published. For a project whose central claim is that the recipe is data-centric, a dataset that has not shipped is a substantial caveat, and anyone attempting to reproduce the training result is currently blocked on it. The second is the versioning. The repository has no GitHub releases, the model version is 1.0 rather than a moving series, and the last push was on 2026-07-31, so the code is a snapshot of a particular state rather than a stream of patches. The licence is Apache-2.0 for the code, which the LICENSE file in the repository root covers, and the weights on the model card are a separate question that the README does not address. The evaluation code is present, with scripts for a wide range of text to image and editing benchmarks documented in EVAL.md, and a separate DATA.md, TRAIN.md and INFERENCE.md for the rest, so a reader can see the intended workflow even where the artefacts are incomplete.

Editorial conclusion

DeepGen suits a research team that wants to study or adapt a unified generation and editing model without training a 20B or 80B system, since the 5B checkpoint fits on a single workstation class GPU and the repository ships pre-training, supervised fine-tuning and evaluation code alongside it. It is the wrong tool for a production image service today, because the model is a research release with checkpoints rather than a served product and the data is still marked as coming soon. It is also the wrong tool if you need the specific strengths of a much larger specialised model, since the README compares against models three to sixteen times its size. Before you commit, read the training and evaluation guides in the repository, check the pinned dependency versions in requirements.txt, and confirm the licence, which is Apache-2.0 for the code and a separate question for the checkpoint weights.

Frequently asked questions

Official sources

1. deepgenteam/deepgen on GitHub
2. Issues
3. License: Apache-2.0
4. Project website
5. README