@@ -38,7 +38,7 @@ bridge = AutoBridge.from_hf_pretrained(
 model_config = bridge.get_model_config()
 
 # Apply deployment-specific parallelism before construction.
-model_config.transformer.tensor_model_parallel_size = 8
+model_config.tensor_model_parallel_size = 8
 models = bridge.get_model(model_config)
 ```
 
 
@@ -16,6 +16,7 @@
     BuildConfigT,
     ModelBuilder,
     ModelConfig,
+    ModelConfigOverrideMixin,
     ModelT,
     Serializable,
     compose_hooks,
@@ -28,6 +29,7 @@
     "BuildConfigT",
     "ModelBuilder",
     "ModelConfig",
+    "ModelConfigOverrideMixin",
     "ModelT",
     "Serializable",
     "compose_hooks",
 
@@ -14,7 +14,7 @@
 
 from dataclasses import fields as dataclass_fields
 from dataclasses import is_dataclass
-from typing import Any
+from typing import Any, ClassVar
 
 from megatron.training.models.base import (
     BuildConfigT,  # noqa: F401
@@ -27,6 +27,7 @@
     ModelConfig as _MegatronModelConfig,
 )
 
+from megatron.bridge.models.transformer_config import TransformerConfig
 from megatron.bridge.utils.instantiate_utils import _resolve_target, _validate_target_prefix, instantiate
 
 
@@ -73,6 +74,42 @@ def _from_dict(subdata: dict[str, Any], full_key: str) -> Any:
     return result
 
 
+class ModelConfigOverrideMixin:
+    """Route flat overrides to their declared owner and reject unknown fields.
+
+    Builder-backed model configs store Megatron-Core transformer settings in a
+    nested ``transformer`` dataclass while exposing flat assignment for recipe
+    compatibility. This mixin keeps that convenience without allowing typos to
+    create phantom configuration attributes. Subclasses declare the nested
+    config type through ``transformer_config_class``.
+    """
+
+    transformer_config_class: ClassVar[type[TransformerConfig]]
+
+    def __setattr__(self, name: str, value: Any, /) -> None:
+        """Assign a declared outer or nested field and reject phantom fields."""
+        try:
+            transformer = object.__getattribute__(self, "transformer")
+        except AttributeError:
+            object.__setattr__(self, name, value)
+            return
+
+        model_fields = getattr(type(self), "__dataclass_fields__", {})
+        transformer_fields = getattr(type(transformer), "__dataclass_fields__", {})
+        descriptor = getattr(type(self), name, None)
+
+        if name == "transformer" or name in model_fields:
+            object.__setattr__(self, name, value)
+        elif name in transformer_fields:
+            setattr(transformer, name, value)
+        elif name == "builder" or name.startswith("_") or hasattr(descriptor, "__set__"):
+            object.__setattr__(self, name, value)
+        else:
+            raise AttributeError(
+                f"Neither {type(self).__name__} nor {type(transformer).__name__} declares a field named {name!r}."
+            )
+
+
 class ModelConfig(_MegatronModelConfig):
     """Bridge compatibility wrapper for Megatron-LM model configs."""
 
 
@@ -37,6 +37,7 @@
     Type,
     TypeVar,
     Union,
+    cast,
 )
 
 import torch
@@ -51,6 +52,7 @@
 from transformers.configuration_utils import PretrainedConfig
 from transformers.modeling_utils import PreTrainedModel
 
+from megatron.bridge.models.common import ModelConfigOverrideMixin
 from megatron.bridge.models.conversion.mapping_registry import MegatronMappingRegistry
 from megatron.bridge.models.conversion.param_mapping import (
     MegatronParamMapping,
@@ -433,11 +435,11 @@ def mapping_registry(self) -> MegatronMappingRegistry:
     # provider, such as one implementing MLA.
     PROVIDER_CLASS = None
 
-    # Builder-backed construction is rolling out incrementally by model family. Override these
-    # when the standard GPT or Transformer config cannot represent the model, and set
-    # MODEL_CONFIG_CLASS to None for families that have not yet migrated.
+    # Builder-backed construction is rolling out incrementally by model family. Override this
+    # when the standard GPT model config cannot represent the model, and set it to None for
+    # families that have not yet migrated. The selected model config owns its nested
+    # transformer config class.
     MODEL_CONFIG_CLASS: ClassVar[type[ModelConfig] | None] = BridgeGPTModelConfig
-    TRANSFORMER_CONFIG_CLASS: ClassVar[type[BridgeTransformerConfig]] = BridgeTransformerConfig
 
     # Leave unset unless HF export must copy nonstandard files in addition to the usual artifacts,
     # for example ``["*reasoning_parser.py"]``.
@@ -723,12 +725,23 @@ def hf_config_to_model_config(self, hf_config: PretrainedConfig) -> ModelConfig:
             )
 
         config_kwargs = self.hf_config_to_model_config_kwargs(hf_config)
+        if not issubclass(model_config_class, ModelConfigOverrideMixin):
+            raise TypeError(f"{model_config_class.__name__} must inherit {ModelConfigOverrideMixin.__name__}.")
+        model_config_with_overrides = cast(type[ModelConfigOverrideMixin], model_config_class)
+        transformer_config_class = model_config_with_overrides.transformer_config_class
+        if not isinstance(transformer_config_class, type) or not issubclass(
+            transformer_config_class, BridgeTransformerConfig
+        ):
+            raise TypeError(
+                f"{model_config_class.__name__}.transformer_config_class must be a "
+                f"{BridgeTransformerConfig.__name__} subclass."
+            )
         model_kwargs, transformer_kwargs = self._partition_model_config_kwargs(
             config_kwargs,
             model_config_class,
-            self.TRANSFORMER_CONFIG_CLASS,
+            transformer_config_class,
         )
-        transformer_config = self.TRANSFORMER_CONFIG_CLASS(**transformer_kwargs)
+        transformer_config = transformer_config_class(**transformer_kwargs)
         return model_config_class(transformer=transformer_config, **model_kwargs)
 
     # Set by @register_bridge decorator
 
@@ -15,16 +15,17 @@
 """Serializable Bridge extension of Megatron-LM's GPT model config."""
 
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, ClassVar
 
-from megatron.bridge.models.common.base import ModelConfig
+from megatron.bridge.models.common.base import ModelConfig, ModelConfigOverrideMixin
 from megatron.bridge.models.gpt.gpt_builder import GPTModelConfig
+from megatron.bridge.models.transformer_config import TransformerConfig
 from megatron.bridge.utils.activation_map import callable_to_str, str_to_callable
 from megatron.bridge.utils.instantiate_utils import _resolve_target
 
 
 @dataclass(kw_only=True)
-class BridgeGPTModelConfig(GPTModelConfig):
+class BridgeGPTModelConfig(ModelConfigOverrideMixin, GPTModelConfig, ModelConfig):
     """GPT model config with strict overrides and callable serialization.
 
     Outer GPT build fields and nested transformer fields keep one declared
@@ -37,29 +38,7 @@ class BridgeGPTModelConfig(GPTModelConfig):
     ``run_config.yaml`` without adding model-specific config fields.
     """
 
-    def __setattr__(self, name: str, value: Any, /) -> None:
-        """Assign a declared outer or nested field and reject phantom fields."""
-        try:
-            transformer = object.__getattribute__(self, "transformer")
-        except AttributeError:
-            object.__setattr__(self, name, value)
-            return
-
-        model_fields = getattr(type(self), "__dataclass_fields__", {})
-        transformer_fields = getattr(type(transformer), "__dataclass_fields__", {})
-
-        if name == "transformer":
-            object.__setattr__(self, name, value)
-        elif name in model_fields:
-            object.__setattr__(self, name, value)
-        elif name in transformer_fields:
-            setattr(transformer, name, value)
-        elif name == "builder" or name.startswith("_"):
-            object.__setattr__(self, name, value)
-        else:
-            raise AttributeError(
-                f"Neither {type(self).__name__} nor {type(transformer).__name__} declares a field named {name!r}."
-            )
+    transformer_config_class: ClassVar[type[TransformerConfig]] = TransformerConfig
 
     def get_builder_cls(self) -> type:
         """Resolve the configured builder through Bridge's target allowlist."""
 
@@ -138,7 +138,6 @@ class MuseGlimmerBridge(MegatronModelBridge):
     """Builder-backed bridge for the complete Muse Glimmer multimodal model."""
 
     MODEL_CONFIG_CLASS = MuseGlimmerModelConfig
-    TRANSFORMER_CONFIG_CLASS = MuseGlimmerTransformerConfig
 
     @staticmethod
     def _validate_architecture(hf_config: PretrainedConfig) -> tuple[Any, Any]:
 
@@ -21,7 +21,7 @@
 
 from megatron.training.models.hybrid import HybridModelConfig
 
-from megatron.bridge.models.common import deserialize_model_config
+from megatron.bridge.models.common import ModelConfigOverrideMixin, deserialize_model_config
 from megatron.bridge.models.transformer_config import TransformerConfig
 from megatron.bridge.utils.activation_map import callable_to_str, str_to_callable
 from megatron.bridge.utils.instantiate_utils import _resolve_target
@@ -67,10 +67,11 @@ def spatial_merge_size(self) -> int:
 
 
 @dataclass(kw_only=True)
-class MuseGlimmerModelConfig(HybridModelConfig):
+class MuseGlimmerModelConfig(ModelConfigOverrideMixin, HybridModelConfig):
     """Complete builder configuration for Muse Glimmer."""
 
     builder: ClassVar[str] = "megatron.bridge.models.muse_glimmer.MuseGlimmerModelBuilder"
+    transformer_config_class: ClassVar[type[TransformerConfig]] = MuseGlimmerTransformerConfig
     hybrid_attention_layers_include_mlp: ClassVar[bool] = True
 
     vision: MuseGlimmerVisionModelConfig = field(default_factory=MuseGlimmerVisionModelConfig)
 
@@ -28,6 +28,7 @@
     MuseGlimmerModelBuilder,
     MuseGlimmerModelConfig,
     MuseGlimmerTextConfig,
+    MuseGlimmerTransformerConfig,
     MuseGlimmerVisionConfig,
 )
 from megatron.bridge.models.muse_glimmer.modeling_muse_glimmer import (
@@ -131,6 +132,24 @@ def test_config_conversion_uses_model_config_path_only() -> None:
     assert model_config.vision_config.spatial_merge_size == 2
 
 
+def test_model_config_owns_transformer_type_and_routes_flat_overrides() -> None:
+    model_config = MuseGlimmerBridge().hf_config_to_model_config(_tiny_hf_config())
+
+    assert MuseGlimmerModelConfig.transformer_config_class is MuseGlimmerTransformerConfig
+    assert "TRANSFORMER_CONFIG_CLASS" not in MuseGlimmerBridge.__dict__
+
+    model_config.tensor_model_parallel_size = 8
+    model_config.seq_length = 512
+
+    assert model_config.transformer.tensor_model_parallel_size == 8
+    assert "tensor_model_parallel_size" not in model_config.__dict__
+    assert model_config.seq_length == 512
+    assert "seq_length" in model_config.__dict__
+
+    with pytest.raises(AttributeError, match="declares a field"):
+        model_config.tesnor_model_parallel_size = 4
+
+
 def test_config_conversion_uses_top_level_embedding_sharing_contract() -> None:
     """The VLM config, not its nested text config, owns HF weight tying."""
     hf_config = _tiny_hf_config()
 
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import inspect
+from dataclasses import dataclass
 from unittest.mock import Mock, patch
 
 import pytest
@@ -103,10 +104,45 @@ def test_model_config_mapping_rejects_unknown_fields() -> None:
         )
 
 
+def test_model_config_class_selects_nested_transformer_type(monkeypatch: pytest.MonkeyPatch) -> None:
+    @dataclass
+    class SpecializedTransformerConfig(TransformerConfig):
+        specialized_field: bool = False
+
+    class SpecializedModelConfig(BridgeGPTModelConfig):
+        transformer_config_class = SpecializedTransformerConfig
+
+    class SpecializedBridge(LlamaBridge):
+        MODEL_CONFIG_CLASS = SpecializedModelConfig
+
+    bridge = SpecializedBridge()
+    monkeypatch.setattr(
+        bridge,
+        "hf_config_to_model_config_kwargs",
+        lambda _hf_config: {
+            "num_layers": 2,
+            "hidden_size": 128,
+            "num_attention_heads": 4,
+            "ffn_hidden_size": 256,
+            "activation_func": F.silu,
+            "specialized_field": True,
+            "vocab_size": 256,
+        },
+    )
+
+    model_config = bridge.hf_config_to_model_config(object())
+
+    assert isinstance(model_config, SpecializedModelConfig)
+    assert isinstance(model_config.transformer, SpecializedTransformerConfig)
+    assert model_config.specialized_field is True
+
+
 def test_gpt_model_config_is_the_bridge_default() -> None:
     assert MegatronModelBridge.MODEL_CONFIG_CLASS is BridgeGPTModelConfig
     assert LlamaBridge.MODEL_CONFIG_CLASS is BridgeGPTModelConfig
     assert "MODEL_CONFIG_CLASS" not in LlamaBridge.__dict__
+    assert BridgeGPTModelConfig.transformer_config_class is TransformerConfig
+    assert not hasattr(MegatronModelBridge, "TRANSFORMER_CONFIG_CLASS")
 
 
 def test_bridge_can_explicitly_disable_model_config() -> None: