@@ -181,6 +181,7 @@ Here is the list of the supported architectures :
 - Latent Consistency
 - Stable Diffusion 3
 - Flux
+- Flux.2
 - Sana
 - SanaSprint
 - LTX
 
@@ -1339,12 +1339,17 @@ def get_flux_models_for_export(pipeline, exporter, int_dtype, float_dtype):
     # Text encoder
     text_encoder = getattr(pipeline, "text_encoder", None)
     if text_encoder is not None:
+        text_encoder.config.model_type
+        model_type = "clip-text"
+        if text_encoder.config.model_type in ["qwen3"]:
+            model_type = "qwen3-text-encoder"
+
         text_encoder_config_constructor = TasksManager.get_exporter_config_constructor(
             model=text_encoder,
             exporter=exporter,
             library_name="diffusers",
             task="feature-extraction",
-            model_type="clip-text",
+            model_type=model_type,
         )
         text_encoder_export_config = text_encoder_config_constructor(
             pipeline.text_encoder.config, int_dtype=int_dtype, float_dtype=float_dtype
@@ -1355,6 +1360,10 @@ def get_flux_models_for_export(pipeline, exporter, int_dtype, float_dtype):
     transformer.config.text_encoder_projection_dim = transformer.config.joint_attention_dim
     transformer.config.requires_aesthetics_score = getattr(pipeline.config, "requires_aesthetics_score", False)
     transformer.config.time_cond_proj_dim = None
+
+    if not hasattr(transformer.config, "pooled_projection_dim") and hasattr(transformer.config, "joint_attention_dim"):
+        transformer.config.pooled_projection_dim = transformer.config.joint_attention_dim
+
     export_config_constructor = TasksManager.get_exporter_config_constructor(
         model=transformer,
         exporter=exporter,
@@ -1370,6 +1379,12 @@ def get_flux_models_for_export(pipeline, exporter, int_dtype, float_dtype):
 
     # VAE Encoder https://github.com/huggingface/diffusers/blob/v0.11.1/src/diffusers/models/vae.py#L565
     vae_encoder = copy.deepcopy(pipeline.vae)
+    # vae_scaling_factor is used at inference to scale latents
+    vae_scaling_factor = None
+    if hasattr(vae_encoder, "config") and getattr(vae_encoder.config, "scaling_factor", None) is not None:
+        vae_scaling_factor = float(vae_encoder.config.scaling_factor)
+        vae_encoder.register_to_config(scaling_factor=vae_scaling_factor)
+
     vae_encoder.forward = lambda sample: {"latent_parameters": vae_encoder.encode(x=sample)["latent_dist"].parameters}
     vae_config_constructor = TasksManager.get_exporter_config_constructor(
         model=vae_encoder,
@@ -1386,6 +1401,22 @@ def get_flux_models_for_export(pipeline, exporter, int_dtype, float_dtype):
 
     # VAE Decoder https://github.com/huggingface/diffusers/blob/v0.11.1/src/diffusers/models/vae.py#L600
     vae_decoder = copy.deepcopy(pipeline.vae)
+    if vae_scaling_factor is not None:
+        vae_decoder.register_to_config(scaling_factor=float(vae_scaling_factor))
+    # The transformer operates on normalized latents
+    # Before the VAE decoder can reconstruct pixels, the latents must be denormalized back
+    if (
+        hasattr(vae_decoder, "bn")
+        and hasattr(vae_decoder.bn, "running_mean")
+        and hasattr(vae_decoder.bn, "running_var")
+    ):
+        vae_decoder.register_to_config(
+            **{
+                "bn_running_mean_data": vae_decoder.bn.running_mean.detach().cpu().tolist(),
+                "bn_running_var_data": vae_decoder.bn.running_var.detach().cpu().tolist(),
+                "bn_eps": float(getattr(vae_decoder.bn, "eps", 1e-5)),
+            }
+        )
     vae_decoder.forward = lambda latent_sample: vae_decoder.decode(z=latent_sample)
     vae_config_constructor = TasksManager.get_exporter_config_constructor(
         model=vae_decoder,
 
@@ -592,7 +592,13 @@ def __init__(
     ):
         self.task = task
         self.batch_size = batch_size
-        self.pooled_projection_dim = normalized_config.config.pooled_projection_dim
+        config = normalized_config.config
+        pooled_projection_dim = getattr(config, "pooled_projection_dim", None)
+        # FrozenDict / dict requires get() method for attribute access
+        # getattr() will just return None
+        if pooled_projection_dim is None and hasattr(config, "get"):
+            pooled_projection_dim = config.get("pooled_projection_dim", None)
+        self.pooled_projection_dim = pooled_projection_dim
 
     def generate(self, input_name: str, framework: str = "pt", int_dtype: str = "int64", float_dtype: str = "fp32"):
         shape = [self.batch_size, self.pooled_projection_dim]
@@ -728,6 +734,8 @@ def __init__(
         super().__init__(task, normalized_config, batch_size, num_channels, width, height, **kwargs)
         if getattr(normalized_config, "in_channels", None):
             self.num_channels = normalized_config.in_channels // 4
+        self.config = normalized_config.config
+        self.is_flux2 = self.config.get("_class_name", "") == "Flux2Transformer2DModel"
 
     def generate(self, input_name: str, framework: str = "pt", int_dtype: str = "int64", float_dtype: str = "fp32"):
         if input_name in ["hidden_states", "sample"]:
@@ -736,12 +744,16 @@ def generate(self, input_name: str, framework: str = "pt", int_dtype: str = "int
         if input_name == "img_ids":
             img_ids_height = self.height // 2
             img_ids_width = self.width // 2
+            img_ids_shape = [self.batch_size, img_ids_height * img_ids_width, 3]
+            img_ids_shape = (
+                [self.batch_size, img_ids_height * img_ids_width, 3]
+                if is_diffusers_version("<", "0.31.0")
+                else [img_ids_height * img_ids_width, 3]
+            )
+            if self.is_flux2:
+                img_ids_shape = [self.batch_size, img_ids_height * img_ids_width, 4]
             return self.random_int_tensor(
-                (
-                    [self.batch_size, img_ids_height * img_ids_width, 3]
-                    if is_diffusers_version("<", "0.31.0")
-                    else [img_ids_height * img_ids_width, 3]
-                ),
+                img_ids_shape,
                 min_value=0,
                 max_value=min(img_ids_height, img_ids_width),
                 framework=framework,
@@ -764,11 +776,14 @@ def generate(self, input_name: str, framework: str = "pt", int_dtype: str = "int
         if input_name == "txt_ids":
             import torch
 
+            is_flux2 = self.normalized_config.config.get("_class_name", "") == "Flux2Transformer2DModel"
             shape = (
                 [self.batch_size, self.sequence_length, 3]
                 if is_diffusers_version("<", "0.31.0")
                 else [self.sequence_length, 3]
             )
+            if is_flux2:
+                shape = [self.batch_size, self.sequence_length, 4]
             dtype = DTYPE_MAPPER.pt(float_dtype)
             return torch.full(shape, 0, dtype=dtype)
         return super().generate(input_name, framework, int_dtype, float_dtype)
 
@@ -2314,6 +2314,35 @@ def inputs(self) -> Dict[str, Dict[int, str]]:
         }
 
 
+@register_in_tasks_manager("qwen3-text-encoder", *["feature-extraction"], library_name="diffusers")
+class Qwen3TextEncoderOpenVINOConfig(CLIPTextOpenVINOConfig):
+    @property
+    def inputs(self) -> Dict[str, Dict[int, str]]:
+        return {
+            "input_ids": {0: "batch_size", 1: "sequence_length"},
+            "attention_mask": {0: "batch_size", 1: "sequence_length"},
+        }
+
+    @property
+    def outputs(self) -> Dict[str, Dict[int, str]]:
+        common_outputs = {"last_hidden_state": {0: "batch_size", 1: "sequence_length"}}
+
+        num_layers = getattr(self._normalized_config, "num_layers", None)
+        if num_layers is None:
+            num_layers = getattr(self._normalized_config, "num_hidden_layers", 0)
+
+        for i in range(int(num_layers) + 1):
+            common_outputs[f"hidden_states.{i}"] = {0: "batch_size", 1: "sequence_length"}
+
+        return common_outputs
+
+    @property
+    def values_override(self) -> Optional[Dict[str, Any]]:
+        values = super().values_override or {}
+        values.update({"output_hidden_states": True, "return_dict": True, "use_cache": False})
+        return values
+
+
 @register_in_tasks_manager("sana-transformer", *["semantic-segmentation"], library_name="diffusers")
 class SanaTransformerOpenVINOConfig(UNetOpenVINOConfig):
     NORMALIZED_CONFIG_CLASS = NormalizedConfig.with_args(
@@ -2446,8 +2475,19 @@ class FluxTransformerOpenVINOConfig(SD3TransformerOpenVINOConfig):
 
     @property
     def inputs(self):
+        self.is_flux2 = self._config.get("_class_name", "") == "Flux2Transformer2DModel"
+
         common_inputs = super().inputs
         common_inputs.pop("sample", None)
+
+        config = self._normalized_config.config
+        pooled_projection_dim = config.get("pooled_projection_dim", None)
+
+        # FLUX.2 (klein): replaced CLIP+T5 with a single Qwen3 encoder
+        # Qwen3 produces sequence embeddings but no pooled embedding
+        if pooled_projection_dim is None:
+            common_inputs.pop("pooled_projections", None)
+
         common_inputs["hidden_states"] = {0: "batch_size", 1: "packed_height_width"}
         common_inputs["txt_ids"] = (
             {0: "batch_size", 1: "sequence_length"} if is_diffusers_version("<", "0.31.0") else {0: "sequence_length"}
 
@@ -105,6 +105,7 @@
             "OVLatentConsistencyModelImg2ImgPipeline",
             "OVLTXPipeline",
             "OVFluxPipeline",
+            "OVFlux2KleinPipeline",
             "OVFluxImg2ImgPipeline",
             "OVFluxInpaintPipeline",
             "OVFluxFillPipeline",
@@ -132,6 +133,7 @@
             "OVLatentConsistencyModelImg2ImgPipeline",
             "OVLTXPipeline",
             "OVFluxPipeline",
+            "OVFlux2KleinPipeline",
             "OVFluxImg2ImgPipeline",
             "OVFluxInpaintPipeline",
             "OVFluxFillPipeline",
 
@@ -95,6 +95,7 @@
 if is_diffusers_available():
     from .modeling_diffusion import (
         OVDiffusionPipeline,
+        OVFlux2KleinPipeline,
         OVFluxFillPipeline,
         OVFluxImg2ImgPipeline,
         OVFluxInpaintPipeline,
 
@@ -21,6 +21,7 @@
 from collections import OrderedDict
 from pathlib import Path
 from tempfile import gettempdir
+from types import SimpleNamespace
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import numpy as np
@@ -126,6 +127,11 @@
 else:
     CacheMixin = object
 
+if is_diffusers_version(">=", "0.37.0"):
+    from diffusers import Flux2KleinPipeline
+else:
+    Flux2KleinPipeline = object
+
 DIFFUSION_MODEL_TRANSFORMER_SUBFOLDER = "transformer"
 DIFFUSION_MODEL_TEXT_ENCODER_3_SUBFOLDER = "text_encoder_3"
 
@@ -764,6 +770,7 @@ def _reshape_transformer(
                 batch_size *= 2
 
         is_ltx = self.__class__.__name__.startswith("OVLTX")
+        is_flux2 = self.__class__.__name__.startswith("OVFlux2")
         if is_ltx:
             height = height // self.vae_spatial_compression_ratio if height > 0 else -1
             width = width // self.vae_spatial_compression_ratio if width > 0 else -1
@@ -804,8 +811,12 @@ def _reshape_transformer(
                     if is_diffusers_version("<", "0.31.0")
                     else [packed_height_width, 3]
                 )
+                if is_flux2:
+                    shapes[inputs] = [batch_size, packed_height_width, 4]
             elif inputs.get_any_name() == "txt_ids":
                 shapes[inputs] = [batch_size, -1, 3] if is_diffusers_version("<", "0.31.0") else [-1, 3]
+                if is_flux2:
+                    shapes[inputs] = [batch_size, -1, 4]
             elif inputs.get_any_name() in ["height", "width", "num_frames", "rope_interpolation_scale"]:
                 shapes[inputs] = inputs.get_partial_shape()
             else:
@@ -1163,6 +1174,7 @@ def forward(
         attention_mask: Optional[Union[np.ndarray, torch.Tensor]] = None,
         output_hidden_states: Optional[bool] = None,
         return_dict: bool = False,
+        **kwargs,
     ):
         self.compile()
         model_inputs = {"input_ids": input_ids}
@@ -1278,6 +1290,7 @@ def forward(
             model_inputs["pooled_projections"] = pooled_projections
         if img_ids is not None:
             model_inputs["img_ids"] = img_ids
+
         if txt_ids is not None:
             model_inputs["txt_ids"] = txt_ids
         if guidance is not None:
@@ -1403,6 +1416,18 @@ def __init__(self, decoder: OVModelVaeDecoder, encoder: OVModelVaeEncoder):
             self.latents_mean = torch.tensor(self.decoder.config.latents_mean_data)
         if hasattr(self.decoder.config, "latents_std_data"):
             self.latents_std = torch.tensor(self.decoder.config.latents_std_data)
+        # Flux2Klein compatibility: pipeline expects self.vae.bn.running_mean/running_var/eps
+        self.bn = None
+        bn_mean = getattr(self.decoder.config, "bn_running_mean_data", None)
+        bn_var = getattr(self.decoder.config, "bn_running_var_data", None)
+        bn_eps = float(getattr(self.decoder.config, "bn_eps", 1e-5))
+
+        if bn_mean is not None and bn_var is not None:
+            self.bn = SimpleNamespace(
+                running_mean=torch.tensor(bn_mean, dtype=torch.float32),
+                running_var=torch.tensor(bn_var, dtype=torch.float32),
+                eps=bn_eps,
+            )
 
     @property
     def _component_names(self) -> List[str]:
@@ -1627,6 +1652,25 @@ class OVFluxPipeline(OVDiffusionPipeline, OVTextualInversionLoaderMixin, FluxPip
     auto_model_class = FluxPipeline
 
 
+class OVFlux2KleinPipeline(OVDiffusionPipeline, OVTextualInversionLoaderMixin, Flux2KleinPipeline):
+    main_input_name = "prompt"
+    export_feature = "text-to-image"
+    auto_model_class = Flux2KleinPipeline
+
+    def __call__(self, *args, **kwargs):
+        if args and isinstance(args[0], str) and "prompt" not in kwargs:
+            user_prompt = args[0]
+            raise ValueError(
+                f"`prompt` must be passed as a keyword argument for Flux2Klein pipelines because the first positional "
+                f"argument is `image`. Use `pipeline(prompt={user_prompt!r})`."
+            )
+
+        if "guidance_scale" in kwargs and kwargs["guidance_scale"] is not None and kwargs["guidance_scale"] != 1.0:
+            kwargs["guidance_scale"] = 1.0
+
+        return super().__call__(*args, **kwargs)
+
+
 class OVFluxImg2ImgPipeline(OVDiffusionPipeline, OVTextualInversionLoaderMixin, FluxImg2ImgPipeline):
     main_input_name = "image"
     export_feature = "image-to-image"
@@ -1748,6 +1792,11 @@ def _get_ov_class(pipeline_class_name: str, throw_error_if_not_exist: bool = Tru
     SUPPORTED_OV_PIPELINES.append(OVSanaSprintPipeline)
     OV_TEXT2IMAGE_PIPELINES_MAPPING["sana-sprint"] = OVSanaSprintPipeline
 
+if is_diffusers_version(">=", "0.37.0"):
+    SUPPORTED_OV_PIPELINES.append(OVFlux2KleinPipeline)
+    OV_TEXT2IMAGE_PIPELINES_MAPPING["flux2-klein"] = OVFlux2KleinPipeline
+    OV_IMAGE2IMAGE_PIPELINES_MAPPING["flux2-klein"] = OVFlux2KleinPipeline
+
 SUPPORTED_OV_PIPELINES_MAPPINGS = [
     OV_TEXT2IMAGE_PIPELINES_MAPPING,
     OV_IMAGE2IMAGE_PIPELINES_MAPPING,
 
@@ -138,6 +138,7 @@
     "sam": "OVSamModel",
     "sana": "OVSanaPipeline",
     "flux": "OVFluxPipeline",
+    "flux.2-klein": "OVFlux2KleinPipeline",
     "flux-fill": "OVFluxFillPipeline",
     "pix2struct": "OVModelForPix2Struct",
     "latent-consistency": "OVLatentConsistencyModelPipeline",
 
@@ -213,6 +213,17 @@ def from_pretrained(cls, *args, **kwargs):
         requires_backends(cls, ["openvino", "diffusers"])
 
 
+class OVFlux2KleinPipeline(metaclass=DummyObject):
+    _backends = ["openvino", "diffusers"]
+
+    def __init__(self, *args, **kwargs):
+        requires_backends(self, ["openvino", "diffusers"])
+
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        requires_backends(cls, ["openvino", "diffusers"])
+
+
 class OVFluxImg2ImgPipeline(metaclass=DummyObject):
     _backends = ["openvino", "diffusers"]