diff --git a/studio/backend/core/inference/local_model_resolver.py b/studio/backend/core/inference/local_model_resolver.py
index 86ad8b9fd8..64ab38ec75 100644
--- a/studio/backend/core/inference/local_model_resolver.py
+++ b/studio/backend/core/inference/local_model_resolver.py
@@ -201,7 +201,11 @@ def _build_index() -> dict[str, _LocalGgufEntry]:
             continue
         # Skip what Unsloth hides from its pickers (validation probe, RAG embed
         # weights): not chat models, so never an auto-switch target.
-        if _is_hidden_model(raw_id, getattr(info, "path", None)):
+        if _is_hidden_model(
+            raw_id,
+            getattr(info, "model_id", None),
+            getattr(info, "path", None),
+        ):
             continue
         # Advertise a client-facing alias, not an absolute filesystem path.
         loader_id = _advertised_loader_id(info)
diff --git a/studio/backend/core/rag/config.py b/studio/backend/core/rag/config.py
index 2de32a68e4..f54d795731 100644
--- a/studio/backend/core/rag/config.py
+++ b/studio/backend/core/rag/config.py
@@ -87,6 +87,22 @@ def _names_gguf(model: str) -> bool:
     return "gguf" in re.split(r"[^a-z0-9]+", model.lower())
 
 
+def gguf_repo_for_embedding_model(model: str) -> str:
+    """GGUF repo for ``model``, honoring an explicit companion override."""
+    if "RAG_EMBED_GGUF_REPO" in os.environ:
+        return EMBED_GGUF_REPO
+    if model == DEFAULT_EMBEDDING_MODEL:
+        return EMBED_GGUF_REPO
+    if _names_gguf(model):
+        return model
+    return f"{model}-GGUF"
+
+
+def default_gguf_repo() -> str:
+    """GGUF companion for the env/default embedding model."""
+    return gguf_repo_for_embedding_model(EMBEDDING_MODEL)
+
+
 def effective_gguf_repo() -> str:
     """GGUF repo for the llama-server backend, tracking the effective model.
 
@@ -95,14 +111,7 @@ def effective_gguf_repo() -> str:
     ``-GGUF`` companion repo (the unsloth convention the default pair follows),
     or is used as-is when it already names a GGUF repo.
     """
-    if "RAG_EMBED_GGUF_REPO" in os.environ:
-        return EMBED_GGUF_REPO
-    model = effective_embedding_model()
-    if model == DEFAULT_EMBEDDING_MODEL:
-        return EMBED_GGUF_REPO
-    if _names_gguf(model):
-        return model
-    return f"{model}-GGUF"
+    return gguf_repo_for_embedding_model(effective_embedding_model())
 
 
 # llama-server backend only. F16 over Q8_0: faster (no per-block dequant for this
diff --git a/studio/backend/hub/services/models/cache_inventory.py b/studio/backend/hub/services/models/cache_inventory.py
index 1f38af9381..54a25482f2 100644
--- a/studio/backend/hub/services/models/cache_inventory.py
+++ b/studio/backend/hub/services/models/cache_inventory.py
@@ -37,6 +37,13 @@ from hub.services.models.common import (
     _runtime_for_format,
 )
 
+# Imported at module scope (not inside the per-repo scan loop) so a broken
+# import surfaces at startup instead of silently emptying the inventory: the
+# scan loop swallows per-repo exceptions and would drop every repo. Lives under
+# ``utils`` (not ``utils.models``) to avoid the eager model-config/checkpoint
+# imports in ``utils/models/__init__.py``.
+from utils.hidden_models import is_hidden_model
+
 logger = get_logger(__name__)
 
 _repo_size_cache: "OrderedDict[tuple[str, str, str], tuple[int, frozenset[str], float]]" = (
@@ -243,6 +250,13 @@ def invalidate_hf_cache_scans() -> None:
     hf_cache_scan.invalidate_hf_cache_scans()
 
 
+def _is_hidden_infra_repo(*values: str | None) -> bool:
+    """True for infra-only repos (the RAG embedder and the llama.cpp install
+    validation probe) that are cached as a side effect of Studio itself and are
+    not usable chat models."""
+    return is_hidden_model(*values)
+
+
 def _scan_cached_gguf() -> list[dict]:
     """Synchronous HF-cache disk walk for GGUF repos; runs in a worker thread."""
     cache_scans = all_hf_cache_scans()
@@ -254,13 +268,24 @@ def _scan_cached_gguf() -> list[dict]:
                 if str(repo_info.repo_type) != "model":
                     continue
                 repo_id = repo_info.repo_id
+                repo_path = Path(repo_info.repo_path)
+                snapshot_path = _cached_model_snapshot_path(repo_path)
                 total_size = _repo_gguf_size_bytes(repo_info)
                 has_variant_state, variant_state_size = _gguf_variant_state_summary(repo_id)
+                is_hidden_infra = _is_hidden_infra_repo(
+                    repo_id,
+                    str(repo_path),
+                    str(snapshot_path) if snapshot_path is not None else None,
+                )
+                # Hide infra repos unless the user downloaded a variant via
+                # the Hub; variant state only exists for user downloads.
+                if is_hidden_infra and not has_variant_state:
+                    continue
                 if total_size == 0 and not has_variant_state:
                     continue
                 partial = hf_cache_scan.is_gguf_repo_partial(
                     repo_id,
-                    Path(repo_info.repo_path),
+                    repo_path,
                 )
                 if total_size == 0 and not partial:
                     continue
@@ -283,6 +308,9 @@ def _scan_cached_gguf() -> list[dict]:
                         requires_variant = True,
                     )
                 )
+                # Visible infra variants remain management-only.
+                if is_hidden_infra:
+                    row["capabilities"]["can_chat"] = False
                 if _prefer_cache_row(row, existing):
                     seen_lower[key] = row
             except Exception as e:
@@ -475,6 +503,15 @@ def _scan_cached_models() -> list[dict]:
                 if str(repo_info.repo_type) != "model":
                     continue
                 repo_id = repo_info.repo_id
+                repo_path = Path(repo_info.repo_path)
+                snapshot_path = _cached_model_snapshot_path(repo_path)
+                # The non-GGUF embedder has no variant downloads; always hide.
+                if _is_hidden_infra_repo(
+                    repo_id,
+                    str(repo_path),
+                    str(snapshot_path) if snapshot_path is not None else None,
+                ):
+                    continue
                 has_main_gguf = _repo_has_gguf_files(repo_info)
                 payload = _repo_non_gguf_model_payload(repo_info)
                 if payload.size_bytes == 0:
@@ -486,7 +523,6 @@ def _scan_cached_models() -> list[dict]:
                     continue
                 key = repo_id.lower()
                 existing = seen_lower.get(key)
-                repo_path = Path(repo_info.repo_path)
                 snapshot_partial = hf_cache_scan.is_snapshot_partial(
                     "model",
                     repo_id,
diff --git a/studio/backend/hub/services/models/local_inventory.py b/studio/backend/hub/services/models/local_inventory.py
index a3782efead..b34532fa35 100644
--- a/studio/backend/hub/services/models/local_inventory.py
+++ b/studio/backend/hub/services/models/local_inventory.py
@@ -36,6 +36,7 @@ from hub.utils.paths import (
 )
 from hub.services.models import common as model_common
 from hub.services.models.ollama import scan_ollama_dir
+from utils.hidden_models import is_hidden_model
 
 logger = get_logger(__name__)
 _MAX_MODELS_PER_CUSTOM_FOLDER = 200
@@ -623,6 +624,20 @@ def _dedupe_local_models(local_models: List[LocalModelInfo]) -> list[LocalModelI
     )
 
 
+def _filter_hidden_models(local_models: List[LocalModelInfo]) -> list[LocalModelInfo]:
+    """Remove infrastructure-only models from the shared local inventory."""
+    visible: list[LocalModelInfo] = []
+    for model in local_models:
+        resolved_cache_path = (
+            hf_cache_scan.resolve_hf_cache_realpath(Path(model.path))
+            if model.source == "hf_cache"
+            else None
+        )
+        if not is_hidden_model(model.id, model.model_id, model.path, resolved_cache_path):
+            visible.append(model)
+    return visible
+
+
 async def list_local_models_response(models_dir: str = "./models") -> LocalModelListResponse:
     """List local model candidates from every supported on-device source."""
     hf_cache_dir = _resolve_hf_cache_dir()
@@ -653,7 +668,7 @@ async def list_local_models_response(models_dir: str = "./models") -> LocalModel
             ollama_dirs,
         )
         local_models += await _collect_models_from_custom_folders()
-        models = _dedupe_local_models(local_models)
+        models = _dedupe_local_models(_filter_hidden_models(local_models))
 
         return LocalModelListResponse(
             models_dir = str(models_root),
diff --git a/studio/backend/hub/tests/test_model_services.py b/studio/backend/hub/tests/test_model_services.py
index 2c33e09b2b..693d945ee1 100644
--- a/studio/backend/hub/tests/test_model_services.py
+++ b/studio/backend/hub/tests/test_model_services.py
@@ -439,6 +439,287 @@ def test_cached_gguf_scan_includes_variant_state_without_completed_gguf(monkeypa
     assert row["capabilities"]["requires_variant"] is True
 
 
+def test_cached_gguf_scan_hides_infra_repos_without_user_downloads(monkeypatch, tmp_path):
+    probe = _repo(
+        "ggml-org/models",
+        [_file("tinyllamas/stories260K.gguf", 1_200_000)],
+        tmp_path / "probe",
+    )
+    embedder = _repo(
+        "unsloth/bge-small-en-v1.5-GGUF",
+        [_file("bge-small-en-v1.5-f16.gguf", 60_000_000)],
+        tmp_path / "embedder",
+    )
+    chat = _repo("Org/Chat-GGUF", [_file("Q4_K_M.gguf", 100)], tmp_path / "chat")
+    monkeypatch.setattr(
+        cache_inventory,
+        "all_hf_cache_scans",
+        lambda: [SimpleNamespace(repos = [probe, embedder, chat])],
+    )
+    monkeypatch.setattr(
+        cache_inventory.hf_cache_scan,
+        "is_gguf_repo_partial",
+        lambda _repo_id, _path: False,
+    )
+
+    result = {"cached": cache_inventory._scan_cached_gguf()}
+
+    assert [row["repo_id"] for row in result["cached"]] == ["Org/Chat-GGUF"]
+
+
+def test_cached_gguf_scan_keeps_infra_repo_with_user_downloaded_variant(monkeypatch, tmp_path):
+    monkeypatch.setattr(state_dir, "cache_root", lambda: tmp_path / "state")
+    embedder = _repo(
+        "unsloth/bge-small-en-v1.5-GGUF",
+        [
+            _file("bge-small-en-v1.5-f16.gguf", 60_000_000),
+            _file("bge-small-en-v1.5-Q8_0.gguf", 35_000_000),
+        ],
+        tmp_path / "embedder",
+    )
+    # Variant manifests only exist for user Hub downloads, not auto-downloads.
+    assert download_manifest.write_manifest(
+        "model",
+        "unsloth/bge-small-en-v1.5-GGUF",
+        "Q8_0",
+        [download_manifest.ExpectedFile(path = "bge-small-en-v1.5-Q8_0.gguf", size = 35_000_000)],
+        "http",
+    )
+    monkeypatch.setattr(
+        cache_inventory,
+        "all_hf_cache_scans",
+        lambda: [SimpleNamespace(repos = [embedder])],
+    )
+    monkeypatch.setattr(
+        cache_inventory.hf_cache_scan,
+        "is_gguf_repo_partial",
+        lambda _repo_id, _path: False,
+    )
+
+    result = {"cached": cache_inventory._scan_cached_gguf()}
+
+    assert [row["repo_id"] for row in result["cached"]] == ["unsloth/bge-small-en-v1.5-GGUF"]
+    assert result["cached"][0]["capabilities"]["can_chat"] is False
+
+
+def test_cached_models_scan_hides_non_gguf_embedder(monkeypatch, tmp_path):
+    embedder_path = tmp_path / "hub" / "models--unsloth--bge-small-en-v1.5"
+    embedder_path.mkdir(parents = True)
+    embedder = _repo(
+        "unsloth/bge-small-en-v1.5",
+        [_file("config.json", 12), _file("model.safetensors", 130_000_000)],
+        embedder_path,
+    )
+    chat_path = tmp_path / "hub" / "models--Org--Chat"
+    chat_path.mkdir(parents = True)
+    chat = _repo(
+        "Org/Chat",
+        [_file("config.json", 12), _file("model.safetensors", 100)],
+        chat_path,
+    )
+    monkeypatch.setattr(
+        cache_inventory,
+        "all_hf_cache_scans",
+        lambda: [SimpleNamespace(repos = [embedder, chat])],
+    )
+    monkeypatch.setattr(
+        cache_inventory.hf_cache_scan,
+        "is_snapshot_partial",
+        lambda _kind, _repo_id, _path: False,
+    )
+
+    result = {"cached": cache_inventory._scan_cached_models()}
+
+    assert [row["repo_id"] for row in result["cached"]] == ["Org/Chat"]
+
+
+def test_cached_scans_hide_embedders_configured_by_cache_path(monkeypatch, tmp_path):
+    from core.rag import config as rag_config
+
+    gguf_path = tmp_path / "hub" / "models--Org--PathEmbedder-GGUF"
+    gguf_path.mkdir(parents = True)
+    gguf = _repo(
+        "Org/PathEmbedder-GGUF",
+        [_file("model-F16.gguf", 60_000_000)],
+        gguf_path,
+    )
+    model_path = tmp_path / "hub" / "models--Org--PathEmbedder"
+    model_path.mkdir(parents = True)
+    model = _repo(
+        "Org/PathEmbedder",
+        [_file("config.json", 12), _file("model.safetensors", 130_000_000)],
+        model_path,
+    )
+    monkeypatch.setattr(
+        rag_config,
+        "effective_embedding_model",
+        lambda: str(model_path),
+    )
+    monkeypatch.setattr(
+        rag_config,
+        "effective_gguf_repo",
+        lambda: str(gguf_path),
+    )
+    monkeypatch.setattr(
+        cache_inventory,
+        "all_hf_cache_scans",
+        lambda: [SimpleNamespace(repos = [gguf, model])],
+    )
+    monkeypatch.setattr(
+        cache_inventory.hf_cache_scan,
+        "is_gguf_repo_partial",
+        lambda _repo_id, _path: False,
+    )
+    monkeypatch.setattr(
+        cache_inventory.hf_cache_scan,
+        "is_snapshot_partial",
+        lambda _kind, _repo_id, _path: False,
+    )
+
+    assert cache_inventory._scan_cached_gguf() == []
+    assert cache_inventory._scan_cached_models() == []
+
+
+def test_cached_scans_hide_embedders_configured_by_snapshot_path(monkeypatch, tmp_path):
+    from core.rag import config as rag_config
+
+    gguf_path = tmp_path / "hub" / "models--Org--SnapshotEmbedder-GGUF"
+    gguf_snapshot = gguf_path / "snapshots" / "gguf-revision"
+    gguf_snapshot.mkdir(parents = True)
+    gguf = _repo(
+        "Org/SnapshotEmbedder-GGUF",
+        [_file("model-F16.gguf", 60_000_000)],
+        gguf_path,
+    )
+    model_path = tmp_path / "hub" / "models--Org--SnapshotEmbedder"
+    model_snapshot = model_path / "snapshots" / "model-revision"
+    model_snapshot.mkdir(parents = True)
+    model = _repo(
+        "Org/SnapshotEmbedder",
+        [_file("config.json", 12), _file("model.safetensors", 130_000_000)],
+        model_path,
+    )
+    monkeypatch.setattr(
+        rag_config,
+        "effective_embedding_model",
+        lambda: str(model_snapshot),
+    )
+    monkeypatch.setattr(
+        rag_config,
+        "effective_gguf_repo",
+        lambda: str(gguf_snapshot),
+    )
+    monkeypatch.setattr(
+        cache_inventory,
+        "all_hf_cache_scans",
+        lambda: [SimpleNamespace(repos = [gguf, model])],
+    )
+
+    def _resolve_snapshot(repo_path):
+        return str(
+            {
+                gguf_path: gguf_snapshot,
+                model_path: model_snapshot,
+            }.get(Path(repo_path), Path(repo_path))
+        )
+
+    monkeypatch.setattr(
+        cache_inventory.hf_cache_scan,
+        "resolve_hf_cache_realpath",
+        _resolve_snapshot,
+    )
+    monkeypatch.setattr(
+        cache_inventory.hf_cache_scan,
+        "is_gguf_repo_partial",
+        lambda _repo_id, _path: False,
+    )
+    monkeypatch.setattr(
+        cache_inventory.hf_cache_scan,
+        "is_snapshot_partial",
+        lambda _kind, _repo_id, _path: False,
+    )
+
+    assert cache_inventory._scan_cached_gguf() == []
+    assert cache_inventory._scan_cached_models() == []
+
+
+def test_cached_models_scan_keeps_unrelated_repo_with_custom_generic_embedder(
+    monkeypatch, tmp_path
+):
+    # A custom embedder with a generic basename ("org/model") must be hidden by
+    # EXACT repo-id match only. An unrelated cached chat model whose id merely
+    # contains "model" (e.g. "user/model-chat") must stay on device: substring
+    # basename matching used to drop real chat models from the inventory.
+    from core.rag import config as rag_config
+
+    monkeypatch.setattr(rag_config, "effective_embedding_model", lambda: "org/model")
+    monkeypatch.setattr(rag_config, "effective_gguf_repo", lambda: "org/model-GGUF")
+
+    def _model_repo(repo_id: str):
+        path = tmp_path / "hub" / f"models--{repo_id.replace('/', '--')}"
+        path.mkdir(parents = True)
+        return _repo(
+            repo_id,
+            [_file("config.json", 12), _file("model.safetensors", 100)],
+            path,
+        )
+
+    embedder = _model_repo("org/model")
+    chat = _model_repo("user/model-chat")
+    monkeypatch.setattr(
+        cache_inventory,
+        "all_hf_cache_scans",
+        lambda: [SimpleNamespace(repos = [embedder, chat])],
+    )
+    monkeypatch.setattr(
+        cache_inventory.hf_cache_scan,
+        "is_snapshot_partial",
+        lambda _kind, _repo_id, _path: False,
+    )
+
+    result = {"cached": cache_inventory._scan_cached_models()}
+
+    assert [row["repo_id"] for row in result["cached"]] == ["user/model-chat"]
+
+
+def test_cached_scans_hide_stale_default_embedder_after_custom_setting(monkeypatch, tmp_path):
+    from core.rag import config as rag_config
+
+    monkeypatch.setattr(rag_config, "effective_embedding_model", lambda: "org/custom")
+    monkeypatch.setattr(rag_config, "effective_gguf_repo", lambda: "org/custom-GGUF")
+
+    gguf = _repo(
+        "unsloth/bge-small-en-v1.5-GGUF",
+        [_file("bge-small-en-v1.5-f16.gguf", 60_000_000)],
+        tmp_path / "default-gguf",
+    )
+    weights_path = tmp_path / "hub" / "models--unsloth--bge-small-en-v1.5"
+    weights_path.mkdir(parents = True)
+    weights = _repo(
+        "unsloth/bge-small-en-v1.5",
+        [_file("config.json", 12), _file("model.safetensors", 130_000_000)],
+        weights_path,
+    )
+    monkeypatch.setattr(
+        cache_inventory,
+        "all_hf_cache_scans",
+        lambda: [SimpleNamespace(repos = [gguf, weights])],
+    )
+    monkeypatch.setattr(
+        cache_inventory.hf_cache_scan,
+        "is_gguf_repo_partial",
+        lambda _repo_id, _path: False,
+    )
+    monkeypatch.setattr(
+        cache_inventory.hf_cache_scan,
+        "is_snapshot_partial",
+        lambda _kind, _repo_id, _path: False,
+    )
+
+    assert cache_inventory._scan_cached_gguf() == []
+    assert cache_inventory._scan_cached_models() == []
+
+
 def test_gguf_variant_requirements_include_split_files_and_preferred_mmproj():
     requirements = gguf_variants._build_gguf_variant_requirements(
         [
@@ -1610,6 +1891,63 @@ def test_hf_cache_scan_uses_gguf_partial_row_for_variant_state(monkeypatch, tmp_
     assert rows[0].capabilities.requires_variant is True
 
 
+def test_local_inventory_filters_custom_embedder_hf_cache_row(monkeypatch, tmp_path):
+    from core.rag import config as rag_config
+
+    monkeypatch.setattr(rag_config, "effective_embedding_model", lambda: "org/embedder")
+    monkeypatch.setattr(rag_config, "effective_gguf_repo", lambda: "org/embedder-GGUF")
+
+    def _row(repo_id: str):
+        repo_path = tmp_path / f"models--{repo_id.replace('/', '--')}"
+        return model_common._local_model_info(
+            scan_path = repo_path,
+            load_path = repo_path,
+            source = "hf_cache",
+            model_format = "safetensors",
+            model_id = repo_id,
+        )
+
+    rows = local_inventory._filter_hidden_models([_row("org/embedder"), _row("org/chat-model")])
+
+    assert [row.model_id for row in rows] == ["org/chat-model"]
+
+
+def test_local_inventory_filters_embedder_configured_by_snapshot_path(monkeypatch, tmp_path):
+    from core.rag import config as rag_config
+
+    embedder_path = tmp_path / "hub" / "models--org--embedder"
+    embedder_snapshot = embedder_path / "snapshots" / "revision"
+    embedder_snapshot.mkdir(parents = True)
+    chat_path = tmp_path / "hub" / "models--org--chat-model"
+    chat_path.mkdir(parents = True)
+    monkeypatch.setattr(
+        rag_config,
+        "effective_embedding_model",
+        lambda: str(embedder_snapshot),
+    )
+    monkeypatch.setattr(rag_config, "effective_gguf_repo", lambda: "org/embedder-GGUF")
+    monkeypatch.setattr(
+        local_inventory.hf_cache_scan,
+        "resolve_hf_cache_realpath",
+        lambda path: str(embedder_snapshot) if Path(path) == embedder_path else str(path),
+    )
+
+    def _row(repo_id: str, repo_path: Path):
+        return model_common._local_model_info(
+            scan_path = repo_path,
+            load_path = repo_path,
+            source = "hf_cache",
+            model_format = "safetensors",
+            model_id = repo_id,
+        )
+
+    rows = local_inventory._filter_hidden_models(
+        [_row("org/embedder", embedder_path), _row("org/chat-model", chat_path)]
+    )
+
+    assert [row.model_id for row in rows] == ["org/chat-model"]
+
+
 def test_model_download_job_helpers_preserve_idle_shape():
     key = downloads._download_job_key("Org/Model", None)
     status = downloads._job_status(key)
diff --git a/studio/backend/routes/models.py b/studio/backend/routes/models.py
index 742ecde3ba..bb321695cd 100644
--- a/studio/backend/routes/models.py
+++ b/studio/backend/routes/models.py
@@ -59,59 +59,12 @@ def _safe_is_dir(path) -> bool:
         return False
 
 
-# Hub repo id shape ("owner/name", no leading separator); anything else is
-# treated as a local filesystem path.
-_HF_REPO_ID_RE = re.compile(r"^[A-Za-z0-9][\w.\-]*/[\w.\-]+$")
-
-
-def _is_hidden_model(*values: str | None) -> bool:
-    """True if any id/path is the RAG embedding model (EMBEDDING_MODEL or
-    EMBED_GGUF_REPO basename) or the llama.cpp install validation probe
-    (ggml-org/models / stories260K), so pickers hide them (GGUF and non-GGUF).
-    None are usable chat models; the probe can be cached as a side effect of
-    installing the prebuilt llama-server and otherwise sorts smallest, so it
-    would be auto-selected. A local-path embedder is matched by exact resolved
-    path only: a generic basename like "model" must not substring-hide
-    unrelated chat models."""
-    from core.rag import config as rag_config
-
-    needles = [
-        # The validation probe's repo (matches the cached repo id) and its exact
-        # filename (matches the on-disk path). The filename carries the .gguf so
-        # it does not hide unrelated repos like ``user/stories260K-finetune-GGUF``.
-        "ggml-org/models",
-        "stories260k.gguf",
-    ]
-    exact_paths: list[str] = []
-    for model in (
-        rag_config.effective_embedding_model(),
-        rag_config.effective_gguf_repo(),
-    ):
-        if _HF_REPO_ID_RE.match(model):
-            needles.append(model.split("/")[-1].lower())
-        else:
-            resolved = _safe_resolve(Path(model).expanduser())
-            if resolved:
-                exact_paths.append(resolved.lower())
-    for v in values:
-        if not v:
-            continue
-        low = v.lower()
-        if any(n in low for n in needles):
-            return True
-        if exact_paths:
-            resolved = _safe_resolve(Path(v).expanduser())
-            if resolved and resolved.lower() in exact_paths:
-                return True
-    return False
-
-
-def _safe_resolve(path: Path) -> Optional[str]:
-    """resolve() to a string, or None when the path is inaccessible."""
-    try:
-        return str(path.resolve())
-    except OSError:
-        return None
+# Shared with the hub inventory scans; keep the private aliases so existing
+# importers (core.inference.local_model_resolver, tests) stay valid.
+from utils.hidden_models import (
+    _safe_resolve,
+    is_hidden_model as _is_hidden_model,
+)
 
 
 backend_path = Path(__file__).parent.parent.parent
@@ -853,7 +806,7 @@ def collect_local_models(models_root: Path) -> List[LocalModelInfo]:
         key = lambda item: (item.updated_at or 0),
         reverse = True,
     )
-    return [m for m in models if not _is_hidden_model(m.id, m.path)]
+    return [m for m in models if not _is_hidden_model(m.id, m.model_id, m.path)]
 
 
 @router.get("/local", response_model = LocalModelListResponse)
diff --git a/studio/backend/routes/settings.py b/studio/backend/routes/settings.py
index 1ddfc0eacb..ab0fd2fd99 100644
--- a/studio/backend/routes/settings.py
+++ b/studio/backend/routes/settings.py
@@ -10,6 +10,7 @@ from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from auth.authentication import get_current_subject
 from auth.storage import rotate_preview_link_secret
+from core.rag.config import default_gguf_repo, effective_gguf_repo
 from loggers import get_logger
 from utils.utils import safe_error_detail, log_and_http_error
 from utils.personalization_settings import (
@@ -263,14 +264,18 @@ class EmbeddingModelPayload(BaseModel):
 
 class EmbeddingModelResponse(BaseModel):
     embedding_model: str
+    embedding_gguf_repo: str
     default_embedding_model: str
+    default_embedding_gguf_repo: str
     is_custom: bool
 
 
 def _embedding_model_response() -> EmbeddingModelResponse:
     return EmbeddingModelResponse(
         embedding_model = get_rag_embedding_model(),
+        embedding_gguf_repo = effective_gguf_repo(),
         default_embedding_model = default_embedding_model(),
+        default_embedding_gguf_repo = default_gguf_repo(),
         is_custom = get_stored_embedding_model() is not None,
     )
 
diff --git a/studio/backend/tests/test_cached_gguf_routes.py b/studio/backend/tests/test_cached_gguf_routes.py
index d4a7cae208..b3e6255d55 100644
--- a/studio/backend/tests/test_cached_gguf_routes.py
+++ b/studio/backend/tests/test_cached_gguf_routes.py
@@ -120,12 +120,151 @@ def test_is_hidden_model_hides_validation_probe_everywhere():
     assert models_route._is_hidden_model(
         None, "/hf/models--ggml-org--models/snapshots/abc/tinyllamas/stories260K.gguf"
     )
+    # A Windows-style snapshot path must match too, even on a POSIX interpreter
+    # (the filename check splits on both separators).
+    assert models_route._is_hidden_model(
+        r"C:\Users\u\.cache\huggingface\hub\models--ggml-org--models\snapshots\abc\tinyllamas\stories260K.gguf"
+    )
     assert not models_route._is_hidden_model("unsloth/gemma-3-270m-it-GGUF")
     # The exact-filename needle must not hide a real repo that merely
     # references stories260K in its name.
     assert not models_route._is_hidden_model("user/stories260K-finetune-GGUF")
 
 
+def test_is_hidden_model_matches_repo_ids_exactly(monkeypatch):
+    """A custom embedder with a generic basename is hidden by EXACT repo-id
+    match only, so unrelated cached repos that merely contain the basename stay
+    visible. Regression: substring basename matching hid real chat models like
+    ``user/model-chat`` from the On Device inventory."""
+    from core.rag import config as rag_config
+
+    monkeypatch.setattr(rag_config, "effective_embedding_model", lambda: "org/model")
+    monkeypatch.setattr(rag_config, "effective_gguf_repo", lambda: "org/model-GGUF")
+
+    # The exact embedder repo and its GGUF companion are hidden.
+    assert models_route._is_hidden_model("org/model")
+    assert models_route._is_hidden_model("org/model-GGUF")
+    # Unrelated repos that merely contain "model" must NOT be hidden.
+    assert not models_route._is_hidden_model("user/model-chat")
+    assert not models_route._is_hidden_model("org/model-instruct")
+    assert not models_route._is_hidden_model("acme/remodelled-chat")
+    # The validation probe stays hidden regardless of embedder config.
+    assert models_route._is_hidden_model("ggml-org/models")
+
+
+def test_is_hidden_model_matches_repo_derived_local_paths(monkeypatch):
+    """Match exact repo-derived cache and LM Studio paths."""
+    from core.rag import config as rag_config
+
+    monkeypatch.setattr(rag_config, "effective_embedding_model", lambda: "org/model")
+    monkeypatch.setattr(rag_config, "effective_gguf_repo", lambda: "org/model-GGUF")
+
+    assert models_route._is_hidden_model(
+        "/cache/models--org--model/snapshots/abc/model.safetensors"
+    )
+    assert models_route._is_hidden_model(
+        r"C:\Users\u\.cache\huggingface\hub\models--org--model-GGUF\snapshots\abc"
+    )
+    assert models_route._is_hidden_model("/lm-studio/org/model-GGUF/model-Q8_0.gguf")
+    assert not models_route._is_hidden_model("/lm-studio/user/model-chat/model-Q8_0.gguf")
+    assert not models_route._is_hidden_model("/cache/models--org--model-instruct")
+
+
+def test_is_hidden_model_prefers_existing_relative_path(monkeypatch, tmp_path):
+    """Prefer an existing relative path over repo-id syntax."""
+    from core.rag import config as rag_config
+
+    embedder = tmp_path / "models" / "embedder"
+    embedder.mkdir(parents = True)
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(rag_config, "effective_embedding_model", lambda: "models/embedder")
+    monkeypatch.setattr(rag_config, "effective_gguf_repo", lambda: "org/embedder-GGUF")
+
+    assert models_route._is_hidden_model(str(embedder))
+
+
+def test_is_hidden_model_keeps_stale_default_embedder_hidden(monkeypatch):
+    """Keep default embedders hidden after a settings change."""
+    from core.rag import config as rag_config
+
+    monkeypatch.setattr(rag_config, "effective_embedding_model", lambda: "org/custom")
+    monkeypatch.setattr(rag_config, "effective_gguf_repo", lambda: "org/custom-GGUF")
+
+    assert models_route._is_hidden_model("unsloth/bge-small-en-v1.5")
+    assert models_route._is_hidden_model("unsloth/bge-small-en-v1.5-GGUF")
+    assert models_route._is_hidden_model("/models/bge-small-en-v1.5")
+    assert models_route._is_hidden_model("/models/bge-small-en-v1.5-F16.gguf")
+    assert models_route._is_hidden_model(r"C:\models\bge-small-en-v1.5-Q8_0.gguf")
+    # Repo IDs still use exact matching, and similar local basenames must have
+    # a real separator after the static default name.
+    assert not models_route._is_hidden_model("user/bge-small-en-v1.5-chat")
+    assert not models_route._is_hidden_model("/models/bge-small-en-v1.50")
+
+
+def test_is_hidden_model_keeps_env_default_hidden_after_override(monkeypatch):
+    """A persisted override must not expose the deployment's env default."""
+    from core.rag import config as rag_config
+
+    monkeypatch.delenv("RAG_EMBED_GGUF_REPO", raising = False)
+    monkeypatch.setattr(rag_config, "EMBEDDING_MODEL", "org/env-default")
+    monkeypatch.setattr(rag_config, "effective_embedding_model", lambda: "org/custom")
+    monkeypatch.setattr(rag_config, "effective_gguf_repo", lambda: "org/custom-GGUF")
+
+    assert models_route._is_hidden_model("org/env-default")
+    assert models_route._is_hidden_model("org/env-default-GGUF")
+    assert models_route._is_hidden_model("org/custom")
+    assert models_route._is_hidden_model("org/custom-GGUF")
+    assert not models_route._is_hidden_model("org/env-default-chat")
+
+
+def test_hidden_models_importable_without_heavy_model_stack():
+    """The hub cache scanner imports ``is_hidden_model`` at module scope, so it
+    must not drag in ``utils/models/__init__`` (the model-config + checkpoint
+    stack). Verify in a clean interpreter that importing the helper touches
+    neither ``utils.models`` nor those heavy submodules, and still classifies
+    the probe."""
+    import os
+    import subprocess
+    import textwrap
+
+    backend = Path(__file__).resolve().parents[1]
+    code = textwrap.dedent(
+        """
+        import sys
+
+        class _Blocker:
+            _blocked = (
+                "utils.models",
+                "utils.models.model_config",
+                "utils.models.checkpoints",
+            )
+
+            def find_spec(self, name, path=None, target=None):
+                if name in self._blocked:
+                    raise ImportError("blocked heavy import: " + name)
+                return None
+
+        sys.meta_path.insert(0, _Blocker())
+        from utils.hidden_models import is_hidden_model
+
+        loaded = sorted(m for m in sys.modules if m.startswith("utils.models"))
+        assert not loaded, loaded
+        assert is_hidden_model("ggml-org/models") is True
+        assert is_hidden_model("unsloth/gemma-3-270m-it-GGUF") is False
+        print("HIDDEN_MODELS_IMPORT_OK")
+        """
+    )
+    env = dict(os.environ, PYTHONPATH = str(backend))
+    proc = subprocess.run(
+        [sys.executable, "-c", code],
+        capture_output = True,
+        text = True,
+        env = env,
+    )
+    assert proc.returncode == 0, proc.stderr
+    assert "HIDDEN_MODELS_IMPORT_OK" in proc.stdout
+
+
 def test_list_cached_gguf_hides_llama_validation_probe(monkeypatch, tmp_path):
     """The ggml-org/models / stories260K install validation probe can land in
     the HF cache as a side effect of installing the prebuilt llama-server.
diff --git a/studio/backend/tests/test_embedding_model_security_gate.py b/studio/backend/tests/test_embedding_model_security_gate.py
index 940b35d7ba..b3fa98b604 100644
--- a/studio/backend/tests/test_embedding_model_security_gate.py
+++ b/studio/backend/tests/test_embedding_model_security_gate.py
@@ -52,6 +52,16 @@ def client(monkeypatch):
     monkeypatch.setattr(settings, "_resolves_as_local_gguf", lambda m: False)
     monkeypatch.setattr(settings, "get_rag_embedding_model", lambda: saved.get("model", ""))
     monkeypatch.setattr(settings, "get_stored_embedding_model", lambda: saved.get("model"))
+    monkeypatch.setattr(
+        settings,
+        "effective_gguf_repo",
+        lambda: f"{saved.get('model', 'unsloth/default-embed')}-GGUF",
+    )
+    monkeypatch.setattr(
+        settings,
+        "default_gguf_repo",
+        lambda: "unsloth/default-embed-GGUF",
+    )
 
     app = FastAPI()
     app.include_router(settings.router)
@@ -257,6 +267,13 @@ def test_clean_repo_saves_under_force(client, monkeypatch):
     r = c.put("/embedding-model", json = {"embedding_model": "acme/clean-embed", "force": True})
     assert r.status_code == 200
     assert saved.get("model") == "acme/clean-embed"
+    assert r.json() == {
+        "embedding_model": "acme/clean-embed",
+        "embedding_gguf_repo": "acme/clean-embed-GGUF",
+        "default_embedding_model": "unsloth/default-embed",
+        "default_embedding_gguf_repo": "unsloth/default-embed-GGUF",
+        "is_custom": True,
+    }
 
 
 def test_load_sink_refuses_flagged_model(monkeypatch):
diff --git a/studio/backend/tests/test_embedding_model_settings.py b/studio/backend/tests/test_embedding_model_settings.py
index 3be4af0e32..bcf3ded71c 100644
--- a/studio/backend/tests/test_embedding_model_settings.py
+++ b/studio/backend/tests/test_embedding_model_settings.py
@@ -53,3 +53,10 @@ def test_custom_model_overrides_default_and_derives_gguf(settings_store, monkeyp
 
     assert ems.reset_rag_embedding_model() == rag_config.EMBEDDING_MODEL
     assert ems.get_stored_embedding_model() is None
+
+
+def test_env_default_derives_its_gguf_companion(monkeypatch):
+    monkeypatch.delenv("RAG_EMBED_GGUF_REPO", raising = False)
+    monkeypatch.setattr(rag_config, "EMBEDDING_MODEL", "org/env-default-embedder")
+
+    assert rag_config.default_gguf_repo() == "org/env-default-embedder-GGUF"
diff --git a/studio/backend/tests/test_openai_auto_switch.py b/studio/backend/tests/test_openai_auto_switch.py
index 90fbd19297..c4c0ce15c9 100644
--- a/studio/backend/tests/test_openai_auto_switch.py
+++ b/studio/backend/tests/test_openai_auto_switch.py
@@ -697,6 +697,10 @@ def test_index_excludes_hidden_models(tmp_path, monkeypatch):
     normal.write_bytes(b"x" * 32)
     probe = tmp_path / "stories260K.gguf"  # llama.cpp install-validation probe
     probe.write_bytes(b"x" * 32)
+    embedder = tmp_path / "embedding-Q8_0.gguf"
+    embedder.write_bytes(b"x" * 32)
+    local_default_embedder = tmp_path / "bge-small-en-v1.5-F16.gguf"
+    local_default_embedder.write_bytes(b"x" * 32)
 
     def _info(mid, path):
         return SimpleNamespace(id = mid, path = str(path), model_id = mid, display_name = mid)
@@ -704,7 +708,22 @@ def test_index_excludes_hidden_models(tmp_path, monkeypatch):
     monkeypatch.setattr(
         models_route,
         "_scan_models_dir",
-        lambda *a, **k: [_info("org/Normal-GGUF", normal), _info("ggml-org/models", probe)],
+        lambda *a, **k: [
+            _info("org/Normal-GGUF", normal),
+            _info("ggml-org/models", probe),
+            SimpleNamespace(
+                id = str(embedder),
+                path = str(embedder),
+                model_id = "unsloth/bge-small-en-v1.5-GGUF",
+                display_name = "embedding-Q8_0",
+            ),
+            SimpleNamespace(
+                id = str(local_default_embedder),
+                path = str(local_default_embedder),
+                model_id = None,
+                display_name = local_default_embedder.name,
+            ),
+        ],
     )
     monkeypatch.setattr(models_route, "_scan_hf_cache", lambda *a, **k: [])
     monkeypatch.setattr(models_route, "_resolve_hf_cache_dir", lambda: tmp_path)
@@ -713,6 +732,8 @@ def test_index_excludes_hidden_models(tmp_path, monkeypatch):
     index = resolver._index()
     assert "org/normal-gguf" in index  # keys are normalized to lowercase
     assert "ggml-org/models" not in index
+    assert "unsloth/bge-small-en-v1.5-gguf" not in index
+    assert str(local_default_embedder).lower() not in index
     # And the hidden probe cannot be auto-switched to by name.
     resolver._scan = (0.0, {})
     assert resolver.resolve_local_gguf("ggml-org/models") is None
@@ -1729,6 +1750,8 @@ def test_index_advertises_alias_not_filesystem_path(tmp_path, monkeypatch):
     # host path in /v1/models, yet the model stays resolvable by that path too.
     from types import SimpleNamespace
     import routes.models as models_route
+    from storage import studio_db
+    import utils.paths as paths
 
     gguf = tmp_path / "model-Q4_K_M.gguf"
     gguf.write_bytes(b"x" * 32)
@@ -1742,6 +1765,8 @@ def test_index_advertises_alias_not_filesystem_path(tmp_path, monkeypatch):
     monkeypatch.setattr(models_route, "_scan_hf_cache", lambda *a, **k: [])
     monkeypatch.setattr(models_route, "_resolve_hf_cache_dir", lambda: tmp_path)
     monkeypatch.setattr(models_route, "_is_hidden_model", lambda *a, **k: False)
+    monkeypatch.setattr(paths, "lmstudio_model_dirs", lambda: [])
+    monkeypatch.setattr(studio_db, "list_scan_folders", lambda: [])
     resolver._scan = (0.0, {})
 
     # The advertised id is the alias, never the absolute path.
diff --git a/studio/backend/utils/hidden_models.py b/studio/backend/utils/hidden_models.py
new file mode 100644
index 0000000000..20d0bb966e
--- /dev/null
+++ b/studio/backend/utils/hidden_models.py
@@ -0,0 +1,142 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Infra-only model detection shared by the model routes and the hub
+inventory. Lives directly under ``utils`` (not ``utils.models``) so the hub
+cache scanner can import it without pulling in ``utils/models/__init__.py``,
+which eagerly loads the model-config/checkpoint stack, and without importing
+``routes.models`` (import-time side effects, would cycle)."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Optional
+
+# Hub repo id shape ("owner/name", no leading separator); anything else is
+# treated as a local filesystem path.
+_HF_REPO_ID_RE = re.compile(r"^[A-Za-z0-9][\w.\-]*/[\w.\-]+$")
+
+# The llama.cpp install-validation probe repo. Always hidden.
+_PROBE_REPO_ID = "ggml-org/models"
+# The probe's on-disk filename. Carries the ".gguf" so it stays specific and
+# does not hide unrelated repos like ``user/stories260K-finetune-GGUF``.
+_PROBE_FILENAME = "stories260k.gguf"
+# Keep previously cached defaults hidden after settings changes.
+_DEFAULT_EMBEDDING_REPO_IDS = {
+    "unsloth/bge-small-en-v1.5",
+    "unsloth/bge-small-en-v1.5-GGUF",
+}
+# Local copies do not always retain the repo id. Keep a narrow basename
+# fallback for Studio's static default embedder only; configured custom repos
+# remain exact-match-only.
+_DEFAULT_EMBEDDING_PATH_BASENAMES = {"bge-small-en-v1.5"}
+
+
+def _safe_resolve(path: Path) -> Optional[str]:
+    """resolve() to a string, or None when the path is inaccessible."""
+    try:
+        return str(path.resolve())
+    except OSError:
+        return None
+
+
+def _existing_resolved_path(value: str) -> Optional[str]:
+    """Resolve an existing local path."""
+    path = Path(value).expanduser()
+    try:
+        if not path.exists():
+            return None
+    except OSError:
+        return None
+    return _safe_resolve(path)
+
+
+def _path_contains_repo_id(value: str, repo_ids: set[str]) -> bool:
+    """Match exact repo-derived path segments."""
+    parts = [part for part in value.lower().replace("\\", "/").split("/") if part]
+    for repo_id in repo_ids:
+        owner, name = repo_id.split("/", 1)
+        if f"models--{owner}--{name}" in parts:
+            return True
+        if any(
+            parts[index] == owner and parts[index + 1] == name for index in range(len(parts) - 1)
+        ):
+            return True
+    return False
+
+
+def _path_basename_is_default_embedder(value: str) -> bool:
+    """Match a default embedder folder or a suffixed local weight filename."""
+    normalized = value.lower().replace("\\", "/").rstrip("/")
+    basename = normalized.rsplit("/", 1)[-1]
+    return any(
+        basename == needle
+        or any(basename.startswith(f"{needle}{separator}") for separator in ("-", "_", "."))
+        for needle in _DEFAULT_EMBEDDING_PATH_BASENAMES
+    )
+
+
+def is_hidden_model(*values: str | None) -> bool:
+    """True if any id/path is the RAG embedding model (the effective embedder
+    or its GGUF companion repo) or the llama.cpp install validation probe
+    (ggml-org/models / stories260K), so pickers hide them (GGUF and non-GGUF).
+    None are usable chat models; the probe can be cached as a side effect of
+    installing the prebuilt llama-server and otherwise sorts smallest, so it
+    would be auto-selected.
+
+    Hub repo ids are matched EXACTLY (case-insensitive full "owner/name"), so a
+    custom embedder with a generic basename like "org/model" cannot substring
+    hide unrelated cached repos such as "user/model-chat" or "org/model-GGUF".
+    Existing paths take precedence over the identical ``owner/name`` repo
+    shape. Cache and LM Studio paths use exact repo-derived segments. Local
+    copies of the static default embedder also use a boundary-aware basename
+    fallback; configured custom repos never do."""
+    from core.rag import config as rag_config
+
+    hidden_repo_ids = {
+        _PROBE_REPO_ID.lower(),
+        *(repo_id.lower() for repo_id in _DEFAULT_EMBEDDING_REPO_IDS),
+    }
+    exact_paths: list[str] = []
+    for model in {
+        rag_config.EMBEDDING_MODEL,
+        rag_config.default_gguf_repo(),
+        rag_config.effective_embedding_model(),
+        rag_config.effective_gguf_repo(),
+    }:
+        existing_path = _existing_resolved_path(model)
+        if existing_path:
+            exact_paths.append(existing_path.lower())
+        elif _HF_REPO_ID_RE.match(model):
+            hidden_repo_ids.add(model.lower())
+        else:
+            resolved = _safe_resolve(Path(model).expanduser())
+            if resolved:
+                exact_paths.append(resolved.lower())
+    for v in values:
+        if not v:
+            continue
+        low = v.lower()
+        if _HF_REPO_ID_RE.match(v):
+            # A repo id ("owner/name"): match the hidden set exactly. It is
+            # never a filesystem path, so skip the path/filename checks.
+            if low in hidden_repo_ids:
+                return True
+            continue
+        # Anything else is treated as a filesystem path (the cached snapshot
+        # path, or a local model id). Match the probe by its exact filename and
+        # any configured local-path embedder by exact resolved path. Split on
+        # both separators so a Windows-style path ("...\\stories260K.gguf") is
+        # matched even when this runs on a POSIX interpreter (and vice versa).
+        if low.replace("\\", "/").rsplit("/", 1)[-1] == _PROBE_FILENAME:
+            return True
+        if _path_basename_is_default_embedder(v):
+            return True
+        if _path_contains_repo_id(v, hidden_repo_ids):
+            return True
+        if exact_paths:
+            resolved = _safe_resolve(Path(v).expanduser())
+            if resolved and resolved.lower() in exact_paths:
+                return True
+    return False
diff --git a/studio/frontend/src/features/hub/hooks/use-hidden-embedding-models.ts b/studio/frontend/src/features/hub/hooks/use-hidden-embedding-models.ts
new file mode 100644
index 0000000000..f78679310f
--- /dev/null
+++ b/studio/frontend/src/features/hub/hooks/use-hidden-embedding-models.ts
@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import { loadEmbeddingModelSettings } from "@/features/settings";
+import { useEffect, useState } from "react";
+import { useInventoryVersion } from "../stores/inventory-events";
+
+/** Backend-resolved embedding repos that optimistic inventory rows must hide. */
+export function useHiddenEmbeddingModelIds(
+  enabled: boolean,
+): ReadonlySet<string> {
+  const inventoryVersion = useInventoryVersion();
+  const [hiddenIds, setHiddenIds] = useState<ReadonlySet<string>>(
+    () => new Set(),
+  );
+
+  // biome-ignore lint/correctness/useExhaustiveDependencies: inventory invalidation must reload backend-resolved embedder ids
+  useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+    let cancelled = false;
+    loadEmbeddingModelSettings()
+      .then((settings) => {
+        if (cancelled) {
+          return;
+        }
+        setHiddenIds(
+          new Set(
+            [
+              settings.embeddingModel,
+              settings.embeddingGgufRepo,
+              settings.defaultEmbeddingModel,
+              settings.defaultEmbeddingGgufRepo,
+            ].map((value) => value.trim().toLowerCase()),
+          ),
+        );
+      })
+      .catch(() => undefined);
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, inventoryVersion]);
+
+  return hiddenIds;
+}
diff --git a/studio/frontend/src/features/hub/hub-page.tsx b/studio/frontend/src/features/hub/hub-page.tsx
index 630daa48ad..d57f9636fe 100644
--- a/studio/frontend/src/features/hub/hub-page.tsx
+++ b/studio/frontend/src/features/hub/hub-page.tsx
@@ -63,6 +63,7 @@ import { useDiscoverSearch } from "./hooks/use-discover-search";
 import { useFeedWriteBack } from "./hooks/use-feed-write-back";
 import { useHubFeed } from "./hooks/use-hub-feed";
 import { useHubModelVram } from "./hooks/use-hub-model-vram";
+import { useHiddenEmbeddingModelIds } from "./hooks/use-hidden-embedding-models";
 import { useModelsSelection } from "./hooks/use-models-selection";
 import {
   CHANNEL_TO_SECTION,
@@ -73,7 +74,10 @@ import {
   SECTION_TO_CHANNEL,
   findChannel,
 } from "./lib/channels";
-import { isHiddenModelId } from "./lib/hidden-models";
+import {
+  isConfiguredHiddenModelId,
+  isHiddenModelId,
+} from "./lib/hidden-models";
 import { inventoryRowMatches, tokenizeQuery } from "./lib/inventory-search";
 import { resolveOwnerProviderLogo } from "./lib/provider-logos";
 import {
@@ -386,6 +390,7 @@ export function ModelsPage() {
     useState<ModelFormatFilter>("all");
   const isDiscoverTab = tab === "discover";
   const isDatasetMode = resourceType === "datasets";
+  const hiddenEmbeddingModelIds = useHiddenEmbeddingModelIds(!isDatasetMode);
   const urlSection = hubSearch.section ?? null;
   const isModelDiscover = isDiscoverTab && !isDatasetMode;
   const sectionChannelId: ChannelId | null = urlSection
@@ -700,6 +705,7 @@ export function ModelsPage() {
     return discoverRows.filter(
       (row) =>
         !isHiddenModelId(row.id) &&
+        !isConfiguredHiddenModelId(hiddenEmbeddingModelIds, row.id) &&
         // The default feed only shows models with a provider logo.
         (!isFeedMode ||
           resolveOwnerProviderLogo(row.owner, row.repo) !== null) &&
@@ -714,6 +720,7 @@ export function ModelsPage() {
     );
   }, [
     discoverRows,
+    hiddenEmbeddingModelIds,
     isDatasetMode,
     isFeedMode,
     effectiveDiscoverFormat,
@@ -739,7 +746,11 @@ export function ModelsPage() {
         effectiveCachedRows,
         effectiveLocalRows,
       )
-        .filter((row) => !isHiddenModelId(row.id))
+        .filter(
+          (row) =>
+            !isHiddenModelId(row.id) &&
+            !isConfiguredHiddenModelId(hiddenEmbeddingModelIds, row.id),
+        )
         .filter((row) => matchesFormat(row.result.isGguf, "gguf"))
         // Same fit filter as the main Discover list, so the feed carousel
         // honors the toggle too.
@@ -751,6 +762,7 @@ export function ModelsPage() {
         ),
     [
       hubFeed.trending.results,
+      hiddenEmbeddingModelIds,
       modelDiscoveryInventorySignature,
       fitOnDeviceOnly,
       gpu,
@@ -778,22 +790,29 @@ export function ModelsPage() {
     () => (isDiscoverTab ? [] : tokenizeQuery(deferredDebouncedQuery)),
     [isDiscoverTab, deferredDebouncedQuery],
   );
-  // Hide infra models (e.g. the RAG embedder bge-small-en-v1.5) from the On
-  // Device list like Discover, but reveal a row when a query matches it so the
-  // user can confirm it is already downloaded.
+  // Server cache rows already apply variant-aware infra hiding. Optimistic
+  // rows are not server-confirmed, so apply the client filter first.
   const isVisibleInventoryRow = useCallback(
-    (row: CachedInventoryRow | LocalInventoryRow) =>
-      // Local rows can have a null repoId and an id that is a hash rather than
-      // the file path/name, so also check path/title (the backend's
-      // _is_hidden_model checks the on-disk path for the same reason).
-      !isHiddenModelId(
-        row.id,
-        row.repoId,
-        row.kind !== "cache" ? row.path : undefined,
-        row.kind !== "cache" ? row.title : undefined,
-      ) ||
-      (inventoryTokens.length > 0 && inventoryRowMatches(row, inventoryTokens)),
-    [inventoryTokens],
+    (row: CachedInventoryRow | LocalInventoryRow) => {
+      if (row.kind === "cache") {
+        return (
+          !row.optimistic ||
+          (!isHiddenModelId(row.id, row.repoId, row.cachePath) &&
+            !isConfiguredHiddenModelId(
+              hiddenEmbeddingModelIds,
+              row.id,
+              row.repoId,
+              row.cachePath,
+            ))
+        );
+      }
+      // Local rows may lack a repo id, so also check path and title.
+      return (
+        !isHiddenModelId(row.id, row.repoId, row.path, row.title) ||
+        (inventoryTokens.length > 0 && inventoryRowMatches(row, inventoryTokens))
+      );
+    },
+    [hiddenEmbeddingModelIds, inventoryTokens],
   );
   // Format filter is a deliberate scope narrowing, so hard-filter it out. The
   // text query instead drives dim-not-filter on On Device (see ModelsCatalog) so
diff --git a/studio/frontend/src/features/hub/index.ts b/studio/frontend/src/features/hub/index.ts
index 3515f6ca76..5d4151e87d 100644
--- a/studio/frontend/src/features/hub/index.ts
+++ b/studio/frontend/src/features/hub/index.ts
@@ -2,6 +2,7 @@
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
 export { cancelStagedModelDownload } from "./download-manager";
+export { bumpInventoryVersion } from "./stores/inventory-events";
 export {
   getHfToken,
   mirrorHfTokenInto,
diff --git a/studio/frontend/src/features/hub/inventory/inventory-hints.ts b/studio/frontend/src/features/hub/inventory/inventory-hints.ts
index af9f254ab3..5e202e3150 100644
--- a/studio/frontend/src/features/hub/inventory/inventory-hints.ts
+++ b/studio/frontend/src/features/hub/inventory/inventory-hints.ts
@@ -12,6 +12,7 @@ export type InventoryHintRow = {
   repo_id: string;
   size_bytes: number;
   partial?: boolean;
+  optimistic?: boolean;
 };
 
 export type InventoryHintReconciliation = {
@@ -41,6 +42,7 @@ function optimisticRow(hint: InventoryHint): InventoryHintRow {
     repo_id: hint.repoId,
     size_bytes: hint.bytes ?? 0,
     partial: false,
+    optimistic: true,
   };
 }
 
@@ -101,9 +103,14 @@ function mergeInventoryHint(
   if (idx === -1) {
     return [...rows, seed];
   }
+  const serverRow = rows[idx];
   const merged = {
-    ...rows[idx],
-    ...seed,
+    ...serverRow,
+    // A completed hint may arrive before a partial server scan catches up. In
+    // that case keep the synthetic row non-runnable. A complete server row is
+    // already authoritative even when its runnable-weight size is smaller than
+    // the hint's full-snapshot byte count, so do not mark that merge optimistic.
+    ...(serverRow.partial ? seed : { optimistic: false }),
     size_bytes: Math.max(rowSizeBytes(rows[idx]), rowSizeBytes(seed)),
   };
   return [...rows.slice(0, idx), merged, ...rows.slice(idx + 1)];
diff --git a/studio/frontend/src/features/hub/inventory/types.ts b/studio/frontend/src/features/hub/inventory/types.ts
index c86ffb1d86..6f65a56037 100644
--- a/studio/frontend/src/features/hub/inventory/types.ts
+++ b/studio/frontend/src/features/hub/inventory/types.ts
@@ -54,6 +54,7 @@ export interface CachedInventoryRow {
   libraryName?: string | null;
   quantMethod?: string | null;
   liveDownload?: boolean;
+  optimistic?: boolean;
 }
 
 export interface LocalInventoryRow {
diff --git a/studio/frontend/src/features/hub/inventory/use-hub-inventory.ts b/studio/frontend/src/features/hub/inventory/use-hub-inventory.ts
index a7dc7ae3f3..fea7b3d331 100644
--- a/studio/frontend/src/features/hub/inventory/use-hub-inventory.ts
+++ b/studio/frontend/src/features/hub/inventory/use-hub-inventory.ts
@@ -204,6 +204,7 @@ function liveDownloadInventoryRows(
           size_bytes: job.displayBytes,
           partial: true,
           partial_transport: null,
+          optimistic: true,
         },
         modelFormat,
       ),
diff --git a/studio/frontend/src/features/hub/inventory/view-models.ts b/studio/frontend/src/features/hub/inventory/view-models.ts
index 63d70418be..334050fab4 100644
--- a/studio/frontend/src/features/hub/inventory/view-models.ts
+++ b/studio/frontend/src/features/hub/inventory/view-models.ts
@@ -176,6 +176,7 @@ export function buildCachedInventoryRow(
     runtime?: string | null;
     format_variant?: string | null;
     capabilities?: BackendModelCapabilities | null;
+    optimistic?: boolean;
   },
   fallbackFormat: ModelInventoryFormat,
 ): CachedInventoryRow {
@@ -185,6 +186,15 @@ export function buildCachedInventoryRow(
   const inferredFromEndpoint =
     rawModelFormat === "unknown" && modelFormat !== "unknown";
   const requiresVariant = modelFormat === "gguf";
+  const capabilities = normalizeCapabilities(
+    inferredFromEndpoint ? null : row.capabilities,
+    modelFormat,
+    row.partial ?? false,
+    requiresVariant,
+  );
+  if (row.optimistic) {
+    capabilities.canChat = false;
+  }
   return {
     kind: "cache",
     id:
@@ -202,12 +212,7 @@ export function buildCachedInventoryRow(
       modelFormat,
     ),
     formatVariant: row.format_variant ?? null,
-    capabilities: normalizeCapabilities(
-      inferredFromEndpoint ? null : row.capabilities,
-      modelFormat,
-      row.partial ?? false,
-      requiresVariant,
-    ),
+    capabilities,
     bytes: row.size_bytes,
     cachePath: row.cache_path ?? null,
     partial: row.partial ?? false,
@@ -216,6 +221,7 @@ export function buildCachedInventoryRow(
     tags: row.tags,
     libraryName: row.library_name ?? null,
     quantMethod: row.quant_method ?? null,
+    optimistic: row.optimistic,
   };
 }
 
diff --git a/studio/frontend/src/features/hub/lib/hidden-models.ts b/studio/frontend/src/features/hub/lib/hidden-models.ts
index 2dbe257947..634a061e0c 100644
--- a/studio/frontend/src/features/hub/lib/hidden-models.ts
+++ b/studio/frontend/src/features/hub/lib/hidden-models.ts
@@ -1,11 +1,13 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
-// Infra models hidden from every browse/preview list (Hub discover and the chat
-// model selector). Mirrors the backend `_is_hidden_model`: the RAG embedding
-// model and the llama.cpp validation probe are not usable chat models. Per-repo
-// file/download views are NOT filtered, so a reinstall still shows the model as
-// already downloaded.
+// Infra models hidden from browse/preview lists (Hub Discover, the chat model
+// selector, and local on-device rows). Mirrors the backend
+// `utils.hidden_models`: the RAG embedding model and the llama.cpp validation
+// probe are not usable chat models. Server-confirmed cache rows are trusted
+// because the backend applies variant-aware filtering. Optimistic cache rows
+// still use these needles until the server confirms them. Per-repo views are
+// not filtered, so reinstall flows still show downloaded files.
 const HIDDEN_NEEDLES = [
   "bge-small-en-v1.5", // RAG embedder: unsloth/bge-small-en-v1.5[-GGUF]
   "ggml-org/models", // llama.cpp validation probe repo
@@ -17,8 +19,20 @@ export function isHiddenModelId(
   ...values: (string | null | undefined)[]
 ): boolean {
   return values.some((v) => {
-    if (!v) return false;
+    if (!v) {
+      return false;
+    }
     const lower = v.toLowerCase();
     return HIDDEN_NEEDLES.some((needle) => lower.includes(needle));
   });
 }
+
+/** Exact-match configured infra repos without hiding similarly named models. */
+export function isConfiguredHiddenModelId(
+  configuredIds: ReadonlySet<string>,
+  ...values: (string | null | undefined)[]
+): boolean {
+  return values.some(
+    (value) => value != null && configuredIds.has(value.trim().toLowerCase()),
+  );
+}
diff --git a/studio/frontend/src/features/settings/api/embedding-model.ts b/studio/frontend/src/features/settings/api/embedding-model.ts
index 9a61142f73..cc21559f38 100644
--- a/studio/frontend/src/features/settings/api/embedding-model.ts
+++ b/studio/frontend/src/features/settings/api/embedding-model.ts
@@ -2,11 +2,14 @@
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
 import { authFetch } from "@/features/auth";
+import { bumpInventoryVersion } from "@/features/hub";
 import { readFastApiError } from "@/lib/format-fastapi-error";
 
 export type EmbeddingModelSettings = {
   embeddingModel: string;
+  embeddingGgufRepo: string;
   defaultEmbeddingModel: string;
+  defaultEmbeddingGgufRepo: string;
   isCustom: boolean;
 };
 
@@ -14,8 +17,12 @@ type ApiEmbeddingModelSettings = {
   // biome-ignore lint/style/useNamingConvention: API schema
   embedding_model: string;
   // biome-ignore lint/style/useNamingConvention: API schema
+  embedding_gguf_repo: string;
+  // biome-ignore lint/style/useNamingConvention: API schema
   default_embedding_model: string;
   // biome-ignore lint/style/useNamingConvention: API schema
+  default_embedding_gguf_repo: string;
+  // biome-ignore lint/style/useNamingConvention: API schema
   is_custom: boolean;
 };
 
@@ -30,7 +37,9 @@ export class EmbeddingModelBlockedError extends Error {}
 function fromApi(settings: ApiEmbeddingModelSettings): EmbeddingModelSettings {
   return {
     embeddingModel: settings.embedding_model,
+    embeddingGgufRepo: settings.embedding_gguf_repo,
     defaultEmbeddingModel: settings.default_embedding_model,
+    defaultEmbeddingGgufRepo: settings.default_embedding_gguf_repo,
     isCustom: settings.is_custom,
   };
 }
@@ -75,7 +84,9 @@ export async function updateEmbeddingModelSettings(
       await readFastApiError(res, "Failed to save embedding model"),
     );
   }
-  return fromApi(await res.json());
+  const settings = fromApi(await res.json());
+  bumpInventoryVersion();
+  return settings;
 }
 
 export async function resetEmbeddingModelSettings(): Promise<EmbeddingModelSettings> {
@@ -87,5 +98,7 @@ export async function resetEmbeddingModelSettings(): Promise<EmbeddingModelSetti
       await readFastApiError(res, "Failed to reset embedding model"),
     );
   }
-  return fromApi(await res.json());
+  const settings = fromApi(await res.json());
+  bumpInventoryVersion();
+  return settings;
 }
diff --git a/studio/frontend/src/features/settings/index.ts b/studio/frontend/src/features/settings/index.ts
index 1e4d9d8844..f27100a322 100644
--- a/studio/frontend/src/features/settings/index.ts
+++ b/studio/frontend/src/features/settings/index.ts
@@ -2,6 +2,7 @@
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
 export { SettingsDialog } from "./settings-dialog";
+export { loadEmbeddingModelSettings } from "./api/embedding-model";
 export {
   loadPersonalization,
   savePersonalization,