@@ -393,6 +393,7 @@ class ModelBuilder(_InferenceRecommenderMixin, _ModelBuilderServers, _ModelBuild
     _tags: Optional[Tags] = field(default=None, init=False)
     _optimizing: bool = field(default=False, init=False)
     _deployment_config: Optional[Dict[str, Any]] = field(default=None, init=False)
+    _selected_hosting_config: Optional[Dict[str, Any]] = field(default=None, init=False)
 
     shared_libs: List[str] = field(
         default_factory=list,
@@ -964,6 +965,169 @@ def _is_gpu_instance(self, instance_type: str) -> bool:
         gpu_count = self._infer_accelerator_count_from_instance_type(instance_type)
         return gpu_count is not None and gpu_count > 0
 
+    def _resolve_recipe_hosting_configs(self) -> List[Dict[str, Any]]:
+        """Return the raw ``HostingConfigs`` list published for this model's recipe.
+
+        A fine-tuned (model-customization) model serves the base model under its recipe, so the
+        authoritative hosting configurations live in the JumpStart hub document under
+        ``RecipeCollection[<recipe>].HostingConfigs``. Falls back to the top-level
+        ``HostingConfigs`` when the recipe entry does not carry its own (some models publish
+        there instead). Raises when neither is present.
+        """
+        hub_document = self._fetch_hub_document_for_custom_model()
+        model_package = self._fetch_model_package()
+        containers = getattr(
+            getattr(model_package, "inference_specification", None), "containers", None
+        )
+        if not containers:
+            raise ValueError(
+                "Model is not supported for deployment: the model package has no inference "
+                "container to resolve a recipe from."
+            )
+        recipe_name = getattr(containers[0].base_model, "recipe_name", None) or ""
+
+        for recipe in hub_document.get("RecipeCollection", []):
+            if recipe.get("Name") == recipe_name:
+                configs = recipe.get("HostingConfigs")
+                if configs:
+                    return configs
+                break
+
+        configs = hub_document.get("HostingConfigs")
+        if configs:
+            return configs
+
+        detail = (
+            f"recipe '{recipe_name}'" if recipe_name else "this model's recipe"
+        )
+        raise ValueError(
+            f"Model is not supported for deployment: {detail} does not publish any "
+            "hosting configurations."
+        )
+
+    @staticmethod
+    def _raw_config_instance_type(cfg: Dict[str, Any]) -> Optional[str]:
+        """Instance type of a raw recipe ``HostingConfigs`` entry.
+
+        Recipe entries publish the instance type under ``InstanceType`` or, for some, only
+        ``DefaultInstanceType``. Every place that reads a raw entry's instance type MUST use this
+        so normalization, selection, and build-time matching stay consistent (otherwise a
+        ``DefaultInstanceType``-only config is listable/selectable but silently fails to re-match
+        at build and falls back to Default).
+        """
+        return cfg.get("InstanceType") or cfg.get("DefaultInstanceType")
+
+    @staticmethod
+    def _normalize_hosting_config(cfg: Dict[str, Any]) -> Dict[str, Any]:
+        """Normalize a raw recipe ``HostingConfigs`` entry into the SAME shape the base/JumpStart
+        ``list_deployment_configs`` response uses, so a caller can iterate results from either
+        pathway identically.
+
+        The serving fields live under ``DeploymentArgs`` with the SAME keys the base response
+        nests (``ImageUri``, ``InstanceType``, ``Environment``, ``ComputeResourceRequirements``,
+        ``ModelData``, ``ModelPackageArn``, ``ModelDataDownloadTimeout``,
+        ``ContainerStartupHealthCheckTimeout``, ``AdditionalDataSources``). Keys a recipe does not
+        provide are present with a ``None`` value so a caller can index the same keys on either
+        pathway without a ``KeyError``. ``BenchmarkMetrics``/``AccelerationConfigs`` are ``None``
+        (recipes don't publish these today; base emits ``None`` when absent too — extensible:
+        populate when recipes do). ``IsDefault`` is an additive convenience the recipe uniquely
+        provides (it marks one config with ``Profile == "Default"``) and is a superset of the base
+        response, which carries no per-config default flag.
+        """
+        profile = cfg.get("Profile")
+        instance_type = ModelBuilder._raw_config_instance_type(cfg)
+        return {
+            # Configs are mostly unnamed (only "Default" has a Profile); fall back to the instance
+            # type as a stable, human-meaningful identifier. Same key the base configs use.
+            "DeploymentConfigName": profile or instance_type,
+            "DeploymentArgs": {
+                "ImageUri": cfg.get("EcrAddress"),
+                "InstanceType": instance_type,
+                "Environment": cfg.get("Environment", {}),
+                "ComputeResourceRequirements": cfg.get("ComputeResourceRequirements", {}),
+                # Keys the base DeploymentArgs carries that recipe configs don't populate — present
+                # as None so both pathways expose an identical DeploymentArgs key set.
+                "ModelData": None,
+                "ModelPackageArn": None,
+                "ModelDataDownloadTimeout": None,
+                "ContainerStartupHealthCheckTimeout": None,
+                "AdditionalDataSources": None,
+            },
+            "BenchmarkMetrics": None,
+            "AccelerationConfigs": None,
+            "IsDefault": profile == "Default",
+        }
+
+    def _select_recipe_hosting_config(self, hosting_configs: list) -> dict:
+        """Select which recipe hosting configuration to apply.
+
+        A recipe publishes several pre-benchmarked hosting configurations (its
+        ``HostingConfigs``); each is a self-consistent bundle of an instance type,
+        serving container image (``EcrAddress``), container ``Environment`` (e.g.
+        ``OPTION_TENSOR_PARALLEL_DEGREE``), and ``ComputeResourceRequirements``.
+
+        Selection precedence:
+
+        1. A config explicitly chosen via :meth:`set_deployment_config`
+           (``_selected_hosting_config``).
+        2. The config whose ``InstanceType`` matches a caller-supplied ``instance_type`` — so its
+           image, environment, and compute requirements are all applied together and consistently,
+           rather than pinning the caller's instance onto the Default config's environment (which
+           would, for example, leave tensor-parallel degree at the Default value on a differently
+           sized instance). Mirrors the Nova path's ``_select_nova_hosting_config_entry``.
+        3. The ``Default`` config (or the first entry) — the prior behavior — when no instance type
+           was supplied, or when the supplied instance type matches no published config.
+
+        Args:
+            hosting_configs: The recipe's ``HostingConfigs`` list.
+
+        Returns:
+            The selected hosting config dict.
+        """
+        if not hosting_configs:
+            raise ValueError(
+                "Model is not supported for deployment: no hosting configurations to select from."
+            )
+        if self._selected_hosting_config is not None:
+            selected_instance = self._config_instance_type(self._selected_hosting_config)
+            match = next(
+                (
+                    cfg
+                    for cfg in hosting_configs
+                    if self._raw_config_instance_type(cfg) == selected_instance
+                ),
+                None,
+            )
+            if match is not None:
+                return match
+
+        if self._user_provided_instance_type and self.instance_type:
+            match = next(
+                (
+                    cfg
+                    for cfg in hosting_configs
+                    if self._raw_config_instance_type(cfg) == self.instance_type
+                ),
+                None,
+            )
+            if match is not None:
+                logger.info(
+                    "Selected recipe hosting config for instance type %s.",
+                    self.instance_type,
+                )
+                return match
+            logger.warning(
+                "Instance type %s does not match any published hosting config for this "
+                "recipe; falling back to the Default hosting config's container image, "
+                "environment, and compute requirements. Published instance types: %s",
+                self.instance_type,
+                [self._raw_config_instance_type(cfg) for cfg in hosting_configs],
+            )
+        return next(
+            (cfg for cfg in hosting_configs if cfg.get("Profile") == "Default"),
+            hosting_configs[0],
+        )
+
     def _fetch_and_cache_recipe_config(self):
         """Fetch and cache image URI, compute requirements, and s3_upload_path from recipe during build."""
         hub_document = self._fetch_hub_document_for_custom_model()
@@ -981,10 +1145,7 @@ def _fetch_and_cache_recipe_config(self):
             if recipe.get("Name") == recipe_name:
                 hosting_configs = recipe.get("HostingConfigs", [])
                 if hosting_configs:
-                    config = next(
-                        (cfg for cfg in hosting_configs if cfg.get("Profile") == "Default"),
-                        hosting_configs[0],
-                    )
+                    config = self._select_recipe_hosting_config(hosting_configs)
                     if not self.image_uri:
                         self.image_uri = config.get("EcrAddress")
 
@@ -4035,8 +4196,53 @@ def display_benchmark_metrics(self, **kwargs) -> None:
     @_telemetry_emitter(
         feature=Feature.MODEL_CUSTOMIZATION, func_name="model_builder.set_deployment_config"
     )
-    def set_deployment_config(self, config_name: str, instance_type: str) -> None:
-        """Sets the deployment config to apply to the model."""
+    def set_deployment_config(
+        self, config_name: Optional[str] = None, instance_type: Optional[str] = None
+    ) -> None:
+        """Select the deployment config to apply to the model.
+
+        One API for both model types. For base/JumpStart models, ``config_name`` chooses a named
+        deployment config (with ``instance_type``). For fine-tuned models, the configs are largely
+        unnamed, so selection is by ``instance_type`` — pass the ``InstanceType`` of a config from
+        :meth:`list_deployment_configs`. The whole matching config (container image, environment,
+        and compute requirements) is applied at build/deploy time.
+        """
+        if self._is_model_customization():
+            if not instance_type:
+                raise ValueError(
+                    "Select a deployment config by instance_type for this model "
+                    "(see list_deployment_configs())."
+                )
+            # Resolve the recipe's configs ONCE and derive both the match and the available-list
+            # from it (avoids re-resolving/re-fetching the hub document per branch).
+            configs = [
+                self._normalize_hosting_config(cfg)
+                for cfg in self._resolve_recipe_hosting_configs()
+            ]
+            matches = [c for c in configs if self._config_instance_type(c) == instance_type]
+            if not matches:
+                available = sorted(
+                    {
+                        self._config_instance_type(c)
+                        for c in configs
+                        if self._config_instance_type(c)
+                    }
+                )
+                raise ValueError(
+                    f"No deployment config published for instance type '{instance_type}'. "
+                    f"Available instance types: {available}"
+                )
+            if len(matches) > 1:
+                raise ValueError(
+                    f"Instance type '{instance_type}' matches {len(matches)} deployment configs; "
+                    "selection by instance type is ambiguous for this model."
+                )
+            self._selected_hosting_config = matches[0]
+            self.instance_type = instance_type
+            self._user_provided_instance_type = True
+            logger.info("Selected deployment config for instance type %s.", instance_type)
+            return
+
         if not isinstance(self.model, str):
             raise ValueError(
                 "Deployment config is only supported for JumpStart or HuggingFace models"
@@ -4045,6 +4251,9 @@ def set_deployment_config(self, config_name: str, instance_type: str) -> None:
         if not (self._is_jumpstart_model_id() or self._use_jumpstart_equivalent()):
             raise ValueError(f"The deployment config {config_name} cannot be set on this model")
 
+        if config_name is None:
+            raise ValueError("config_name is required to set a deployment config on this model.")
+
         self.config_name = config_name
         self.instance_type = instance_type
 
@@ -4068,7 +4277,24 @@ def set_deployment_config(self, config_name: str, instance_type: str) -> None:
         feature=Feature.MODEL_CUSTOMIZATION, func_name="model_builder.get_deployment_config"
     )
     def get_deployment_config(self) -> Optional[Dict[str, Any]]:
-        """Gets the deployment config to apply to the model."""
+        """Get the deployment config that will be applied to the model.
+
+        One API for both model types. For fine-tuned models, returns the config chosen via
+        :meth:`set_deployment_config` if one was set, otherwise the config that would be selected
+        by default at build time (matching a provided instance type, else the default config); it
+        raises if the model publishes no hosting configs. NOTE: this differs from the base/
+        JumpStart path, which returns ``None`` until a config is explicitly set — the fine-tuned
+        path always has a well-defined default (its recipe's Default config), so it reports that.
+        """
+        if self._is_model_customization():
+            if self._selected_hosting_config is not None:
+                return self._selected_hosting_config
+            # _resolve_recipe_hosting_configs raises when no configs are published, so a non-empty
+            # list is guaranteed here.
+            return self._normalize_hosting_config(
+                self._select_recipe_hosting_config(self._resolve_recipe_hosting_configs())
+            )
+
         if not isinstance(self.model, str):
             raise ValueError(
                 "Deployment config is only supported for JumpStart or HuggingFace models"
@@ -4092,19 +4318,59 @@ def get_deployment_config(self) -> Optional[Dict[str, Any]]:
     @_telemetry_emitter(
         feature=Feature.MODEL_CUSTOMIZATION, func_name="model_builder.list_deployment_configs"
     )
-    def list_deployment_configs(self) -> List[Dict[str, Any]]:
-        """List deployment configs for the model in the current region."""
-        if not isinstance(self.model, str):
-            raise ValueError(
-                "Deployment config is only supported for JumpStart or HuggingFace models"
-            )
+    def list_deployment_configs(
+        self, instance_type: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """List the deployment configs available for the model in the current region.
+
+        One API for both model types, returning the SAME dict shape so callers can iterate
+        results from either pathway identically: ``DeploymentConfigName`` plus a
+        ``DeploymentArgs`` block (``ImageUri``, ``InstanceType``, ``Environment``,
+        ``ComputeResourceRequirements``) and ``BenchmarkMetrics`` / ``AccelerationConfigs``. For
+        fine-tuned models the recipe's published configs are normalized into this shape;
+        ``BenchmarkMetrics``/``AccelerationConfigs`` are empty (recipes don't publish them yet) and
+        an additive ``IsDefault`` flag marks the recipe's Default config. When ``instance_type`` is
+        provided, only configs offering that instance type are returned — the supported way to
+        narrow the alternatives before selecting.
+        """
+        if self._is_model_customization():
+            configs = [
+                self._normalize_hosting_config(cfg)
+                for cfg in self._resolve_recipe_hosting_configs()
+            ]
+        else:
+            if not isinstance(self.model, str):
+                raise ValueError(
+                    "Deployment config is only supported for JumpStart or HuggingFace models"
+                )
 
-        if not (self._is_jumpstart_model_id() or self._use_jumpstart_equivalent()):
-            raise ValueError("Deployment config is only supported for JumpStart models")
+            if not (self._is_jumpstart_model_id() or self._use_jumpstart_equivalent()):
+                raise ValueError("Deployment config is only supported for JumpStart models")
+
+            configs = self.deployment_config_response_data(
+                self._get_deployment_configs(self.config_name, self.instance_type)
+            )  # Delegate to JumpStart builder
 
-        return self.deployment_config_response_data(
-            self._get_deployment_configs(self.config_name, self.instance_type)
-        )  # Delegate to JumpStart builder
+        if instance_type is not None:
+            configs = [
+                cfg for cfg in configs if self._config_instance_type(cfg) == instance_type
+            ]
+        return configs
+
+    @staticmethod
+    def _config_instance_type(config: Dict[str, Any]) -> Optional[str]:
+        """Extract the instance type from a normalized deployment config.
+
+        Both pathways nest the instance type under ``DeploymentArgs`` (fine-tuned configs are
+        normalized to the base shape by :meth:`_normalize_hosting_config`). A top-level
+        ``InstanceType`` is accepted as a defensive fallback.
+        """
+        deployment_args = config.get("DeploymentArgs") or {}
+        return (
+            deployment_args.get("InstanceType")
+            or deployment_args.get("instance_type")
+            or config.get("InstanceType")
+        )
 
     @_telemetry_emitter(feature=Feature.MODEL_CUSTOMIZATION, func_name="model_builder.optimize")
     # Add these methods to the current V3 ModelBuilder class: