Verdict: Microsoft Mage-Flow is the best free, open-source local image generation model available in July 2026 if you want a lightweight 4B system that does both text-to-image and instruction-based editing at native resolution — no API keys, no subscription, no cloud. Its RL-aligned variant scores GenEval 0.90 (the highest among open-source models), runs in as few as 4 denoising steps, and ships under an MIT license that permits unrestricted commercial use. The catch: you need an NVIDIA GPU (ideals are an RTX 4090 or better), and first-run setup involves compiling flash-attention — not a one-click installer.
Last verified: 2026-07-29 · Best for local generation: Mage-Flow-RL (4B, 20 steps, GenEval 0.90) · Fastest: Mage-Flow-Turbo (4B, 4 steps, 0.59 s/image on A100) · Best for editing: Mage-Flow-Edit-RL (4B, 30 steps) · Lowest VRAM: ~2.2 GB at INT4 / ~9 GB at FP16 · License: MIT (commercial OK) · Pricing and model versions change often — last checked 2026-07-29.
What Is Microsoft Mage-Flow?
Mage-Flow is a compact 4B-parameter generative stack released by the Microsoft Mage Team in July 2026 for efficient text-to-image generation and instruction-based image editing. Instead of scaling to tens of billions of parameters like FLUX.2 (32B) or Qwen-Image (20B), Mage-Flow reaches state-of-the-art-competitive quality through tokenizer-backbone-system co-design, keeping it fast, memory-light, and easy to fine-tune on modest hardware. The code is on GitHub, the weights are on Hugging Face, and the technical report is on arXiv (2607.19064). The entire Mage-Flow family is released under the MIT license, which permits commercial use without restriction.
Mage-Flow is part of the broader Microsoft Mage model family, which also includes Mage-VL — a separate 4B model for image and video understanding (released under Apache-2.0). This article focuses on Mage-Flow, the generation and editing model.
How Does Mage-Flow Work?
Mage-Flow is built from two co-designed components. Mage-VAE is a lightweight latent tokenizer — a one-step diffusion codec that matches FLUX.2-VAE reconstruction fidelity while using roughly 12× fewer encode MACs and 22× fewer decode MACs per pixel, removing the VAE bottleneck at high resolutions. The NR-MMDiT (Native-Resolution Multimodal Diffusion Transformer) is a shared 4B backbone trained with rectified flow matching in the Mage-VAE latent space, using Qwen3-VL as its text encoder (arXiv 2607.19064).
The "native resolution" part matters: one checkpoint generates images from 512 to 2048 pixels on any aspect ratio, including extreme 4:1 panoramas (e.g., 512×2048 or 2048×512), without the resize-and-crop artifacts that fixed-resolution generators produce. Combined with native-resolution packing and fused CUDA kernels, the system achieves roughly 2.5× faster training and a measured MFU jump from ~33% to ~77% (microsoft/Mage GitHub).
Which Mage-Flow Variant Should You Pick?
There are six checkpoints, all 4B parameters, each self-contained as a diffusers-style repo on Hugging Face:
| Model | Task | Variant | Steps | Hugging Face |
|---|---|---|---|---|
| Mage-Flow-Base | text→image | Base | 30 | microsoft/Mage-Flow-Base |
| Mage-Flow (RL) | text→image | RL-aligned | 20 | microsoft/Mage-Flow |
| Mage-Flow-Turbo | text→image | Few-step distilled | 4 | microsoft/Mage-Flow-Turbo |
| Mage-Flow-Edit-Base | editing | Base | 30 | microsoft/Mage-Flow-Edit-Base |
| Mage-Flow-Edit (RL) | editing | RL-aligned | 30 | microsoft/Mage-Flow-Edit |
| Mage-Flow-Edit-Turbo | editing | Few-step distilled | 4 | microsoft/Mage-Flow-Edit-Turbo |
Source: microsoft/Mage GitHub repository
Pick the RL-aligned variant (Mage-Flow) for best quality at 20 steps. Pick Turbo if you need speed — 4 steps, 0.59 seconds per image at 1024² on an A100 (Microsoft Mage-Flow project page). Pick Base if you want more diverse outputs across a batch (RL-aligned models cluster more consistently around preferred visual conventions, while base models give a wider range of starting points). For editing, the same Base/RL/Turbo split applies — Turbo does an edit in ~1.02 seconds on an A100.
How Fast Is Mage-Flow on Consumer Hardware?
At 1024×1024 on a single NVIDIA A100, Microsoft reports Mage-Flow-Turbo generates an image in 0.59 seconds and Mage-Flow-Edit-Turbo edits in 1.02 seconds — the peak memory footprint is roughly 18–20 GB (Microsoft Mage-Flow project page). On more typical consumer hardware (RTX 4090, 24 GB VRAM), you should expect generation in seconds rather than sub-seconds, but the model fits comfortably in VRAM at FP16.
According to Spheron's GPU recommender (which estimates peak VRAM from safetensors metadata), the inference memory footprint is approximately:
| Precision | Inference VRAM | LoRA Fine-Tune VRAM | Full Fine-Tune VRAM |
|---|---|---|---|
| FP16 | ~9 GB | ~13 GB | ~36 GB |
| INT8 | ~4.5 GB | ~6.7 GB | ~18 GB |
| INT4 | ~2.2 GB | ~3.4 GB | ~9 GB |
This means an RTX 4090 (24 GB) handles FP16 inference with room for batching. An RTX 3060 12 GB can run INT8 or INT4 quantized variants comfortably. You can also use an RTX 5090 (32 GB) ($0.86/hr on cloud GPU marketplaces) or an L40S (48 GB) for heavier workloads. Apple Silicon (MPS) is supported but significantly slower — the Diffusers code path sets device_map="mps" for Apple devices (Hugging Face model card), but for production workloads, an NVIDIA CUDA GPU is strongly recommended.
How to Install Mage-Flow Locally
The official installation uses uv for dependency management and requires PyTorch with a matching CUDA toolkit. Here is the setup from the official README:
Step 1: Clone the repository
git clone https://github.com/microsoft/Mage.git
cd Mage/mage_flow
Step 2: Create a virtual environment and install dependencies
uv venv && source .venv/bin/activate
# Install the pinned, tested dependency set
# (torch 2.13, transformers 5.5, diffusers 0.38, pillow 12.3, etc.)
uv pip install -r requirements.txt
uv pip install -e . --no-deps
Step 3: Install flash-attention (requires CUDA toolkit)
Flash-attention needs build tools and a CUDA toolkit whose major version matches your torch build. If your CUDA toolkit is 12.x, install torch from the matching index first:
# Match your nvcc version (e.g., cu126 for CUDA 12.6)
uv pip install torch==2.13.0 torchvision==0.28.0 \
--index-url https://download.pytorch.org/whl/cu126
# Build flash-attn with isolation off
uv pip install setuptools wheel ninja
uv pip install --no-build-isolation flash-attn==2.8.3
This registers three CLI commands: mage-flow (text-to-image), mage-flow-edit (instruction-based editing), and mage-flow-app (Gradio web UI).
Step 4: Generate your first image
From the command line, let's generate a single image:
mage-flow --prompt "A cat eating pancakes, warm morning light, photorealistic" \
--model_path microsoft/Mage-Flow --steps 20 --seed 42 --out ./outputs
The model weights download automatically from Hugging Face on first run and are cached locally. Subsequent generations skip the download.
Step 5 (Optional): Launch the Gradio web UI
The Gradio app gives you a browser-based interface with a prompt field, model preset dropdown (Base, RL, Turbo), and live preview:
mage-flow-app --host 0.0.0.0 --port 7860
Open http://localhost:7860 in your browser. Add --share to create a public Gradio share link. Add --preload microsoft/Mage-Flow,microsoft/Mage-Flow-Turbo to load multiple checkpoints at startup (microsoft/Mage GitHub).
How to Edit Images With Mage-Flow-Edit
Mage-Flow-Edit supports instruction-based editing: you provide a source image and a natural-language instruction (e.g., "replace the background with a field of sunflowers") and the model performs the edit. It supports semantic content editing, appearance transformation, image restoration, and structure-aware outputs within a unified pipeline.
mage-flow-edit --prompt "Replace the background with a field of sunflowers" \
--ref assets/dog.jpg \
--model_path microsoft/Mage-Flow-Edit --max_size 1024 --out ./outputs
You can comma-separate multiple images for multi-image edits (e.g., blending two photos). The editing benchmarks are strong: Mage-Flow-Edit-Turbo scores GEdit-EN 8.271 and GEdit-CN 8.264, ranking first or second among all open-source editing models (Microsoft Mage-Flow project page).
How to Use Mage-Flow From Python
If you want to script Mage-Flow into a larger pipeline — or plug it into an agent workflow — the Python API exposes pipe.generate() and pipe.edit():
from mage_flow import MageFlowPipeline
pipe = MageFlowPipeline.from_pretrained("microsoft/Mage-Flow", device="cuda")
images = pipe.generate(
prompts=["A dragon flying over a misty mountain at dawn"],
steps=20,
seed=42,
height=1024,
width=1024,
)
images[0].save("./dragon.png")
The pipeline returns a list[PIL.Image] aligned with your prompts. A list of prompts is batched into one packed forward pass per denoise step, and each sample can have its own resolution and seed. This is the path to use if you are building an AI agent OS and want Mage-Flow as the visual generation backend.
How to Use Mage-Flow Via Hugging Face Spaces (No Local GPU Needed)
If you do not have a capable GPU locally, there is a free Hugging Face Space where you can try Mage-Flow in your browser. You describe the image you want, choose between "Mage-Flow quality" and "Mage-Flow turbo fast," optionally upload an input image for editing, and hit run. You wait for a GPU to become available (typically seconds to a few minutes), then the generated image appears in the page. This is the fastest way to test whether Mage-Flow produces the quality you need before committing to a local install. Just be aware that free Spaces have usage limits and queues — for unlimited or batch generation, run locally.
How Does Mage-Flow Compare to Other Open-Source Image Models?
Mage-Flow's headline number is GenEval 0.90 (RL-aligned, 20 steps) — the highest score among all open-source models, surpassing FLUX.2 (0.87), Qwen-Image (0.87), and Z-Image (0.84). The Turbo variant hits 0.88 GenEval in just 4 steps. Here is how the key open-source contenders stack up:
| Model | Params | Steps | GenEval | DPG-Bench | License | Min VRAM (FP16) |
|---|---|---|---|---|---|---|
| Mage-Flow (RL) | 4B | 20 | 0.90 | 86.49 | MIT | ~9 GB |
| Mage-Flow-Turbo | 4B | 4 | 0.88 | 85.48 | MIT | ~9 GB |
| Mage-Flow-Base | 4B | 30 | 0.79 | 86.26 | MIT | ~9 GB |
| FLUX.2-dev | 32B | 50 | 0.87 | 87.57 | Non-commercial | 80 GB+ |
| FLUX.2-Klein-9B | 9B | 4 | 0.86 | 86.20 | Non-commercial | ~29 GB |
| Qwen-Image | 20B | 50 | 0.87 | 88.32 | Open | Not reported |
| Z-Image-Turbo | 6B | 8 | 0.82 | 84.86 | Open | ~13 GB |
| ERNIE-Image (Baidu) | 8B | — | 0.89 | — | Apache-2.0 | ~24 GB |
Sources: Microsoft Mage-Flow project page, microsoft/Mage GitHub, Spheron GPU recommender, ERNIE-Image GitHub
The key differentiator: Mage-Flow is the only model in this table that combines top-tier benchmark scores, an MIT license (commercial use without restriction), and a 4B footprint that fits on a single consumer GPU at FP16. FLUX.2-dev's non-commercial license and 32B size make it impractical for many teams. ERNIE-Image is a strong alternative if you need excellent text rendering (LongTextBench 0.97+), but it requires ~24 GB VRAM and is twice the parameter count. For a broader comparison of local AI stacks, see our guide to the 5-layer local AI stack and our walkthrough on how to run local AI on your computer in 2026.
Can You Use Mage-Flow With an AI Agent?
Yes — this is where Mage-Flow gets interesting for builders. Because the entire model is local and scriptable via the Python API, you can wire it into an agent pipeline as the image-generation backend. An agent (whether you run it with Hermes Agent or a custom orchestrator) can call pipe.generate() with a prompt it constructs from context, get back a PIL image, and save it — all without an API key or cloud round-trip.
The practical pattern looks like this: your agent decides what image it needs (based on its task), constructs a prompt, calls Mage-Flow locally, waits for the result, and uses the image in its downstream work — whether that is embedding it in a document, posting it to a CMS, or feeding it into another model. Because the model runs in 4 steps (Turbo) and fits in 9 GB of VRAM, a single workstation can serve an interactive agent workflow. This is one of the most accessible local AI image generation setups available right now — and the MIT license means you can ship it in a commercial product without legal friction. For more on what makes an agent reliable enough to do this autonomously, see our breakdown of perception agents and AI computer use in 2026.
What Are the Limitations of Mage-Flow?
Mage-Flow is a research model with real constraints:
- No native ComfyUI support yet. As of late July 2026, you must use the official Python API, CLI, or Gradio app from the Mage repository. ComfyUI integration is expected but not available (ComfyUI Wiki).
- NVIDIA CUDA required for best results. Apple Silicon (MPS) works but is significantly slower. CPU-only generation is impractical.
- flash-attn build complexity. The installation requires a CUDA toolkit whose major version matches your PyTorch build, and flash-attention must be compiled from source with build isolation off. This is the most common setup failure.
- Research-grade safety. Microsoft's own model card notes the training data is sourced from web-scale collections and "may contain biases or uneven representation," and recommends the model "be used in controlled research settings with appropriate human oversight" (microsoft/Mage-Flow Hugging Face).
- Generation time on non-A100 hardware. Sub-second Turbo generation is an A100 number. On a Mac Studio or consumer RTX card, expect a few seconds to a couple of minutes depending on your setup and resolution.
What This Means for You
If you are a small business owner or content creator, Mage-Flow means you can generate unlimited custom images — product mockups, social graphics, blog headers — without a subscription or per-image fee. Run the Turbo variant locally on a single GPU workstation and get production-usable images in seconds. The MIT license means you own the output and can use it commercially.
If you are a developer building AI agents, the Python API and local execution make Mage-Flow a strong candidate for the visual-generation backend in your agent pipeline. No API costs, no rate limits, no data leaving your machine.
If you are a researcher, the 4B scale and modularity make it ideal for controlled experiments, fine-tuning research, and post-training studies — exactly the design goal Microsoft states in the repository. You can fine-tune on a single A100 or even an RTX 4090 (LoRA at ~13 GB FP16).
For everyone: the main barrier is the flash-attention install. Get past that and you have a free, MIT-licensed, top-tier image model running on your own hardware.
FAQ
Q: Is Microsoft Mage-Flow really free? A: Yes. Mage-Flow is released under the MIT license, which permits free commercial use with no restrictions. The model weights, code, and Gradio app are all available on Hugging Face and GitHub. Your only cost is the hardware you run it on.
Q: How much VRAM do I need to run Mage-Flow? A: Approximately 9 GB at FP16 precision for inference, 4.5 GB at INT8, and 2.2 GB at INT4, according to Spheron's GPU recommender. For the best experience at 1024×1024, an RTX 4090 (24 GB) or equivalent is recommended — peak memory at that resolution is roughly 18–20 GB (Microsoft project page).
Q: Can I run Mage-Flow on a Mac? A: Yes, via the MPS (Metal Performance Shaders) device path in Diffusers, but it will be significantly slower than on an NVIDIA CUDA GPU. The model is optimized for CUDA and uses flash-attention, which is CUDA-only. For production workloads, an NVIDIA GPU is strongly recommended.
Q: What is the difference between Mage-Flow and Mage-VL? A: Mage-Flow is for image generation and editing (text-to-image and instruction-based editing). Mage-VL is a separate model in the same family for image and video understanding (visual perception). They share the 4B scale but serve different purposes. Mage-Flow is MIT licensed; Mage-VL is Apache-2.0 (microsoft/Mage GitHub).
Q: Does Mage-Flow support image editing? A: Yes. Mage-Flow-Edit is a dedicated instruction-based editing model with the same three variants (Base, RL-aligned, Turbo). It supports semantic content editing, appearance transformation, image restoration, and structure-aware outputs. Mage-Flow-Edit-Turbo does an edit in ~1.02 seconds at 1024² on an A100 (Microsoft project page).
Q: Is there a ComfyUI node for Mage-Flow? A: Not yet, as of late July 2026. Mage-Flow currently requires the official Python API, CLI, or Gradio app from the Mage repository. ComfyUI support is expected but not yet available (ComfyUI Wiki).
Discussion
0 comments