diff --git a/docs/LOAD_SUBCONFIGS.md b/docs/LOAD_SUBCONFIGS.md
new file mode 100644
index 00000000..b2bed420
--- /dev/null
+++ b/docs/LOAD_SUBCONFIGS.md
@@ -0,0 +1,384 @@
+# Loading Subconfigs from MLflow runs
+
+## Goal:
+
+The goal is to be able to compose a config taking parts/entire configs that have been logged as MLflow artifacts from previous runs
+
+## Design:
+
+The proposed design is patterned after the Hydra [defaults list](https://hydra.cc/docs/advanced/defaults_list/):
+
+```
+mlflow_defaults:
+  (- MLFLOW_ENTRY)*
+
+MLFLOW_ENTRY      : CONFIG | OPTION_CONFIG | _self_
+CONFIG            : TARGET(@PACKAGE)?
+OPTION_CONFIG     : [optional|override]? TARGET(@PACKAGE)?: OPTION
+OPTION            : ARTIFACT_PATH | SELECT_PATH | ARTIFACT_PATH#SELECT_PATH | null
+```
+
+- `TARGET`: OmegaConf dot path within current config pointing to the [MLFlowConfig](https://github.com/Astera-org/simplexity/blob/657aff777cd7d7a6edfadd1f846bbf62028caeec/simplexity/structured_configs/mlflow.py#L21) node
+- `PACKAGE`: OmegaConf dot path where to place merged content (default: ".", i.e., root)
+- `ARTIFACT_PATH`: path within the MLflow run’s artifact dir to the source YAML without system extension (default: "config").
+  - If the path contains `/`, it is treated as an `ARTIFACT_PATH`.
+  - If the path does not contain `/`, it is ambiguous and defaults to `SELECT_PATH`. To force it to be an `ARTIFACT_PATH`, append `#` (e.g., `my_artifact#`).
+- `SELECT_PATH`: OmegaConf dot path within the source YAML to the subconfig to import (default: root).
+- `_self_`, `optional`, and `override` function the same as their Hydra equivalents.
+  - `_self_` determines the composition order. If missing, it is always appended to the end. If `_self_` is explicitly included, it is processed in the specified order.
+  - Standard merge semantics apply: **whatever comes last wins**, whether it's `_self_` or an MLflow entry.
+    - If `_self_` is first: MLflow entries merged after `_self_` will override the original config.
+    - If `_self_` is last: Original config merged after MLflow entries will override MLflow content.
+    - To override everything from `_self_`, explicitly include `_self_` first, then use `override` at root.
+  - `optional` suppresses errors if the artifact or selected subconfig is missing.
+  - `override` causes the loaded config to completely replace the value at the package path instead of merging. When override is used, any existing content at that path is completely replaced with the loaded content (no deep merge).
+
+### Merge Semantics for Overlapping Keys
+
+When multiple entries in `mlflow_defaults` (or `_self_`) have overlapping keys, the merge behavior follows Hydra's deep merge semantics:
+
+1. **Conflicting keys (same key path)**: The last entry wins. The value from the later entry completely replaces the value from earlier entries.
+
+   ```yaml
+   # Entry 1: other_section.foo = "first"
+   # Entry 2: other_section.foo = "second"
+   # Result: other_section.foo = "second" (Entry 2 wins)
+   ```
+
+2. **Non-conflicting keys at the same level**: Both keys are preserved. Nested dictionaries are merged deeply.
+
+   ```yaml
+   # Entry 1: other_section.key = 3, other_section.dict.subkey = 30
+   # Entry 2: other_section.foo = "bar"
+   # Result: other_section.key = 3, other_section.dict.subkey = 30, other_section.foo = "bar"
+   # (All keys preserved, nested dicts merged)
+   ```
+
+3. **Partially overlapping nested structures**: Deep merge preserves non-conflicting nested keys.
+   ```yaml
+   # Entry 1: other_section.dict.key1 = "value1", other_section.dict.key2 = "value2"
+   # Entry 2: other_section.dict.key2 = "new_value2", other_section.dict.key3 = "value3"
+   # Result:
+   #   other_section.dict.key1 = "value1" (preserved from Entry 1)
+   #   other_section.dict.key2 = "new_value2" (Entry 2 wins for conflicting key)
+   #   other_section.dict.key3 = "value3" (added from Entry 2)
+   ```
+
+This matches Hydra's defaults list behavior: entries are merged in order using `OmegaConf.merge()`, which performs deep merging of nested dictionaries.
+
+### OPTION Parsing Logic
+
+To resolve ambiguity in `OPTION`:
+
+1. If `OPTION` contains `#`:
+   - Split into `ARTIFACT_PART` and `SELECT_PART`.
+   - `ARTIFACT_PATH` = `ARTIFACT_PART` (if empty, defaults to "config").
+   - `SELECT_PATH` = `SELECT_PART` (if empty, defaults to root).
+2. Else (no `#`):
+   - If `OPTION` contains `/`:
+     - `ARTIFACT_PATH` = `OPTION`.
+     - `SELECT_PATH` = root.
+   - Else:
+     - `ARTIFACT_PATH` = "config".
+     - `SELECT_PATH` = `OPTION`.
+
+## Examples:
+
+### load entire `config.yaml` and merge at root
+
+```yaml
+defaults:
+  - mlflow@load_source: previous_run
+mlflow_defaults:
+  - load_source
+```
+
+### load `configs/model.yaml` and merge as old_model
+
+```yaml
+defaults:
+  - mlflow@load_source: previous_run
+mlflow_defaults:
+  # 'configs/model' contains '/', so it is treated as ARTIFACT_PATH
+  - load_source@old_model: configs/model
+```
+
+### load `persistence` subconfig from `config.yaml` if it exists
+
+```yaml
+defaults:
+  - mlflow@load_source: previous_run
+mlflow_defaults:
+  # 'persistence' has no '/' or '#', so it is treated as SELECT_PATH from default artifact 'config'
+  - optional load_source@persistence: persistence
+```
+
+### override `train.optimizer` with subconfig from` train.yaml`
+
+```yaml
+defaults:
+  - mlflow@load_source: previous_run
+  - train: smoke
+mlflow_defaults:
+  # usage of '#' explicit defines ARTIFACT_PATH (train) and SELECT_PATH (optimizer)
+  # override flag causes complete replacement of train.optimizer (no merge)
+  - override load_source@train.optimizer: train#optimizer
+```
+
+**Note**: With `override`, the entire `train.optimizer` section is replaced with the content from the artifact. Any existing keys in `train.optimizer` that are not in the artifact will be removed.
+
+### load `model` and `generative_process` from previous run
+
+```yaml
+defaults:
+  - mlflow@load_source: previous_run
+mlflow_defaults:
+  - load_source@model: model
+  - load_source@generative_process: generative_process
+```
+
+### load models from multiple runs
+
+```yaml
+defaults:
+  - model@current_model: transformer
+  - mlflow@load_source_1: previous_run_1
+  - mlflow@load_source_2: previous_run_2
+mlflow_defaults:
+  - load_source_1@old_model_1: model
+  - load_source_2@old_model_2: model
+```
+
+### Load a top-level artifact `custom.yaml` at root
+
+```yaml
+defaults:
+  - mlflow@load_source: previous_run
+mlflow_defaults:
+  # Use '#' to indicate 'custom' is the artifact, and select root
+  - load_source@custom_section: custom#
+```
+
+### Merge behavior with overlapping keys
+
+Deep merge semantics apply consistently everywhere, matching Hydra's defaults list behavior:
+
+1. **Loading at root (no package specified)**: Deep merge - multiple entries merge together, preserving non-conflicting keys.
+
+2. **Loading at a specific package path (e.g., `@other_section`)**: Deep merge - content merges with any existing content at that package path, preserving non-conflicting keys.
+
+   ```yaml
+   defaults:
+     - mlflow@load_source: previous_run
+   other_section:
+     foo: bar
+   mlflow_defaults:
+     - _self_
+     - load_source@other_section: config#
+   # Result: other_section contains both foo: bar (from _self_)
+   # and content from config (merged together)
+   ```
+
+3. **Multiple entries at the same package path**: Deep merge preserves non-conflicting keys:
+   ```yaml
+   mlflow_defaults:
+     - load_source_1@other_section: config1# # Loads at other_section
+     - load_source_2@other_section: config2# # Merges with config1's other_section
+   ```
+
+**Example of multiple entries with overlapping keys:**
+
+```yaml
+defaults:
+  - mlflow@load_source_1: previous_run_1
+  - mlflow@load_source_2: previous_run_2
+mlflow_defaults:
+  # Load config from run 1
+  - load_source_1@other_section: config1#
+  # Load config from run 2 (will merge with run 1's other_section)
+  - load_source_2@other_section: config2#
+```
+
+If `config1.yaml` contains:
+
+```yaml
+other_section:
+  key: 3
+  dict:
+    subkey: 30
+```
+
+And `config2.yaml` contains:
+
+```yaml
+other_section:
+  foo: bar
+  dict:
+    other_subkey: 40
+```
+
+The final result will be:
+
+```yaml
+other_section:
+  key: 3 # Preserved from config1 (non-conflicting)
+  foo: bar # Added from config2 (non-conflicting)
+  dict:
+    subkey: 30 # Preserved from config1 (non-conflicting nested key)
+    other_subkey: 40 # Added from config2 (non-conflicting nested key)
+```
+
+If both configs had `other_section.foo`, the value from `config2` would win (last entry wins for conflicting keys).
+
+**Note**: The `override` flag changes merge behavior: when specified, the loaded config completely replaces the value at the package path instead of merging. This means all existing keys at that path are removed and replaced with the loaded content.
+
+### Override flag behavior with `_self_`
+
+When `override` is used, the order of entries still matters. If `_self_` is explicitly included in the list, it will be processed in the order specified:
+
+```yaml
+mlflow_defaults:
+  - load_source_1@other_section: config1# # Merges at other_section
+  - override load_source_2@other_section: config2# # Replaces other_section completely
+  - _self_ # Merges original config, so original values can override the override
+```
+
+In this example:
+
+1. `config1` is merged into `other_section` (preserving existing keys, merging nested dicts)
+2. `config2` completely replaces `other_section` (removing all keys from step 1)
+3. `_self_` merges the original config, so any keys in the original `other_section` will override/replace what was loaded from `config2`
+
+**Important**: `_self_` is always auto-appended if not explicitly included, regardless of override usage. If you want to override everything from `_self_`, explicitly include `_self_` first, then use `override` at root:
+
+```yaml
+mlflow_defaults:
+  - _self_ # Explicitly include first
+  - override load_source # Then override at root, replacing everything
+```
+
+## Implementation:
+
+The proposed implementation is as a stand alone function that dynamically resolves the config:
+
+```python
+from mlflow.client import MlflowClient
+from omegaconf import DictConfig, OmegaConf
+
+from simplexity.utils.config_utils import dynamic_resolve
+
+def load_mlflow_defaults(cfg: DictConfig) -> DictConfig
+    # 1. Parse 'mlflow_defaults' list.
+    #    - If '_self_' is missing, append it to the end.
+
+    # 2. Iterate through items:
+    #    - If item is '_self_':
+    #         Merge original cfg (passed in argument) into the accumulator.
+    #    - Else (MLFLOW_ENTRY):
+    #         Parse TARGET, PACKAGE, OPTION.
+    #         If OPTION is "null":
+    #             If "optional" flag is set: continue (ignore)
+    #             Else: throw Error ("Config is mandatory but OPTION is null")
+    #
+    #         Resolve ARTIFACT_PATH and SELECT_PATH from OPTION.
+    #
+    #         Resolve 'tracking_uri', 'run_id' from cfg[TARGET].
+    #         Instantiate MlflowClient.
+    #
+    #         Download artifact (with caching/tempfile).
+    #         Load artifact as DictConfig.
+    #
+    #         Select subconfig if SELECT_PATH is set.
+    #
+    #         Merge into accumulator at PACKAGE.
+
+    # 3. Return accumulator.
+    ...
+```
+
+This could then be included in the `managed_run` decorator
+
+```python
+...
+cfg = get_config(args, kwargs)
+cfg = load_mlflow_defaults(cfg) # <- load subconfigs here
+validate_base_config(cfg)
+resolve_base_config(cfg, strict=strict)
+...
+```
+
+Or used as by itself, such as in a notebook:
+
+```python
+# %%
+cfg = DictConfig({
+    "load_source": DictConfig({
+        "experiment_id": "9828318895773678"
+        "run_id": "93c47bf390aef1273573b9dd53de2d3a"
+        "tracking_uri": "databricks"
+    }),
+    "mlflow_defaults": "load_source",
+})
+
+cfg = load_mlflow_defaults(cfg)
+```
+
+## Testing
+
+### Test Cases
+
+**Entries**
+
+- Single `ENTRY`
+- Multiple `ENTRY` items for different runs
+- Multiple `ENTRY` items for the same run
+- Multiple `ENTRY` items with shared keys but differing values
+  - Resulting value comes from last `ENTRY` in the list with that key
+- Explicit `_self_` omitted
+  - included implicitly at the end
+- Explicit `_self_` before other `ENTRY` item(s)
+
+**Packages**
+
+- Explicit `PACKAGE` omitted
+  - Load at config root by default
+- Load at specified `PACKAGE` path
+
+**Artifact Paths**
+
+- Explicit `ARTIFACT_PATH` omitted
+  - `config.yaml` loaded by default
+- Load config specified by `ARTIFACT_PATH`
+
+**Select Paths**
+
+- Explicit `SELECT_PATH` omitted
+  - Entire `TARGET` config loaded by default
+- Load subconfig specified by `SELECT_PATH`
+- Load a single key specified by `SELECT_PATH`
+
+**Options**
+
+- Explicit `optional` omitted
+  - Throws exception if `OPTION` is `null`
+  - Throws exception if there is an issue loading given `OPTION`
+- Explicit `optional` specified
+  - Accepts `null` value for `OPTION` effectively skipping that `ENTRY`
+  - Loads valid `OPTION` normally
+  - Skips that `ENTRY` if there is an issue loading given `OPTION`
+- Explicit `override` omitted
+  - No effect
+- Explicit `override` specified
+  - No effect
+
+### Unit Tests
+
+- There should be individual test functions for each of the [Test Cases]
+- Each case should be tested in relative isolation to the extent that that is feasible (use simplest defaults for components not under test)
+- Calls to `MlflowClient.download_artifacts` should be mocked with the side effect of saving a yaml file with content needed by the test in a temp directory to avoid this dependency not under test
+
+### Integration Tests
+
+- Should aim to broad coverage of the possibilites in [Test Cases]
+- Should test realistic workflows (such as corresponding to the structures of [Examples]) with individual tests typically covering multiple non-default elements of [Test Cases]
+- Should avoid any mocking (use local MLflow with `sqlite://` in a temp directory as the `tracking_uri`)
diff --git a/simplexity/run_management/run_management.py b/simplexity/run_management/run_management.py
index ed75a730..e8b3eb9f 100644
--- a/simplexity/run_management/run_management.py
+++ b/simplexity/run_management/run_management.py
@@ -64,6 +64,7 @@
     validate_metric_tracker_config,
 )
 from simplexity.structured_configs.mlflow import update_mlflow_config
+from simplexity.structured_configs.mlflow_defaults import load_mlflow_defaults
 from simplexity.structured_configs.optimizer import (
     is_optimizer_target,
     is_pytorch_optimizer_config,
@@ -633,6 +634,13 @@ def decorator(fn: Callable[..., Any]) -> Callable[..., Any]:
         def wrapper(*args: Any, **kwargs: Any) -> Any:
             try:
                 cfg = get_config(args, kwargs)
+                cfg = load_mlflow_defaults(cfg)
+                if "cfg" in kwargs:
+                    kwargs["cfg"] = cfg
+                elif args and isinstance(args[0], DictConfig):
+                    args = (cfg, *args[1:])
+                else:
+                    kwargs["cfg"] = cfg
                 validate_base_config(cfg)
                 resolve_base_config(cfg, strict=strict)
                 with _setup_device(cfg), _setup_mlflow(cfg):
diff --git a/simplexity/structured_configs/mlflow.py b/simplexity/structured_configs/mlflow.py
index f3b88403..e478cabf 100644
--- a/simplexity/structured_configs/mlflow.py
+++ b/simplexity/structured_configs/mlflow.py
@@ -11,10 +11,12 @@
 
 from dataclasses import dataclass
 
+from mlflow import MlflowClient
 from omegaconf import DictConfig
 
 from simplexity.structured_configs.validation import validate_bool, validate_nonempty_str, validate_uri
 from simplexity.utils.config_utils import dynamic_resolve
+from simplexity.utils.mlflow_utils import get_experiment, get_run, resolve_registry_uri
 
 
 @dataclass
@@ -53,6 +55,40 @@ def validate_mlflow_config(cfg: DictConfig) -> None:
     validate_uri(registry_uri, "MLFlowConfig.registry_uri", is_none_allowed=True)
 
 
+@dynamic_resolve
+def resolve_mlflow_config(cfg: DictConfig) -> None:
+    """Resolve a MLFlowConfig."""
+    # Resolve registry uri
+    tracking_uri: str | None = cfg.get("tracking_uri")
+    registry_uri: str | None = cfg.get("registry_uri")
+    downgrade_unity_catalog: bool = cfg.get("downgrade_unity_catalog", True)
+    cfg.registry_uri = resolve_registry_uri(
+        registry_uri=registry_uri,
+        tracking_uri=tracking_uri,
+        downgrade_unity_catalog=downgrade_unity_catalog,
+    )
+
+    client = MlflowClient(tracking_uri=tracking_uri, registry_uri=cfg.registry_uri)
+
+    # Resolve experiment id and name
+    experiment_id: str | None = cfg.get("experiment_id")
+    experiment_name: str | None = cfg.get("experiment_name")
+    experiment = get_experiment(experiment_id=experiment_id, experiment_name=experiment_name, client=client)
+    if experiment is None:
+        raise ValueError(f"Experiment not found for id: {experiment_id} and name: {experiment_name}")
+    cfg.experiment_id = experiment.experiment_id
+    cfg.experiment_name = experiment.name
+
+    # Resolve run id and name
+    run_id: str | None = cfg.get("run_id")
+    run_name: str | None = cfg.get("run_name")
+    run = get_run(run_id=run_id, run_name=run_name, experiment_id=cfg.experiment_id, client=client)
+    if run is None:
+        raise ValueError(f"Run not found for id: {run_id} and name: {run_name}")
+    cfg.run_id = run.info.run_id
+    cfg.run_name = run.info.run_name
+
+
 @dynamic_resolve
 def update_mlflow_config(cfg: DictConfig, updated_cfg: DictConfig) -> None:
     """Update a MLFlowConfig with the updated configuration."""
diff --git a/simplexity/structured_configs/mlflow_defaults.py b/simplexity/structured_configs/mlflow_defaults.py
new file mode 100644
index 00000000..772f3ad4
--- /dev/null
+++ b/simplexity/structured_configs/mlflow_defaults.py
@@ -0,0 +1,358 @@
+"""Load and merge configs from MLflow runs.
+
+This module implements the mlflow_defaults functionality, allowing configs to be
+composed from parts or entire configs that have been logged as MLflow artifacts
+from previous runs. The design is patterned after Hydra's defaults list.
+
+See LOAD_SUBCONFIGS.md for the full specification.
+"""
+
+# pylint: disable=all
+# Temporarily disable all pylint checkers during AST traversal to prevent crash.
+# The imports checker crashes when resolving simplexity package imports due to a bug
+# in pylint/astroid: https://github.com/pylint-dev/pylint/issues/10185
+# pylint: enable=all
+# Re-enable all pylint checkers for the checking phase. This allows other checks
+# (code quality, style, undefined names, etc.) to run normally while bypassing
+# the problematic imports checker that would crash during AST traversal.
+
+import re
+import tempfile
+from typing import Any, NamedTuple, cast
+
+import yaml
+from mlflow import MlflowClient
+from omegaconf import DictConfig, ListConfig, OmegaConf
+from omegaconf.errors import MissingMandatoryValue
+
+from simplexity.exceptions import ConfigValidationError
+from simplexity.logger import SIMPLEXITY_LOGGER
+from simplexity.structured_configs.mlflow import resolve_mlflow_config, validate_mlflow_config
+from simplexity.utils.config_utils import dynamic_resolve
+
+DEFAULT_ARTIFACT_NAME = "config"
+
+# TARGET(@PACKAGE)?
+# [optional|override]? TARGET(@PACKAGE)? : OPTION
+FLAGS_STR = r"(?P<flags>(?:(?:optional|override)\s+)*)"
+MLFLOW_CONFIG_ENTRY_STR = r"(?P<target>[\w\.]+)(?:@(?P<package>[\w\.]+))?"
+OPTION_STR = r"(?P<option>.*?)"
+MLFLOW_DEFAULT_ITEM_PATTERN = re.compile(rf"^{FLAGS_STR}(?:{MLFLOW_CONFIG_ENTRY_STR})?(?:\s*:\s*{OPTION_STR})?$")
+
+
+class _ParsedEntry(NamedTuple):
+    """Parsed MLflow default item."""
+
+    optional: bool
+    override: bool
+    target: str
+    package: str
+    artifact_path: str | None
+    select_path: str | None
+
+
+def _parse_option(option: str) -> tuple[str, str | None]:
+    """Parse artifact path and select path from option string."""
+    if "#" in option:
+        artifact_part, select_part = option.split("#", 1)
+        artifact_path = artifact_part.strip() or DEFAULT_ARTIFACT_NAME
+        select_path = select_part.strip() or None
+        return artifact_path, select_path
+
+    if "/" in option:
+        artifact_path = option.strip()
+        select_path = None
+        return artifact_path, select_path
+
+    artifact_path = DEFAULT_ARTIFACT_NAME
+    select_path = option.strip() or None
+    return artifact_path, select_path
+
+
+def _parse_entry(item: str) -> _ParsedEntry:
+    """Parse a single MLflow default item."""
+    match = MLFLOW_DEFAULT_ITEM_PATTERN.match(item)
+    if not match:
+        raise ValueError(
+            f"Invalid MLflow default entry: {item}. Must be in format '[optional|override]* TARGET(@PACKAGE)?: OPTION'"
+        )
+
+    groups = match.groupdict()
+    flags_str = groups.get("flags", "")
+    optional = "optional" in flags_str
+    override = "override" in flags_str
+
+    target = groups["target"]
+    if not target:
+        raise ValueError(
+            f"Invalid MLflow default entry: {item}. Must be in format "
+            "'TARGET(@PACKAGE)? | [optional|override]? TARGET(@PACKAGE)?: OPTION | _self_'"
+        )
+
+    package = groups.get("package")
+    option = groups.get("option")
+
+    # Check for null keyword first, before special case handling
+    if option == "null":
+        package = package or "."
+        return _ParsedEntry(optional, override, target, package, None, None)
+
+    # Special case: TARGET: VALUE (no @) where VALUE doesn't contain / or #
+    # Treat VALUE as both PACKAGE and SELECT_PATH
+    if package is None and option is not None and "/" not in option and "#" not in option:
+        package = option.rsplit(".", 1)[1] if "." in option else option
+        artifact_path = DEFAULT_ARTIFACT_NAME
+        select_path = option
+        return _ParsedEntry(optional, override, target, package, artifact_path, select_path)
+
+    package = package or "."
+
+    artifact_path, select_path = _parse_option(option or "")
+    return _ParsedEntry(optional, override, target, package, artifact_path, select_path)
+
+
+def _get_target_config(cfg: DictConfig, parsed_entry: _ParsedEntry) -> Any | None:
+    """Download and load config from MLflow run.
+
+    Args:
+        cfg: The current config containing MLflow config nodes.
+        parsed_entry: The parsed entry specifying target, package, and paths.
+
+    Returns:
+        The loaded config (or selected subconfig), or None if loading failed
+        and the entry is optional.
+    """
+    if parsed_entry.artifact_path is None:
+        SIMPLEXITY_LOGGER.warning("Config is mandatory but OPTION is null for entry: %s", parsed_entry.target)
+        return None
+
+    target_node: DictConfig | None = OmegaConf.select(cfg, parsed_entry.target)
+    if target_node is None:
+        SIMPLEXITY_LOGGER.warning("Target node '%s' not found in config", parsed_entry.target)
+        return None
+
+    try:
+        validate_mlflow_config(target_node)
+    except ConfigValidationError as e:
+        SIMPLEXITY_LOGGER.warning("Error validating MLflow config: %s", e)
+        return None
+
+    try:
+        resolve_mlflow_config(target_node)
+    except (ValueError, RuntimeError) as e:
+        SIMPLEXITY_LOGGER.warning("Error resolving MLflow config: %s", e)
+        return None
+
+    tracking_uri: str | None = target_node.get("tracking_uri")
+    run_id: str = target_node.get("run_id")
+    artifact_path = parsed_entry.artifact_path
+    if not artifact_path.endswith((".yaml", ".yml")):
+        artifact_path = f"{artifact_path}.yaml"
+    client = MlflowClient(tracking_uri=tracking_uri)
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        try:
+            local_path = client.download_artifacts(run_id=run_id, path=artifact_path, dst_path=tmp_dir)
+        except (OSError, FileNotFoundError) as e:
+            SIMPLEXITY_LOGGER.warning("Failed to download artifact from MLflow '%s': %s", parsed_entry.target, e)
+            return None
+
+        try:
+            loaded_config = OmegaConf.load(local_path)
+        except (OSError, FileNotFoundError, ValueError, yaml.YAMLError) as e:
+            SIMPLEXITY_LOGGER.warning("Failed to load MLflow default '%s': %s", parsed_entry.target, e)
+            return None
+
+    if parsed_entry.select_path is None:
+        return loaded_config
+
+    selected_config = OmegaConf.select(loaded_config, parsed_entry.select_path)
+    if selected_config is None:
+        SIMPLEXITY_LOGGER.warning(
+            "Selected path '%s' not found in artifact '%s'", parsed_entry.select_path, parsed_entry.artifact_path
+        )
+        return None
+
+    return selected_config
+
+
+def _normalize_item(item: str | DictConfig) -> str:
+    """Normalize an item to a string format.
+
+    If item is a DictConfig with a single key-value pair:
+    - If value is "config" (the default artifact), treat as just the key (no option)
+    - If value is None (Python None, from YAML null), convert to "key: null" string
+    - Otherwise, convert to "key: value" format
+    Otherwise, convert to string.
+    """
+    if isinstance(item, DictConfig):
+        keys = list(item.keys())
+        if len(keys) == 1:
+            key = keys[0]
+            value = item[key]
+            # If value is the default artifact name, treat as simple CONFIG entry
+            if value == DEFAULT_ARTIFACT_NAME:
+                return str(key)
+            # If value is None (from YAML null), convert to "null" string
+            # IMPORTANT: Check for None BEFORE f-string formatting to avoid converting
+            # Python None to the string "None" instead of "null"
+            if value is None:
+                return f"{key}: null"
+            # Format the value - this would convert None to "None" if the check above is bypassed
+            return f"{key}: {value}"
+        # Multiple keys - convert entire dict to string representation
+        return str(item)
+    return str(item)
+
+
+def _resolve_mlflow_configs_recursive(cfg: DictConfig) -> None:
+    """Recursively find and resolve all MLflow configs in the config.
+
+    This is needed when _self_ is processed and MLflow configs are merged unresolved.
+    MLflow configs that are not valid or can't be resolved are silently skipped.
+
+    Args:
+        cfg: The DictConfig to search for MLflow configs.
+    """
+    if not isinstance(cfg, DictConfig):
+        return
+
+    # Only try to validate/resolve if this looks like an MLflow config
+    # Check for key identifying fields (not just optional fields like registry_uri)
+    mlflow_identifying_fields = {"experiment_id", "experiment_name", "run_id", "run_name"}
+    has_mlflow_fields = any(field in cfg for field in mlflow_identifying_fields)
+
+    if has_mlflow_fields:
+        # Try to validate and resolve the current node as an MLflow config
+        try:
+            validate_mlflow_config(cfg)
+            # If validation passes, this looks like an MLflow config, try to resolve it
+            resolve_mlflow_config(cfg)
+        except (ConfigValidationError, ValueError, RuntimeError):
+            # Not an MLflow config or can't be resolved, continue to check nested configs
+            pass
+
+    # Recursively process all nested DictConfig values
+    for key in cfg:
+        try:
+            value = cfg[key]
+        except MissingMandatoryValue:
+            # Skip keys that can't be accessed (e.g., missing mandatory values)
+            continue
+
+        if isinstance(value, DictConfig):
+            _resolve_mlflow_configs_recursive(value)
+        elif isinstance(value, ListConfig):
+            # Also check ListConfig items that might be DictConfigs
+            for item in value:
+                if isinstance(item, DictConfig):
+                    _resolve_mlflow_configs_recursive(item)
+
+
+def _process_entry(cfg: DictConfig, accumulator: DictConfig, item: str) -> DictConfig:
+    """Process a single MLflow default item.
+
+    Handles both "_self_" entries (merging the original config) and MLflow entries
+    (downloading and merging configs from MLflow runs). Uses deep merge semantics
+    matching Hydra's defaults list behavior, unless the override flag is specified.
+
+    When override is True, the loaded config completely replaces the value at the
+    package path instead of merging with existing content.
+
+    Args:
+        cfg: The original config being processed.
+        accumulator: The accumulated merged config so far.
+        item: The entry to process (either "_self_" or an MLflow entry string).
+
+    Returns:
+        The updated accumulator with the entry merged in or replaced (if override).
+    """
+    if item == "_self_":
+        # Standard merge semantics: last entry wins (matches Hydra behavior)
+        # OmegaConf.merge does deep merge (nested dicts get merged), which matches
+        # how Hydra composes configs with defaults list
+        result = cast(DictConfig, OmegaConf.merge(accumulator, cfg))
+        # Resolve any MLflow configs that may have been merged unresolved
+        _resolve_mlflow_configs_recursive(result)
+        return result
+
+    parsed_entry = _parse_entry(item)
+
+    loaded_config = _get_target_config(cfg, parsed_entry)
+
+    if loaded_config is None:
+        if parsed_entry.optional:
+            return accumulator
+        raise ValueError(f"Target config not found for entry: {item}")
+
+    if parsed_entry.package == ".":
+        if not isinstance(loaded_config, DictConfig):
+            if parsed_entry.optional:
+                return accumulator
+            raise ValueError(f"Target config not found for entry: {item}")
+        if parsed_entry.override:
+            # Override at root: replace entire accumulator with loaded config
+            return loaded_config
+        return cast(DictConfig, OmegaConf.merge(accumulator, loaded_config))
+
+    # When merging at a package (not root)
+    if parsed_entry.override:
+        # Override: completely replace the value at the package path
+        # Traverse the path and directly assign the value to replace any existing content
+        package_parts = parsed_entry.package.split(".")
+        target = accumulator
+        # Navigate to the parent of the target key
+        for part in package_parts[:-1]:
+            if part not in target:
+                target[part] = OmegaConf.create()
+            target = target[part]
+        # Directly assign the new value, completely replacing any existing value
+        target[package_parts[-1]] = loaded_config
+        return accumulator
+
+    # Standard merge: use deep merge semantics (matches Hydra behavior)
+    # This ensures that MLflow content merges with any existing content at that package path,
+    # preserving non-conflicting keys and deeply merging nested dictionaries
+    package_conf = OmegaConf.create()
+    OmegaConf.update(package_conf, parsed_entry.package, loaded_config)
+    return cast(DictConfig, OmegaConf.merge(accumulator, package_conf))
+
+
+@dynamic_resolve
+def load_mlflow_defaults(cfg: DictConfig) -> DictConfig:
+    """Load and merge configs from MLflow runs based on mlflow_defaults list.
+
+    Processes the mlflow_defaults list in the config, downloading artifacts from
+    MLflow runs and merging them according to the specified package paths and
+    select paths. If "_self_" is not present, it is appended to the end.
+
+    Args:
+        cfg: The config containing mlflow_defaults list and MLflow config nodes.
+
+    Returns:
+        A new config with MLflow defaults merged in. The mlflow_defaults key is
+        removed from the result.
+
+    See Also:
+        LOAD_SUBCONFIGS.md for the full specification and examples.
+    """
+    mlflow_defaults: ListConfig | None = cfg.get("mlflow_defaults")
+    if mlflow_defaults is None:
+        return cfg
+
+    # Create a copy to avoid mutating the input config
+    mlflow_defaults_copy = cast(ListConfig, OmegaConf.create(list(mlflow_defaults)))
+    if "_self_" not in mlflow_defaults_copy:
+        mlflow_defaults_copy.append("_self_")
+
+    accumulator = cast(DictConfig, OmegaConf.create())
+
+    for item in mlflow_defaults_copy:
+        normalized_item = _normalize_item(item)
+        accumulator = _process_entry(cfg, accumulator, normalized_item)
+
+    # Remove mlflow_defaults key if it exists (it may not exist if override at root replaced everything)
+    if "mlflow_defaults" in accumulator:
+        del accumulator["mlflow_defaults"]
+
+    return accumulator
diff --git a/tests/end_to_end/conftest.py b/tests/end_to_end/conftest.py
new file mode 100644
index 00000000..1e8d3679
--- /dev/null
+++ b/tests/end_to_end/conftest.py
@@ -0,0 +1,68 @@
+"""End-to-end tests configuration."""
+
+# pylint: disable=all
+# Temporarily disable all pylint checkers during AST traversal to prevent crash.
+# The imports checker crashes when resolving simplexity package imports due to a bug
+# in pylint/astroid: https://github.com/pylint-dev/pylint/issues/10185
+# pylint: enable=all
+# Re-enable all pylint checkers for the checking phase. This allows other checks
+# (code quality, style, undefined names, etc.) to run normally while bypassing
+# the problematic imports checker that would crash during AST traversal.
+
+import shutil
+from pathlib import Path
+
+import mlflow
+import pytest
+from hydra import compose, initialize_config_dir
+from omegaconf import DictConfig
+
+from simplexity.logging.mlflow_logger import MLFlowLogger
+from simplexity.utils.mlflow_utils import get_experiment, get_run
+
+CONFIG_DIR = str(Path(__file__).parent / "mlflow_defaults_configs")
+EXPERIMENT_NAME = "test_mlflow_defaults"
+
+
+@pytest.fixture(scope="session")
+def setup_dir(tmp_path_factory: pytest.TempPathFactory) -> Path:
+    """Setup function."""
+    tmp_path = tmp_path_factory.mktemp("mlflow_defaults")
+    config_path = tmp_path / "configs"
+    shutil.copytree(f"{CONFIG_DIR}/setup", str(config_path))
+    tracking_uri = f"sqlite:///{tmp_path.resolve()}/mlflow.db"
+    mlflow.set_tracking_uri(tracking_uri)
+
+    def log_to_mlflow(cfg: DictConfig | None, config_names: list[str], run_name: str) -> None:
+        """Save config."""
+        experiment = get_experiment(experiment_name=EXPERIMENT_NAME)
+        assert experiment is not None
+        experiment_id = experiment.experiment_id
+        run = get_run(run_name=run_name, experiment_id=experiment_id)
+        assert run is not None
+        run_id = run.info.run_id
+        with mlflow.start_run(
+            run_id=run_id,
+            experiment_id=experiment_id,
+            run_name=run_name,
+            log_system_metrics=False,
+        ):
+            logger = MLFlowLogger(tracking_uri=tracking_uri)
+            if cfg is not None:
+                logger.log_config(cfg, resolve=False)
+            for config_name in config_names:
+                logger.log_artifact(local_path=str(config_path / config_name), artifact_path="subdir")
+
+    def previous_run(config_name: str | None, config_names: list[str], run_name: str) -> None:
+        """Previous run."""
+        if config_name is None:
+            cfg = None
+        else:
+            with initialize_config_dir(config_dir=str(config_path)):
+                cfg = compose(config_name=config_name)
+        log_to_mlflow(cfg, config_names, run_name)
+
+    previous_run(config_name="prev_config_1", config_names=["special_1.yaml"], run_name="prev_run_1")
+    previous_run(config_name="prev_config_2", config_names=["special_2.yaml"], run_name="prev_run_2")
+
+    return tmp_path
diff --git a/tests/end_to_end/mlflow_defaults_configs/composition_order_self_first.yaml b/tests/end_to_end/mlflow_defaults_configs/composition_order_self_first.yaml
new file mode 100644
index 00000000..92e56a7a
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/composition_order_self_first.yaml
@@ -0,0 +1,7 @@
+defaults:
+  - mlflow@load_source: prev_run_1
+other_section:
+  foo: bar
+mlflow_defaults:
+  - _self_
+  - load_source@other_section: subdir/special_1#
diff --git a/tests/end_to_end/mlflow_defaults_configs/composition_order_self_first_expected.yaml b/tests/end_to_end/mlflow_defaults_configs/composition_order_self_first_expected.yaml
new file mode 100644
index 00000000..e07228c3
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/composition_order_self_first_expected.yaml
@@ -0,0 +1,20 @@
+other_section:
+  foo: bar
+  key: 3
+  dict:
+    subkey: 30
+  group_a:
+    a_key: 3
+    a_dict:
+      a_subkey: 30
+  group_b:
+    b_key: 3
+    b_dict:
+      b_subkey: 30
+load_source:
+  experiment_name: test_mlflow_defaults
+  run_name: prev_run_1
+  tracking_uri: sqlite:///mlflow.db  # placeholder
+  registry_uri: null
+  experiment_id: "1"  # placeholder
+  run_id: "00000000000000000000000000000000"  # placeholder
diff --git a/tests/end_to_end/mlflow_defaults_configs/composition_order_self_last.yaml b/tests/end_to_end/mlflow_defaults_configs/composition_order_self_last.yaml
new file mode 100644
index 00000000..95bb779b
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/composition_order_self_last.yaml
@@ -0,0 +1,7 @@
+defaults:
+  - mlflow@load_source: prev_run_1
+other_section:
+  foo: bar
+mlflow_defaults:
+  - load_source@other_section: subdir/special_1#
+  - _self_
diff --git a/tests/end_to_end/mlflow_defaults_configs/composition_order_self_last_expected.yaml b/tests/end_to_end/mlflow_defaults_configs/composition_order_self_last_expected.yaml
new file mode 100644
index 00000000..6127550f
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/composition_order_self_last_expected.yaml
@@ -0,0 +1,20 @@
+other_section:
+  key: 3
+  dict:
+    subkey: 30
+  group_a:
+    a_key: 3
+    a_dict:
+      a_subkey: 30
+  group_b:
+    b_key: 3
+    b_dict:
+      b_subkey: 30
+  foo: bar
+load_source:
+  experiment_name: test_mlflow_defaults
+  run_name: prev_run_1
+  tracking_uri: sqlite:///mlflow.db  # placeholder
+  registry_uri: null
+  experiment_id: "1"  # placeholder
+  run_id: "00000000000000000000000000000000"  # placeholder
diff --git a/tests/end_to_end/mlflow_defaults_configs/full_default_copy.yaml b/tests/end_to_end/mlflow_defaults_configs/full_default_copy.yaml
new file mode 100644
index 00000000..a1fe6e49
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/full_default_copy.yaml
@@ -0,0 +1,4 @@
+defaults:
+  - mlflow@load_source: prev_run_1
+mlflow_defaults:
+  - load_source
\ No newline at end of file
diff --git a/tests/end_to_end/mlflow_defaults_configs/full_default_copy_expected.yaml b/tests/end_to_end/mlflow_defaults_configs/full_default_copy_expected.yaml
new file mode 100644
index 00000000..610debcc
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/full_default_copy_expected.yaml
@@ -0,0 +1,18 @@
+key: 1
+dict:
+  subkey: 10
+group_a:
+  a_key: 1
+  a_dict:
+    a_subkey: 10
+group_b:
+  b_key: 1
+  b_dict:
+    b_subkey: 10
+load_source:
+  experiment_name: test_mlflow_defaults
+  run_name: prev_run_1
+  tracking_uri: sqlite:///mlflow.db  # placeholder
+  registry_uri: null
+  experiment_id: "1"  # placeholder
+  run_id: "00000000000000000000000000000000"  # placeholder
diff --git a/tests/end_to_end/mlflow_defaults_configs/implicit_artifact_select.yaml b/tests/end_to_end/mlflow_defaults_configs/implicit_artifact_select.yaml
new file mode 100644
index 00000000..e8451c42
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/implicit_artifact_select.yaml
@@ -0,0 +1,4 @@
+defaults:
+  - mlflow@load_source: prev_run_1
+mlflow_defaults:
+  - load_source@dest: subdir/special_1
diff --git a/tests/end_to_end/mlflow_defaults_configs/implicit_artifact_select_expected.yaml b/tests/end_to_end/mlflow_defaults_configs/implicit_artifact_select_expected.yaml
new file mode 100644
index 00000000..61848826
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/implicit_artifact_select_expected.yaml
@@ -0,0 +1,19 @@
+dest:
+  key: 3
+  dict:
+    subkey: 30
+  group_a:
+    a_key: 3
+    a_dict:
+      a_subkey: 30
+  group_b:
+    b_key: 3
+    b_dict:
+      b_subkey: 30
+load_source:
+  experiment_name: test_mlflow_defaults
+  run_name: prev_run_1
+  tracking_uri: sqlite:///mlflow.db  # placeholder
+  registry_uri: null
+  experiment_id: "1"  # placeholder
+  run_id: "00000000000000000000000000000000"  # placeholder
diff --git a/tests/end_to_end/mlflow_defaults_configs/implicit_config_select.yaml b/tests/end_to_end/mlflow_defaults_configs/implicit_config_select.yaml
new file mode 100644
index 00000000..e79d0038
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/implicit_config_select.yaml
@@ -0,0 +1,4 @@
+defaults:
+  - mlflow@load_source: prev_run_1
+mlflow_defaults:
+  - load_source@dest: group_a
diff --git a/tests/end_to_end/mlflow_defaults_configs/implicit_config_select_expected.yaml b/tests/end_to_end/mlflow_defaults_configs/implicit_config_select_expected.yaml
new file mode 100644
index 00000000..dbf6f5f3
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/implicit_config_select_expected.yaml
@@ -0,0 +1,11 @@
+dest:
+  a_key: 1
+  a_dict:
+    a_subkey: 10
+load_source:
+  experiment_name: test_mlflow_defaults
+  run_name: prev_run_1
+  tracking_uri: sqlite:///mlflow.db  # placeholder
+  registry_uri: null
+  experiment_id: "1"  # placeholder
+  run_id: "00000000000000000000000000000000"  # placeholder
diff --git a/tests/end_to_end/mlflow_defaults_configs/load_default_config_at_package.yaml b/tests/end_to_end/mlflow_defaults_configs/load_default_config_at_package.yaml
new file mode 100644
index 00000000..7fdc40f9
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/load_default_config_at_package.yaml
@@ -0,0 +1,4 @@
+defaults:
+  - mlflow@load_source: prev_run_1
+mlflow_defaults:
+  - load_source@dest
diff --git a/tests/end_to_end/mlflow_defaults_configs/load_default_config_at_package_expected.yaml b/tests/end_to_end/mlflow_defaults_configs/load_default_config_at_package_expected.yaml
new file mode 100644
index 00000000..c741220c
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/load_default_config_at_package_expected.yaml
@@ -0,0 +1,19 @@
+dest:
+  key: 1
+  dict:
+    subkey: 10
+  group_a:
+    a_key: 1
+    a_dict:
+      a_subkey: 10
+  group_b:
+    b_key: 1
+    b_dict:
+      b_subkey: 10
+load_source:
+  experiment_name: test_mlflow_defaults
+  run_name: prev_run_1
+  tracking_uri: sqlite:///mlflow.db  # placeholder
+  registry_uri: null
+  experiment_id: "1"  # placeholder
+  run_id: "00000000000000000000000000000000"  # placeholder
diff --git a/tests/end_to_end/mlflow_defaults_configs/load_nondefault_config.yaml b/tests/end_to_end/mlflow_defaults_configs/load_nondefault_config.yaml
new file mode 100644
index 00000000..82756626
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/load_nondefault_config.yaml
@@ -0,0 +1,4 @@
+defaults:
+  - mlflow@load_source: prev_run_1
+mlflow_defaults:
+  - load_source: subdir/special_1#
diff --git a/tests/end_to_end/mlflow_defaults_configs/load_nondefault_config_expected.yaml b/tests/end_to_end/mlflow_defaults_configs/load_nondefault_config_expected.yaml
new file mode 100644
index 00000000..f75a3b3a
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/load_nondefault_config_expected.yaml
@@ -0,0 +1,18 @@
+key: 3
+dict:
+  subkey: 30
+group_a:
+  a_key: 3
+  a_dict:
+    a_subkey: 30
+group_b:
+  b_key: 3
+  b_dict:
+    b_subkey: 30
+load_source:
+  experiment_name: test_mlflow_defaults
+  run_name: prev_run_1
+  tracking_uri: sqlite:///mlflow.db  # placeholder
+  registry_uri: null
+  experiment_id: "1"  # placeholder
+  run_id: "00000000000000000000000000000000"  # placeholder
diff --git a/tests/end_to_end/mlflow_defaults_configs/load_subconfig.yaml b/tests/end_to_end/mlflow_defaults_configs/load_subconfig.yaml
new file mode 100644
index 00000000..88e2b479
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/load_subconfig.yaml
@@ -0,0 +1,4 @@
+defaults:
+  - mlflow@load_source: prev_run_1
+mlflow_defaults:
+  - load_source: group_a
diff --git a/tests/end_to_end/mlflow_defaults_configs/load_subconfig_expected.yaml b/tests/end_to_end/mlflow_defaults_configs/load_subconfig_expected.yaml
new file mode 100644
index 00000000..877bcb86
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/load_subconfig_expected.yaml
@@ -0,0 +1,11 @@
+group_a:
+  a_key: 1
+  a_dict:
+    a_subkey: 10
+load_source:
+  experiment_name: test_mlflow_defaults
+  run_name: prev_run_1
+  tracking_uri: sqlite:///mlflow.db  # placeholder
+  registry_uri: null
+  experiment_id: "1"  # placeholder
+  run_id: "00000000000000000000000000000000"  # placeholder
diff --git a/tests/end_to_end/mlflow_defaults_configs/load_subconfig_select.yaml b/tests/end_to_end/mlflow_defaults_configs/load_subconfig_select.yaml
new file mode 100644
index 00000000..ddfa0b29
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/load_subconfig_select.yaml
@@ -0,0 +1,4 @@
+defaults:
+  - mlflow@load_source: prev_run_1
+mlflow_defaults:
+  - load_source@dest: subdir/special_1#group_a.a_key
diff --git a/tests/end_to_end/mlflow_defaults_configs/load_subconfig_select_expected.yaml b/tests/end_to_end/mlflow_defaults_configs/load_subconfig_select_expected.yaml
new file mode 100644
index 00000000..e219585b
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/load_subconfig_select_expected.yaml
@@ -0,0 +1,8 @@
+dest: 3
+load_source:
+  experiment_name: test_mlflow_defaults
+  run_name: prev_run_1
+  tracking_uri: sqlite:///mlflow.db  # placeholder
+  registry_uri: null
+  experiment_id: "1"  # placeholder
+  run_id: "00000000000000000000000000000000"  # placeholder
diff --git a/tests/end_to_end/mlflow_defaults_configs/mlflow/prev_run_1.yaml b/tests/end_to_end/mlflow_defaults_configs/mlflow/prev_run_1.yaml
new file mode 100644
index 00000000..27c1b0c8
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/mlflow/prev_run_1.yaml
@@ -0,0 +1,3 @@
+experiment_name: test_mlflow_defaults
+run_name: prev_run_1
+tracking_uri: placeholder
\ No newline at end of file
diff --git a/tests/end_to_end/mlflow_defaults_configs/mlflow/prev_run_2.yaml b/tests/end_to_end/mlflow_defaults_configs/mlflow/prev_run_2.yaml
new file mode 100644
index 00000000..d0a49224
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/mlflow/prev_run_2.yaml
@@ -0,0 +1,3 @@
+experiment_name: test_mlflow_defaults
+run_name: prev_run_2
+tracking_uri: placeholder
\ No newline at end of file
diff --git a/tests/end_to_end/mlflow_defaults_configs/multiple_runs.yaml b/tests/end_to_end/mlflow_defaults_configs/multiple_runs.yaml
new file mode 100644
index 00000000..9bb9b463
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/multiple_runs.yaml
@@ -0,0 +1,6 @@
+defaults:
+  - mlflow@load_source_1: prev_run_1
+  - mlflow@load_source_2: prev_run_2
+mlflow_defaults:
+  - load_source_1@old_model_1
+  - load_source_2@old_model_2
diff --git a/tests/end_to_end/mlflow_defaults_configs/multiple_runs_expected.yaml b/tests/end_to_end/mlflow_defaults_configs/multiple_runs_expected.yaml
new file mode 100644
index 00000000..65fcb9a0
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/multiple_runs_expected.yaml
@@ -0,0 +1,38 @@
+old_model_1:
+  key: 1
+  dict:
+    subkey: 10
+  group_a:
+    a_key: 1
+    a_dict:
+      a_subkey: 10
+  group_b:
+    b_key: 1
+    b_dict:
+      b_subkey: 10
+old_model_2:
+  key: 2
+  dict:
+    subkey: 20
+  group_a:
+    a_key: 2
+    a_dict:
+      a_subkey: 20
+  group_b:
+    b_key: 2
+    b_dict:
+      b_subkey: 20
+load_source_1:
+  experiment_name: test_mlflow_defaults
+  run_name: prev_run_1
+  tracking_uri: sqlite:///mlflow.db  # placeholder
+  registry_uri: null
+  experiment_id: "1"  # placeholder
+  run_id: "00000000000000000000000000000000"  # placeholder
+load_source_2:
+  experiment_name: test_mlflow_defaults
+  run_name: prev_run_2
+  tracking_uri: sqlite:///mlflow.db  # placeholder
+  registry_uri: null
+  experiment_id: "1"  # placeholder
+  run_id: "00000000000000000000000000000000"  # placeholder
diff --git a/tests/end_to_end/mlflow_defaults_configs/override_flag.yaml b/tests/end_to_end/mlflow_defaults_configs/override_flag.yaml
new file mode 100644
index 00000000..a6d13a5e
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/override_flag.yaml
@@ -0,0 +1,7 @@
+defaults:
+  - mlflow@load_source: prev_run_1
+other_section:
+  foo: bar
+mlflow_defaults:
+  - _self_
+  - override load_source@other_section: subdir/special_1#
diff --git a/tests/end_to_end/mlflow_defaults_configs/override_flag_expected.yaml b/tests/end_to_end/mlflow_defaults_configs/override_flag_expected.yaml
new file mode 100644
index 00000000..8d4d28d3
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/override_flag_expected.yaml
@@ -0,0 +1,19 @@
+other_section:
+  key: 3
+  dict:
+    subkey: 30
+  group_a:
+    a_key: 3
+    a_dict:
+      a_subkey: 30
+  group_b:
+    b_key: 3
+    b_dict:
+      b_subkey: 30
+load_source:
+  experiment_name: test_mlflow_defaults
+  run_name: prev_run_1
+  tracking_uri: sqlite:///mlflow.db  # placeholder
+  registry_uri: null
+  experiment_id: "1"  # placeholder
+  run_id: "00000000000000000000000000000000"  # placeholder
diff --git a/tests/end_to_end/mlflow_defaults_configs/setup/group_a/subconfig_a1.yaml b/tests/end_to_end/mlflow_defaults_configs/setup/group_a/subconfig_a1.yaml
new file mode 100644
index 00000000..53a0ed55
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/setup/group_a/subconfig_a1.yaml
@@ -0,0 +1,3 @@
+a_key: 1
+a_dict:
+  a_subkey: 10
\ No newline at end of file
diff --git a/tests/end_to_end/mlflow_defaults_configs/setup/group_a/subconfig_a2.yaml b/tests/end_to_end/mlflow_defaults_configs/setup/group_a/subconfig_a2.yaml
new file mode 100644
index 00000000..ba32fc12
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/setup/group_a/subconfig_a2.yaml
@@ -0,0 +1,3 @@
+a_key: 2
+a_dict:
+  a_subkey: 20
\ No newline at end of file
diff --git a/tests/end_to_end/mlflow_defaults_configs/setup/group_b/subconfig_b1.yaml b/tests/end_to_end/mlflow_defaults_configs/setup/group_b/subconfig_b1.yaml
new file mode 100644
index 00000000..a89b185c
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/setup/group_b/subconfig_b1.yaml
@@ -0,0 +1,3 @@
+b_key: 1
+b_dict:
+  b_subkey: 10
\ No newline at end of file
diff --git a/tests/end_to_end/mlflow_defaults_configs/setup/group_b/subconfig_b2.yaml b/tests/end_to_end/mlflow_defaults_configs/setup/group_b/subconfig_b2.yaml
new file mode 100644
index 00000000..9e407359
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/setup/group_b/subconfig_b2.yaml
@@ -0,0 +1,3 @@
+b_key: 2
+b_dict:
+  b_subkey: 20
\ No newline at end of file
diff --git a/tests/end_to_end/mlflow_defaults_configs/setup/prev_config_1.yaml b/tests/end_to_end/mlflow_defaults_configs/setup/prev_config_1.yaml
new file mode 100644
index 00000000..375b3a59
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/setup/prev_config_1.yaml
@@ -0,0 +1,8 @@
+defaults:
+  - _self_
+  - group_a: subconfig_a1
+  - group_b: subconfig_b1
+
+key: 1
+dict:
+  subkey: 10
diff --git a/tests/end_to_end/mlflow_defaults_configs/setup/prev_config_2.yaml b/tests/end_to_end/mlflow_defaults_configs/setup/prev_config_2.yaml
new file mode 100644
index 00000000..d35c26bd
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/setup/prev_config_2.yaml
@@ -0,0 +1,8 @@
+defaults:
+  - _self_
+  - group_a: subconfig_a2
+  - group_b: subconfig_b2
+
+key: 2
+dict:
+  subkey: 20
\ No newline at end of file
diff --git a/tests/end_to_end/mlflow_defaults_configs/setup/special_1.yaml b/tests/end_to_end/mlflow_defaults_configs/setup/special_1.yaml
new file mode 100644
index 00000000..7b78e00b
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/setup/special_1.yaml
@@ -0,0 +1,11 @@
+key: 3
+dict:
+  subkey: 30
+group_a:
+  a_key: 3
+  a_dict:
+    a_subkey: 30
+group_b:
+  b_key: 3
+  b_dict:
+    b_subkey: 30
diff --git a/tests/end_to_end/mlflow_defaults_configs/setup/special_2.yaml b/tests/end_to_end/mlflow_defaults_configs/setup/special_2.yaml
new file mode 100644
index 00000000..a2d9aabc
--- /dev/null
+++ b/tests/end_to_end/mlflow_defaults_configs/setup/special_2.yaml
@@ -0,0 +1,11 @@
+key: 4
+dict:
+  subkey: 40
+group_a:
+  a_key: 4
+  a_dict:
+    a_subkey: 40
+group_b:
+  b_key: 4
+  b_dict:
+    b_subkey: 40
diff --git a/tests/end_to_end/test_load_config_from_mlflow.py b/tests/end_to_end/test_load_config_from_mlflow.py
new file mode 100644
index 00000000..b7db1fa1
--- /dev/null
+++ b/tests/end_to_end/test_load_config_from_mlflow.py
@@ -0,0 +1,107 @@
+"""End-to-end mlflow defaults tests."""
+
+# pylint: disable=all
+# Temporarily disable all pylint checkers during AST traversal to prevent crash.
+# The imports checker crashes when resolving simplexity package imports due to a bug
+# in pylint/astroid: https://github.com/pylint-dev/pylint/issues/10185
+# pylint: enable=all
+# Re-enable all pylint checkers for the checking phase. This allows other checks
+# (code quality, style, undefined names, etc.) to run normally while bypassing
+# the problematic imports checker that would crash during AST traversal.
+
+from pathlib import Path
+
+import mlflow
+import pytest
+from hydra import compose, initialize_config_dir
+from omegaconf import OmegaConf
+
+from simplexity.structured_configs.mlflow_defaults import load_mlflow_defaults
+
+CONFIG_DIR = str(Path(__file__).parent / "mlflow_defaults_configs")
+
+EXPERIMENT_NAME = "test_mlflow_defaults"
+
+
+def test_setup(setup_dir: Path, tmp_path: Path) -> None:
+    """Test setup."""
+    tracking_uri = f"sqlite:///{setup_dir.resolve()}/mlflow.db"
+    client = mlflow.MlflowClient(tracking_uri=tracking_uri)
+    experiments = client.get_experiment_by_name(name=EXPERIMENT_NAME)
+    assert experiments is not None
+    experiment_id = experiments.experiment_id
+
+    for run_num in (1, 2):
+        run = client.search_runs(
+            experiment_ids=[experiment_id], filter_string=f"attributes.run_name = 'prev_run_{run_num}'"
+        )
+        assert len(run) == 1
+        run_id = run[0].info.run_id
+
+        config_path = client.download_artifacts(
+            run_id=run_id, path="config.yaml", dst_path=str(tmp_path / f"config_{run_num}.yaml")
+        )
+
+        actual = OmegaConf.load(config_path)
+        with initialize_config_dir(config_dir=str(setup_dir / "configs")):
+            expected = compose(config_name=f"prev_config_{run_num}.yaml")
+        assert actual == expected
+
+        downloaded_dir = client.download_artifacts(
+            run_id=run_id,
+            path="subdir",
+            dst_path=str(tmp_path),
+        )
+        special_config_path = Path(downloaded_dir) / f"special_{run_num}.yaml"
+        expected_special_config_path = setup_dir / "configs" / f"special_{run_num}.yaml"
+        with (
+            open(special_config_path, encoding="utf-8") as f,
+            open(expected_special_config_path, encoding="utf-8") as expected_f,
+        ):
+            assert f.read() == expected_f.read()
+
+
+@pytest.mark.parametrize(
+    ("test_case", "load_sources"),
+    [
+        ("full_default_copy", ["load_source"]),
+        ("load_default_config_at_package", ["load_source"]),
+        ("load_nondefault_config", ["load_source"]),
+        ("load_subconfig", ["load_source"]),
+        ("load_subconfig_select", ["load_source"]),
+        ("implicit_config_select", ["load_source"]),
+        ("implicit_artifact_select", ["load_source"]),
+        ("override_flag", ["load_source"]),
+        ("composition_order_self_first", ["load_source"]),
+        ("composition_order_self_last", ["load_source"]),
+        ("multiple_runs", ["load_source_1", "load_source_2"]),
+    ],
+)
+def test_mlflow_defaults(setup_dir: Path, test_case: str, load_sources: list[str]) -> None:
+    """Test mlflow defaults."""
+    tracking_uri = f"sqlite:///{setup_dir.resolve()}/mlflow.db"
+    with initialize_config_dir(config_dir=CONFIG_DIR):
+        # Generate overrides for all load sources
+        overrides = [f"{load_source}.tracking_uri={tracking_uri}" for load_source in load_sources]
+        cfg = compose(config_name=test_case, overrides=overrides)
+    actual = load_mlflow_defaults(cfg)
+
+    # Extract experiment_id and run_id for all load sources
+    expected_overrides = []
+    for load_source in load_sources:
+        experiment_id = OmegaConf.select(actual, f"{load_source}.experiment_id")
+        run_id = OmegaConf.select(actual, f"{load_source}.run_id")
+        assert experiment_id is not None
+        assert run_id is not None
+        expected_overrides.extend(
+            [
+                f"{load_source}.tracking_uri={tracking_uri}",
+                f'{load_source}.experiment_id="{experiment_id}"',
+                f'{load_source}.run_id="{run_id}"',
+            ]
+        )
+
+    with initialize_config_dir(config_dir=CONFIG_DIR):
+        expected = compose(config_name=f"{test_case}_expected", overrides=expected_overrides)
+
+    assert actual == expected
diff --git a/tests/end_to_end/test_managed_run_mlflow_defaults.py b/tests/end_to_end/test_managed_run_mlflow_defaults.py
new file mode 100644
index 00000000..57210bbf
--- /dev/null
+++ b/tests/end_to_end/test_managed_run_mlflow_defaults.py
@@ -0,0 +1,47 @@
+from pathlib import Path
+
+from hydra import compose, initialize_config_dir
+from omegaconf import DictConfig, OmegaConf
+
+import simplexity
+
+CONFIG_DIR = str(Path(__file__).parent / "mlflow_defaults_configs")
+
+
+def test_managed_run_loads_mlflow_defaults(setup_dir: Path) -> None:
+    tracking_uri = f"sqlite:///{setup_dir.resolve()}/mlflow.db"
+    with initialize_config_dir(config_dir=CONFIG_DIR):
+        cfg = compose(
+            config_name="full_default_copy",
+            overrides=[f"load_source.tracking_uri={tracking_uri}"],
+        )
+
+    captured: dict[str, DictConfig] = {}
+
+    @simplexity.managed_run(strict=False)
+    def run(cfg: DictConfig, components: simplexity.Components) -> None:
+        captured["cfg"] = cfg
+
+    run(cfg)
+
+    actual = captured["cfg"]
+    experiment_id = OmegaConf.select(actual, "load_source.experiment_id")
+    run_id = OmegaConf.select(actual, "load_source.run_id")
+    assert experiment_id is not None
+    assert run_id is not None
+
+    expected_overrides = [
+        f"load_source.tracking_uri={tracking_uri}",
+        f'load_source.experiment_id="{experiment_id}"',
+        f'load_source.run_id="{run_id}"',
+    ]
+    with initialize_config_dir(config_dir=CONFIG_DIR):
+        expected = compose(config_name="full_default_copy_expected", overrides=expected_overrides)
+
+    actual_container = OmegaConf.to_container(actual, resolve=True)
+    actual_filtered = OmegaConf.create(actual_container)
+    for key in ("device", "seed", "tags"):
+        if key in actual_filtered:
+            del actual_filtered[key]
+
+    assert actual_filtered == expected
diff --git a/tests/run_management/test_load_mlflow_defaults.py b/tests/run_management/test_load_mlflow_defaults.py
new file mode 100644
index 00000000..ad44511d
--- /dev/null
+++ b/tests/run_management/test_load_mlflow_defaults.py
@@ -0,0 +1,822 @@
+"""Test MLflow defaults."""
+
+from pathlib import Path
+from unittest.mock import ANY, MagicMock
+
+import pytest
+from mlflow.client import MlflowClient
+from omegaconf import DictConfig, OmegaConf
+
+from simplexity.exceptions import ConfigValidationError
+from simplexity.structured_configs.mlflow_defaults import load_mlflow_defaults
+
+
+@pytest.fixture(autouse=True)
+def _patch_mlflow_helpers(mocker):
+    """Automatically patch common MLflow helper functions for all tests."""
+    mocker.patch("simplexity.structured_configs.mlflow_defaults.validate_mlflow_config")
+    mocker.patch("simplexity.structured_configs.mlflow_defaults.resolve_mlflow_config")
+
+
+@pytest.fixture
+def base_cfg() -> DictConfig:
+    """Set up the base config."""
+    return OmegaConf.create(
+        {
+            "previous_run": {
+                "tracking_uri": "databricks",
+                "run_id": "test_run_id",
+            },
+            "other_section": {"foo": "bar"},
+        }
+    )
+
+
+@pytest.fixture
+def mock_download(mocker) -> MagicMock:
+    """Create a mock MLflow client instance."""
+    mock_client_instance = MagicMock(spec=MlflowClient)
+    mocker.patch(
+        "simplexity.structured_configs.mlflow_defaults.MlflowClient",
+        return_value=mock_client_instance,
+    )
+    return mock_client_instance.download_artifacts
+
+
+def test_load_default_config_at_root(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test loading basic config."""
+    artifact_path = tmp_path / "config.yaml"
+    artifact_path.write_text("loaded_key: loaded_value\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run"],
+        },
+    )
+
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+
+    assert loaded_cfg.get("loaded_key") == "loaded_value"
+    assert OmegaConf.select(loaded_cfg, "other_section.foo") == "bar"
+
+
+def test_load_default_config_at_package(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test loading at package."""
+    artifact_path = tmp_path / "config.yaml"
+    artifact_path.write_text("loaded_key: loaded_value\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run@dest"],
+        },
+    )
+
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "dest.loaded_key") == "loaded_value"
+    assert OmegaConf.select(loaded_cfg, "other_section.foo") == "bar"
+    assert mock_download.call_args.kwargs["path"] == "config.yaml"
+
+
+def test_load_nondefault_config(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test loading basic config."""
+    artifact_path = tmp_path / "nondefault_config.yaml"
+    artifact_path.write_text("loaded_key: loaded_value\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run: nondefault_config#"],
+        },
+    )
+
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+
+    assert loaded_cfg.get("loaded_key") == "loaded_value"
+    assert OmegaConf.select(loaded_cfg, "other_section.foo") == "bar"
+    assert mock_download.call_args.kwargs["path"] == "nondefault_config.yaml"
+
+
+def test_load_subconfig(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test loading subconfig."""
+    artifact_path = tmp_path / "config.yaml"
+    artifact_path.write_text("root:\n  sub:\n    nested: value\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run: root.sub"],
+        },
+    )
+
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "sub.nested") == "value"
+    assert mock_download.call_args.kwargs["path"] == "config.yaml"
+
+
+def test_load_subconfig_select(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test loading subconfig select."""
+    artifact_path = tmp_path / "nondefault_config.yaml"
+    artifact_path.write_text("sub:\n  nested: value\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run@dest: nondefault_config#sub.nested"],
+        },
+    )
+
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert loaded_cfg.get("dest") == "value"
+
+
+def test_implicit_config_select(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test implicit artifact="config" when option has no / or #."""
+    artifact_path = tmp_path / "config.yaml"
+    artifact_path.write_text("sub: value\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run@dest: sub"],
+        },
+    )
+
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert loaded_cfg.get("dest") == "value"
+    mock_download.assert_called_with(run_id="test_run_id", path="config.yaml", dst_path=ANY)
+
+
+def test_implicit_artifact_select(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test implicit select=root when option has /."""
+    artifact_path = tmp_path / "artifact.yaml"
+    artifact_path.write_text("key: value\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run@dest: path/to/artifact"],
+        },
+    )
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "dest.key") == "value"
+    mock_download.assert_called_with(run_id="test_run_id", path="path/to/artifact.yaml", dst_path=ANY)
+
+
+def test_override_flag(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test override flag replaces instead of merging."""
+    # Artifact contains different keys than base config to verify replacement
+    artifact_path = tmp_path / "nondefault_config.yaml"
+    artifact_path.write_text("new_key: new_value\nother_key: other_value\n")
+    mock_download.return_value = str(artifact_path)
+
+    # Place _self_ first so original config is merged, then override replaces it
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["_self_", "override previous_run@other_section: nondefault_config#"],
+        },
+    )
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+
+    # Verify override replaced the entire other_section (no merge)
+    assert OmegaConf.select(loaded_cfg, "other_section.new_key") == "new_value"
+    assert OmegaConf.select(loaded_cfg, "other_section.other_key") == "other_value"
+    # Original foo: bar should be gone (replaced, not merged)
+    assert OmegaConf.select(loaded_cfg, "other_section.foo") is None
+
+
+def test_override_flag_at_root(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test override flag at root level with explicit _self_ first."""
+    artifact_path = tmp_path / "config.yaml"
+    artifact_path.write_text("root_key: root_value\nother_key: other_value\n")
+    mock_download.return_value = str(artifact_path)
+
+    # To override everything, explicitly include _self_ first, then override
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["_self_", "override previous_run"],
+        },
+    )
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+
+    # Verify override replaced entire config at root (after _self_ was processed)
+    assert OmegaConf.select(loaded_cfg, "root_key") == "root_value"
+    assert OmegaConf.select(loaded_cfg, "other_key") == "other_value"
+    # Original keys should be gone (override replaced everything)
+    assert OmegaConf.select(loaded_cfg, "other_section") is None
+    assert OmegaConf.select(loaded_cfg, "previous_run") is None
+
+
+def test_override_flag_at_root_without_explicit_self(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test override flag at root level without explicit _self_ - _self_ is auto-appended."""
+    artifact_path = tmp_path / "config.yaml"
+    artifact_path.write_text("root_key: root_value\nother_key: other_value\n")
+    mock_download.return_value = str(artifact_path)
+
+    # Without explicit _self_, it will be auto-appended at the end
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["override previous_run"],
+        },
+    )
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+
+    # Override replaced everything, but _self_ was auto-appended and merged after
+    # So original keys from _self_ should be back (last entry wins for conflicting keys)
+    assert OmegaConf.select(loaded_cfg, "other_section.foo") == "bar"
+    assert OmegaConf.select(loaded_cfg, "previous_run.tracking_uri") == "databricks"
+    # Keys from override that don't conflict with _self_ should still be present
+    assert OmegaConf.select(loaded_cfg, "root_key") == "root_value"
+    assert OmegaConf.select(loaded_cfg, "other_key") == "other_value"
+
+
+def test_override_flag_nested_path(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test override flag with nested package path."""
+    artifact_path = tmp_path / "config.yaml"
+    artifact_path.write_text("nested_key: nested_value\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["_self_", "override previous_run@nested.path: config#"],
+        },
+    )
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+
+    # Verify override replaced at nested path
+    assert OmegaConf.select(loaded_cfg, "nested.path.nested_key") == "nested_value"
+    # Original other_section should still exist (not affected)
+    assert OmegaConf.select(loaded_cfg, "other_section.foo") == "bar"
+
+
+def test_override_with_explicit_self(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test that _self_ is processed when explicitly included after override."""
+    artifact_path = tmp_path / "config.yaml"
+    artifact_path.write_text("key1: value1\nkey2: value2\n")
+    mock_download.return_value = str(artifact_path)
+
+    # Test with override followed by explicit _self_
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": [
+                "override previous_run@other_section: config#",
+                "_self_",  # Explicitly included, should merge after override
+            ],
+        },
+    )
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+
+    # Override replaced other_section, but _self_ merged after, so original foo should be back
+    assert OmegaConf.select(loaded_cfg, "other_section.foo") == "bar"  # From _self_
+    assert OmegaConf.select(loaded_cfg, "other_section.key1") == "value1"  # From override
+    assert OmegaConf.select(loaded_cfg, "other_section.key2") == "value2"  # From override
+
+
+def test_override_vs_merge_behavior(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test that override replaces while normal entry merges."""
+    artifact_path = tmp_path / "config.yaml"
+    artifact_path.write_text("key1: value1\nkey2: value2\n")
+    mock_download.return_value = str(artifact_path)
+
+    # Test with merge (no override)
+    cfg_merge = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["_self_", "previous_run@other_section: config#"],
+        },
+    )
+    loaded_merge: DictConfig = load_mlflow_defaults(cfg_merge)
+    # With merge, original foo should be preserved
+    assert OmegaConf.select(loaded_merge, "other_section.foo") == "bar"
+    assert OmegaConf.select(loaded_merge, "other_section.key1") == "value1"
+    assert OmegaConf.select(loaded_merge, "other_section.key2") == "value2"
+
+    # Test with override
+    cfg_override = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["_self_", "override previous_run@other_section: config#"],
+        },
+    )
+    loaded_override: DictConfig = load_mlflow_defaults(cfg_override)
+    # With override, original foo should be replaced
+    assert OmegaConf.select(loaded_override, "other_section.foo") is None
+    assert OmegaConf.select(loaded_override, "other_section.key1") == "value1"
+    assert OmegaConf.select(loaded_override, "other_section.key2") == "value2"
+
+
+def test_optional_flag_missing_artifact(base_cfg: DictConfig):
+    """Test optional flag with missing artifact."""
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["optional previous_run: null"],
+        },
+    )
+    # Should not raise
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert loaded_cfg == base_cfg
+
+
+def test_null_option_error(base_cfg: DictConfig):
+    """Test null option raises error."""
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run: null"],
+        },
+    )
+    # null option returns just the target config in new logic unless specific logic handles it differently
+    # Actually user logic for option="null" returns _ParsedEntry with artifact_path=None
+    # And _get_target_config handles artifact_path=None by warning and returning None
+    # So "mlflow: null" should be valid but yield nothing in accumulator if not trapped earlier?
+    # Re-reading logic in Step 245:
+    # _parse_entry returns artifact_path=None if option="null"
+    # _get_target_config checks if parsed_entry.artifact_path is None: logs Warning, returns None.
+    # _process_entry sees loaded_config is None.
+    # It raises ValueError("Target config not found for entry...") if not optional.
+    # So it SHOULD raise ValueError.
+
+    with pytest.raises(ValueError, match="Target config not found for entry"):
+        load_mlflow_defaults(cfg)
+
+
+def test_null_option_optional(base_cfg: DictConfig):
+    """Test null option with optional flag."""
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["optional previous_run: null"],
+        },
+    )
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "other_section") == cfg.other_section
+
+
+def test_null_option_dict_syntax_error(base_cfg: DictConfig):
+    """Test null option with YAML dict syntax raises error."""
+    # YAML dict syntax: - previous_run: null becomes DictConfig with None value
+    # This should be treated the same as string format: "previous_run: null"
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": [OmegaConf.create({"previous_run": None})],
+        },
+    )
+    # Should raise ValueError because null option without optional flag is mandatory
+    with pytest.raises(ValueError, match="Target config not found for entry"):
+        load_mlflow_defaults(cfg)
+
+
+def test_composition_order(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test _self_ placement in composition order."""
+    artifact_path = tmp_path / "nondefault_config.yaml"
+    artifact_path.write_text("foo: mlflow_value\n")
+    mock_download.return_value = str(artifact_path)
+
+    # Case 1: _self_ (default/original) before mlflow -> mlflow overrides
+    cfg1 = OmegaConf.merge(base_cfg, {"mlflow_defaults": ["_self_", "previous_run@other_section: nondefault_config#"]})
+    loaded1: DictConfig = load_mlflow_defaults(cfg1)
+    assert OmegaConf.select(loaded1, "other_section.foo") == "mlflow_value"
+
+    # Case 2: mlflow before _self_ -> original overrides (last entry wins)
+    cfg2 = OmegaConf.merge(base_cfg, {"mlflow_defaults": ["previous_run@other_section: nondefault_config#", "_self_"]})
+    loaded2: DictConfig = load_mlflow_defaults(cfg2)
+    assert OmegaConf.select(loaded2, "other_section.foo") == "bar"  # Original value wins (last entry)
+
+
+def test_config_entry_syntax(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test CONFIG syntax: TARGET (no option)."""
+    artifact_path = tmp_path / "nondefault_config.yaml"
+    artifact_path.write_text("key: val\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run"],
+        },
+    )
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "key") == "val"
+    # Implicitly loads "config" artifact
+    mock_download.assert_called_with(run_id="test_run_id", path="config.yaml", dst_path=ANY)
+
+
+def test_missing_target_error(base_cfg: DictConfig):
+    """Test missing target raises error."""
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["optional : option"],
+        },
+    )
+    with pytest.raises(ValueError, match="Invalid MLflow default entry"):
+        load_mlflow_defaults(cfg)
+
+
+def test_invalid_entry_format(base_cfg: DictConfig):
+    """Test invalid entry format raises error (line 64)."""
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["invalid@format@too@many@ats"],
+        },
+    )
+    with pytest.raises(ValueError, match="Invalid MLflow default entry"):
+        load_mlflow_defaults(cfg)
+
+
+def test_missing_target_node(base_cfg: DictConfig):
+    """Test missing target node in config (lines 96-97)."""
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["nonexistent: config"],
+        },
+    )
+    # Should raise ValueError because target node not found and not optional
+    with pytest.raises(ValueError, match="Target config not found for entry"):
+        load_mlflow_defaults(cfg)
+
+
+def test_missing_target_node_optional(base_cfg: DictConfig):
+    """Test missing target node with optional flag."""
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["optional nonexistent: config"],
+        },
+    )
+    # Should not raise, just return accumulator
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "other_section") == cfg.other_section
+
+
+def test_validate_mlflow_config_error(base_cfg: DictConfig, mocker):
+    """Test ConfigValidationError from validate_mlflow_config (lines 101-103)."""
+    # Make validate_mlflow_config raise ConfigValidationError
+    mock_validate = mocker.patch("simplexity.structured_configs.mlflow_defaults.validate_mlflow_config")
+    mock_validate.side_effect = ConfigValidationError("Invalid config")
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run: config"],
+        },
+    )
+    # Should raise ValueError because validation failed and not optional
+    with pytest.raises(ValueError, match="Target config not found for entry"):
+        load_mlflow_defaults(cfg)
+
+
+def test_validate_mlflow_config_error_optional(base_cfg: DictConfig, mocker):
+    """Test ConfigValidationError with optional flag."""
+    # Make validate_mlflow_config raise ConfigValidationError
+    mock_validate = mocker.patch("simplexity.structured_configs.mlflow_defaults.validate_mlflow_config")
+    mock_validate.side_effect = ConfigValidationError("Invalid config")
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["optional previous_run: config"],
+        },
+    )
+    # Should not raise, just return accumulator
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "other_section") == cfg.other_section
+
+
+def test_resolve_mlflow_config_error(base_cfg: DictConfig, mocker):
+    """Test ValueError from resolve_mlflow_config (lines 107-109)."""
+    # Make resolve_mlflow_config raise ValueError
+    mock_resolve = mocker.patch("simplexity.structured_configs.mlflow_defaults.resolve_mlflow_config")
+    mock_resolve.side_effect = ValueError("Resolution failed")
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run: config"],
+        },
+    )
+    # Should raise ValueError because resolution failed and not optional
+    with pytest.raises(ValueError, match="Target config not found for entry"):
+        load_mlflow_defaults(cfg)
+
+
+def test_resolve_mlflow_config_error_optional(base_cfg: DictConfig, mocker):
+    """Test ValueError from resolve_mlflow_config with optional flag."""
+    # Make resolve_mlflow_config raise ValueError
+    mock_resolve = mocker.patch("simplexity.structured_configs.mlflow_defaults.resolve_mlflow_config")
+    mock_resolve.side_effect = ValueError("Resolution failed")
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["optional mlflow: config"],
+        },
+    )
+    # Should not raise, just return accumulator
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "other_section") == cfg.other_section
+
+
+def test_omegaconf_load_error(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test Exception from OmegaConf.load (lines 124-126)."""
+    # Create a file with invalid YAML content
+    artifact_path = tmp_path / "invalid.yaml"
+    artifact_path.write_text("invalid: yaml: content: [unclosed")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["mlflow: config"],
+        },
+    )
+    # Should raise ValueError because load failed and not optional
+    with pytest.raises(ValueError, match="Target config not found for entry"):
+        load_mlflow_defaults(cfg)
+
+
+def test_omegaconf_load_error_optional(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test Exception from OmegaConf.load with optional flag."""
+    # Create a file with invalid YAML content
+    artifact_path = tmp_path / "invalid.yaml"
+    artifact_path.write_text("invalid: yaml: content: [unclosed")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["optional previous_run: config"],
+        },
+    )
+    # Should not raise, just return accumulator
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "other_section") == cfg.other_section
+
+
+def test_select_path_not_found(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test select path not found in artifact (lines 133-136)."""
+    artifact_path = tmp_path / "nondefault_config.yaml"
+    artifact_path.write_text("key: value\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run@dest: nondefault_config#nonexistent.path"],
+        },
+    )
+    # Should raise ValueError because select path not found and not optional
+    with pytest.raises(ValueError, match="Target config not found for entry"):
+        load_mlflow_defaults(cfg)
+
+
+def test_select_path_not_found_optional(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test select path not found with optional flag."""
+    artifact_path = tmp_path / "nondefault_config.yaml"
+    artifact_path.write_text("key: value\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["optional previous_run@dest: nondefault_config#nonexistent.path"],
+        },
+    )
+    # Should not raise, just return accumulator
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "other_section") == cfg.other_section
+
+
+def test_non_dictconfig_error(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test non-DictConfig error when not optional (lines 157-159)."""
+    # Create artifact with list (non-dict) root value
+    # Use "nondefault_config#" to avoid select_path, so we get the full ListConfig
+    artifact_path = tmp_path / "nondefault_config.yaml"
+    artifact_path.write_text("- item1\n- item2\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run: nondefault_config#"],
+        },
+    )
+    # Should raise ValueError because loaded_config is ListConfig (not DictConfig) and not optional
+    with pytest.raises(ValueError, match="Target config not found for entry"):
+        load_mlflow_defaults(cfg)
+
+
+def test_non_dictconfig_optional(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test non-DictConfig with optional flag."""
+    # Create artifact with list (non-dict) root value
+    # Use "nondefault_config#" to avoid select_path, so we get the full ListConfig
+    artifact_path = tmp_path / "nondefault_config.yaml"
+    artifact_path.write_text("- item1\n- item2\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["optional previous_run: nondefault_config#"],
+        },
+    )
+    # Should not raise, just return accumulator
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "other_section") == cfg.other_section
+
+
+def test_no_mlflow_defaults_key():
+    """Test early return when mlflow_defaults key is missing (line 172)."""
+    # Config without mlflow_defaults key
+    cfg = OmegaConf.create(
+        {
+            "previous_run": {
+                "tracking_uri": "databricks",
+                "run_id": "test_run_id",
+            },
+            "other_section": {"foo": "bar"},
+        }
+    )
+    # Should return cfg unchanged
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert loaded_cfg == cfg
+    assert OmegaConf.select(loaded_cfg, "other_section.foo") == "bar"
+
+
+def test_multiple_entries_different_runs(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test loading configs from multiple different runs."""
+    # Setup two different runs with different configs
+    artifact_path_1 = tmp_path / "config_run1.yaml"
+    run_1 = DictConfig({"run1_key": "run1_value", "run1_section": {"nested": "run1_nested"}})
+    artifact_path_1.write_text(OmegaConf.to_yaml(run_1))
+    artifact_path_2 = tmp_path / "config_run2.yaml"
+    run_2 = DictConfig({"run2_key": "run2_value", "run2_section": {"nested": "run2_nested"}})
+    artifact_path_2.write_text(OmegaConf.to_yaml(run_2))
+
+    # Mock download_artifacts to return different paths for different run_ids
+    def download_side_effect(run_id=None, _path=None, _dst_path=None, **_kwargs):
+        if run_id == "test_run_id_1":
+            return str(artifact_path_1)
+        if run_id == "test_run_id_2":
+            return str(artifact_path_2)
+        return ""
+
+    mock_download.side_effect = download_side_effect
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "run1": {
+                "tracking_uri": "databricks",
+                "run_id": "test_run_id_1",
+            },
+            "run2": {
+                "tracking_uri": "databricks",
+                "run_id": "test_run_id_2",
+            },
+            "mlflow_defaults": ["run1@model1", "run2@model2"],
+        },
+    )
+
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "model1") == run_1
+    assert OmegaConf.select(loaded_cfg, "model2") == run_2
+    assert OmegaConf.select(loaded_cfg, "other_section.foo") == "bar"
+
+
+def test_multiple_entries_same_run(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test loading multiple artifacts from the same run."""
+    # Setup multiple artifacts from the same run
+    artifact_path_1 = tmp_path / "config.yaml"
+    artifact_path_1.write_text("artifact1_key: artifact1_value\n")
+    artifact_path_2 = tmp_path / "other_artifact.yaml"
+    artifact_path_2.write_text("artifact2_key: artifact2_value\n")
+
+    # Mock download_artifacts to return different paths based on artifact path
+    def download_side_effect(_run_id=None, path=None, _dst_path=None, **_kwargs):
+        # Path might be "config" or "config.yaml" depending on parsing
+        if path in ("config", "config.yaml"):
+            return str(artifact_path_1)
+        if path in ("other_artifact", "other_artifact.yaml"):
+            return str(artifact_path_2)
+        return ""
+
+    mock_download.side_effect = download_side_effect
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": [
+                "previous_run@section1: config#",
+                "previous_run@section2: other_artifact#",
+            ],
+        },
+    )
+
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "section1.artifact1_key") == "artifact1_value"
+    assert OmegaConf.select(loaded_cfg, "section2.artifact2_key") == "artifact2_value"
+    assert OmegaConf.select(loaded_cfg, "other_section.foo") == "bar"
+
+
+def test_multiple_entries_shared_keys_last_wins(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test that last entry wins when keys conflict."""
+    # Setup entries that load configs with overlapping keys
+    artifact_path_1 = tmp_path / "config1.yaml"
+    artifact_path_1.write_text("shared_key: first_value\nunique1: value1\n")
+    artifact_path_2 = tmp_path / "config2.yaml"
+    artifact_path_2.write_text("shared_key: second_value\nunique2: value2\n")
+
+    def download_side_effect(_run_id=None, path=None, _dst_path=None, **_kwargs):
+        # Path might be "config1" or "config1.yaml" depending on parsing
+        if path in ("config1", "config1.yaml"):
+            return str(artifact_path_1)
+        if path in ("config2", "config2.yaml"):
+            return str(artifact_path_2)
+        return ""
+
+    mock_download.side_effect = download_side_effect
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "run1": {
+                "tracking_uri": "databricks",
+                "run_id": "test_run_id_1",
+            },
+            "run2": {
+                "tracking_uri": "databricks",
+                "run_id": "test_run_id_2",
+            },
+            "mlflow_defaults": [
+                "run1: config1#",
+                "run2: config2#",
+            ],
+        },
+    )
+
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    # Last entry should win for shared_key
+    assert OmegaConf.select(loaded_cfg, "shared_key") == "second_value"
+    # Both unique keys should be present
+    assert OmegaConf.select(loaded_cfg, "unique1") == "value1"
+    assert OmegaConf.select(loaded_cfg, "unique2") == "value2"
+    assert OmegaConf.select(loaded_cfg, "other_section.foo") == "bar"
+
+
+def test_option_trailing_hash(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test option with trailing # (artifact path only)."""
+    # Test: "custom#" should load artifact "custom" at root
+    artifact_path = tmp_path / "custom.yaml"
+    artifact_path.write_text("key: value\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run: custom#"],
+        },
+    )
+
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    assert OmegaConf.select(loaded_cfg, "key") == "value"
+    assert mock_download.call_args.kwargs["path"] == "custom.yaml"
+
+
+def test_option_hash_empty_select(base_cfg: DictConfig, mock_download: MagicMock, tmp_path: Path):
+    """Test option with # but empty select path."""
+    # Test: "artifact#" should load artifact "artifact" at root
+    artifact_path = tmp_path / "artifact.yaml"
+    artifact_path.write_text("root_key: root_value\nnested:\n  nested_key: nested_value\n")
+    mock_download.return_value = str(artifact_path)
+
+    cfg = OmegaConf.merge(
+        base_cfg,
+        {
+            "mlflow_defaults": ["previous_run: artifact#"],
+        },
+    )
+
+    loaded_cfg: DictConfig = load_mlflow_defaults(cfg)
+    # Should load entire artifact at root
+    assert OmegaConf.select(loaded_cfg, "root_key") == "root_value"
+    assert OmegaConf.select(loaded_cfg, "nested.nested_key") == "nested_value"
+    assert mock_download.call_args.kwargs["path"] == "artifact.yaml"