diff --git a/cuda_pathfinder/cuda/pathfinder/__init__.py b/cuda_pathfinder/cuda/pathfinder/__init__.py
index afffd54263..8441b95fc4 100644
--- a/cuda_pathfinder/cuda/pathfinder/__init__.py
+++ b/cuda_pathfinder/cuda/pathfinder/__init__.py
@@ -5,6 +5,8 @@
 
 from cuda.pathfinder._version import __version__  # noqa: F401
 
+from cuda.pathfinder._binaries.find_nvidia_binaries import find_nvidia_binary as find_nvidia_binary
+from cuda.pathfinder._binaries.supported_nvidia_binaries import SUPPORTED_BINARIES as SUPPORTED_NVIDIA_BINARIES
 from cuda.pathfinder._dynamic_libs.load_dl_common import DynamicLibNotFoundError as DynamicLibNotFoundError
 from cuda.pathfinder._dynamic_libs.load_dl_common import LoadedDL as LoadedDL
 from cuda.pathfinder._dynamic_libs.load_nvidia_dynamic_lib import load_nvidia_dynamic_lib as load_nvidia_dynamic_lib
@@ -13,6 +15,15 @@
 )
 from cuda.pathfinder._headers.find_nvidia_headers import find_nvidia_header_directory as find_nvidia_header_directory
 from cuda.pathfinder._headers.supported_nvidia_headers import SUPPORTED_HEADERS_CTK as _SUPPORTED_HEADERS_CTK
+from cuda.pathfinder._static_libs.find_nvidia_static_libs import find_nvidia_static_lib as find_nvidia_static_lib
+from cuda.pathfinder._static_libs.supported_nvidia_static_libs import (
+    SUPPORTED_STATIC_LIBS as SUPPORTED_NVIDIA_STATIC_LIBS,
+)
+from cuda.pathfinder._utils.toolchain_tracker import (
+    SearchContext as SearchContext,
+    ToolchainMismatchError as ToolchainMismatchError,
+    reset_default_context as reset_default_context,
+)
 
 # Indirections to help Sphinx find the docstrings.
 #: Mapping from short CUDA Toolkit (CTK) library names to their canonical
diff --git a/cuda_pathfinder/cuda/pathfinder/_binaries/find_nvidia_binaries.py b/cuda_pathfinder/cuda/pathfinder/_binaries/find_nvidia_binaries.py
new file mode 100644
index 0000000000..d59f89a3d3
--- /dev/null
+++ b/cuda_pathfinder/cuda/pathfinder/_binaries/find_nvidia_binaries.py
@@ -0,0 +1,110 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import functools
+import os
+from typing import Sequence
+
+from cuda.pathfinder._binaries.supported_nvidia_binaries import SITE_PACKAGES_BINDIRS, SUPPORTED_BINARIES
+from cuda.pathfinder._utils.env_vars import get_cuda_home_or_path
+from cuda.pathfinder._utils.find_sub_dirs import find_sub_dirs_all_sitepackages
+from cuda.pathfinder._utils.path_utils import _abs_norm
+from cuda.pathfinder._utils.toolchain_tracker import (
+    SearchContext,
+    SearchLocation,
+    ToolchainSource,
+    get_default_context,
+)
+
+
+def _binary_filename_variants(name: str) -> Sequence[str]:
+    """Generate filename variants for a binary (cross-platform).
+
+    Args:
+        name: Base binary name.
+
+    Returns:
+        Tuple of possible filenames (e.g., "nvcc", "nvcc.exe").
+    """
+    return (name, f"{name}.exe")
+
+
+def _get_site_packages_subdirs(binary_name: str) -> Sequence[str]:
+    """Get site-packages sub-directories for a binary.
+
+    Args:
+        binary_name: Name of the binary.
+
+    Returns:
+        List of sub-directories to search, or empty list if binary not in site-packages.
+    """
+    relative_directories = SITE_PACKAGES_BINDIRS.get(binary_name)
+    if not relative_directories:
+        return []
+
+    # Expand site-packages paths
+    sub_directories = []
+    for relative_directory in relative_directories:
+        for found_dir in find_sub_dirs_all_sitepackages(tuple(relative_directory.split("/"))):
+            sub_directories.append(found_dir)
+    return sub_directories
+
+
+# Define search locations for binaries
+def _create_search_locations(binary_name: str) -> list[SearchLocation]:
+    """Create search location configurations for a specific binary.
+
+    Args:
+        binary_name: Name of the binary to search for.
+
+    Returns:
+        List of SearchLocation objects to try.
+    """
+    return [
+        SearchLocation(
+            source=ToolchainSource.SITE_PACKAGES,
+            base_dir_func=lambda: None,  # Use subdirs for full paths
+            subdirs=_get_site_packages_subdirs(binary_name),
+            filename_variants=_binary_filename_variants,
+        ),
+        SearchLocation(
+            source=ToolchainSource.CONDA,
+            base_dir_func=lambda: os.environ.get("CONDA_PREFIX"),
+            subdirs=["Library/bin", "bin"],  # Windows and Unix layouts
+            filename_variants=_binary_filename_variants,
+        ),
+        SearchLocation(
+            source=ToolchainSource.CUDA_HOME,
+            base_dir_func=get_cuda_home_or_path,
+            subdirs=["bin"],
+            filename_variants=_binary_filename_variants,
+        ),
+    ]
+
+
+@functools.cache
+def find_nvidia_binary(binary_name: str, *, context: SearchContext | None = None) -> str | None:
+    """Locate a CUDA binary executable.
+
+    Args:
+        binary_name: Name of the binary (e.g., "nvdisasm", "cuobjdump").
+        context: Optional SearchContext for toolchain consistency tracking.
+            If None, uses the default module-level context.
+
+    Returns:
+        Absolute path to the binary, or None if not found.
+
+    Raises:
+        RuntimeError: If binary_name is not supported.
+        ToolchainMismatchError: If binary found in different source than
+            the context's preferred source.
+    """
+    if binary_name not in SUPPORTED_BINARIES:
+        raise RuntimeError(f"UNKNOWN {binary_name=}")
+
+    if context is None:
+        context = get_default_context()
+
+    locations = _create_search_locations(binary_name)
+    path = context.find(binary_name, locations)
+    return _abs_norm(path) if path else None
diff --git a/cuda_pathfinder/cuda/pathfinder/_binaries/supported_nvidia_binaries.py b/cuda_pathfinder/cuda/pathfinder/_binaries/supported_nvidia_binaries.py
new file mode 100644
index 0000000000..0e9bc6ca8a
--- /dev/null
+++ b/cuda_pathfinder/cuda/pathfinder/_binaries/supported_nvidia_binaries.py
@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+# THIS FILE NEEDS TO BE REVIEWED/UPDATED FOR EACH CTK RELEASE
+# Likely candidates for updates are:
+#     SUPPORTED_BINARIES
+#     SITE_PACKAGES_BINDIRS
+
+from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
+
+# Supported CUDA binaries that can be found
+SUPPORTED_BINARIES_COMMON = (
+    "nvdisasm",
+    "cuobjdump",
+)
+
+SUPPORTED_BINARIES = SUPPORTED_BINARIES_COMMON
+
+# Map from binary name to relative paths under site-packages
+# These are typically from cuda-toolkit[nvcc] wheels
+SITE_PACKAGES_BINDIRS = {
+    "nvdisasm": ["nvidia/cuda_nvcc/bin"],
+    "cuobjdump": ["nvidia/cuda_nvcc/bin"],
+}
diff --git a/cuda_pathfinder/cuda/pathfinder/_headers/find_nvidia_headers.py b/cuda_pathfinder/cuda/pathfinder/_headers/find_nvidia_headers.py
index 63f8a627fd..f0755034ab 100644
--- a/cuda_pathfinder/cuda/pathfinder/_headers/find_nvidia_headers.py
+++ b/cuda_pathfinder/cuda/pathfinder/_headers/find_nvidia_headers.py
@@ -8,15 +8,10 @@
 from cuda.pathfinder._headers import supported_nvidia_headers
 from cuda.pathfinder._utils.env_vars import get_cuda_home_or_path
 from cuda.pathfinder._utils.find_sub_dirs import find_sub_dirs_all_sitepackages
+from cuda.pathfinder._utils.path_utils import _abs_norm
 from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
 
 
-def _abs_norm(path: str | None) -> str | None:
-    if path:
-        return os.path.normpath(os.path.abspath(path))
-    return None
-
-
 def _joined_isfile(dirpath: str, basename: str) -> bool:
     return os.path.isfile(os.path.join(dirpath, basename))
 
diff --git a/cuda_pathfinder/cuda/pathfinder/_static_libs/find_nvidia_static_libs.py b/cuda_pathfinder/cuda/pathfinder/_static_libs/find_nvidia_static_libs.py
new file mode 100644
index 0000000000..a6bd24c1d2
--- /dev/null
+++ b/cuda_pathfinder/cuda/pathfinder/_static_libs/find_nvidia_static_libs.py
@@ -0,0 +1,164 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import functools
+import os
+from typing import Sequence
+
+from cuda.pathfinder._static_libs.supported_nvidia_static_libs import (
+    SITE_PACKAGES_STATIC_LIBDIRS,
+    SUPPORTED_STATIC_LIBS,
+)
+from cuda.pathfinder._utils.env_vars import get_cuda_home_or_path
+from cuda.pathfinder._utils.find_sub_dirs import find_sub_dirs_all_sitepackages
+from cuda.pathfinder._utils.path_utils import _abs_norm
+from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
+from cuda.pathfinder._utils.toolchain_tracker import (
+    SearchContext,
+    SearchLocation,
+    ToolchainSource,
+    get_default_context,
+)
+
+
+# Generic search locations by toolchain source (platform-specific at import time)
+if IS_WINDOWS:
+    CONDA_LIB_SUBDIRS = ("Library/lib", "Library/lib/x64")
+    CONDA_NVVM_SUBDIRS = ("Library/nvvm/libdevice",)
+    CUDA_HOME_LIB_SUBDIRS = ("lib/x64", "lib")
+    CUDA_HOME_NVVM_SUBDIRS = ("nvvm/libdevice",)
+else:
+    CONDA_LIB_SUBDIRS = ("lib",)
+    CONDA_NVVM_SUBDIRS = ("nvvm/libdevice",)
+    CUDA_HOME_LIB_SUBDIRS = ("lib64", "lib")
+    CUDA_HOME_NVVM_SUBDIRS = ("nvvm/libdevice",)
+
+
+def _static_lib_filename_variants(artifact_name: str) -> Sequence[str]:
+    """Generate platform-appropriate filename variants for an artifact.
+
+    Args:
+        artifact_name: Canonical artifact name (e.g., "cudadevrt", "libdevice.10.bc").
+
+    Returns:
+        Sequence of filenames to search for on this platform.
+
+    Examples:
+        On Windows:
+            "cudadevrt" -> ("cudadevrt.lib",)
+            "libdevice.10.bc" -> ("libdevice.10.bc",)
+        On Linux:
+            "cudadevrt" -> ("libcudadevrt.a",)
+            "libdevice.10.bc" -> ("libdevice.10.bc",)
+    """
+    # Files that are the same on all platforms (e.g., .bc bitcode files)
+    if "." in artifact_name:
+        return (artifact_name,)
+
+    # Platform-specific library naming conventions
+    if IS_WINDOWS:
+        return (f"{artifact_name}.lib",)
+    else:
+        return (f"lib{artifact_name}.a",)
+
+
+def _get_cuda_home_subdirs_with_targets() -> tuple[str, ...]:
+    """Get CUDA_HOME subdirectories including expanded targets/* paths.
+
+    Returns:
+        Tuple of subdirectories to search under CUDA_HOME.
+    """
+    import glob
+
+    subdirs = list(CUDA_HOME_LIB_SUBDIRS + CUDA_HOME_NVVM_SUBDIRS)
+
+    # On Linux, also search targets/*/lib64 and targets/*/lib for cross-compilation
+    if not IS_WINDOWS:
+        cuda_home = get_cuda_home_or_path()
+        if cuda_home:
+            for lib_subdir in ("lib64", "lib"):
+                pattern = os.path.join(cuda_home, "targets", "*", lib_subdir)
+                for target_dir in sorted(glob.glob(pattern), reverse=True):
+                    # Make relative to cuda_home
+                    rel_path = os.path.relpath(target_dir, cuda_home)
+                    subdirs.append(rel_path)
+
+    return tuple(subdirs)
+
+
+def _create_search_locations(artifact_name: str) -> list[SearchLocation]:
+    """Create generic search location configurations.
+
+    Args:
+        artifact_name: Name of the artifact to search for.
+
+    Returns:
+        List of SearchLocation objects to try.
+    """
+    locations = []
+
+    # Site-packages: Create separate SearchLocation for each found directory
+    relative_directories = SITE_PACKAGES_STATIC_LIBDIRS.get(artifact_name)
+    if relative_directories:
+        for relative_directory in relative_directories:
+            for found_dir in find_sub_dirs_all_sitepackages(tuple(relative_directory.split("/"))):
+                locations.append(
+                    SearchLocation(
+                        source=ToolchainSource.SITE_PACKAGES,
+                        base_dir_func=lambda d=found_dir: d,
+                        subdirs=[""],
+                        filename_variants=_static_lib_filename_variants,
+                    )
+                )
+
+    # Conda: Generic lib and nvvm locations
+    locations.append(
+        SearchLocation(
+            source=ToolchainSource.CONDA,
+            base_dir_func=lambda: os.environ.get("CONDA_PREFIX"),
+            subdirs=CONDA_LIB_SUBDIRS + CONDA_NVVM_SUBDIRS,
+            filename_variants=_static_lib_filename_variants,
+        )
+    )
+
+    # CUDA_HOME: Generic lib and nvvm locations (including targets/* on Linux)
+    locations.append(
+        SearchLocation(
+            source=ToolchainSource.CUDA_HOME,
+            base_dir_func=get_cuda_home_or_path,
+            subdirs=_get_cuda_home_subdirs_with_targets(),
+            filename_variants=_static_lib_filename_variants,
+        )
+    )
+
+    return locations
+
+
+@functools.cache
+def find_nvidia_static_lib(artifact_name: str, *, context: SearchContext | None = None) -> str | None:
+    """Locate a CUDA static library or artifact file.
+
+    Args:
+        artifact_name: Canonical artifact name (e.g., "libdevice.10.bc", "cudadevrt").
+            Platform-specific filenames are resolved automatically:
+            - "cudadevrt" -> "libcudadevrt.a" on Linux, "cudadevrt.lib" on Windows
+        context: Optional SearchContext for toolchain consistency tracking.
+            If None, uses the default module-level context.
+
+    Returns:
+        Absolute path to the artifact, or None if not found.
+
+    Raises:
+        RuntimeError: If artifact_name is not supported.
+        ToolchainMismatchError: If artifact found in different source than
+            the context's preferred source.
+    """
+    if artifact_name not in SUPPORTED_STATIC_LIBS:
+        raise RuntimeError(f"UNKNOWN {artifact_name=}")
+
+    if context is None:
+        context = get_default_context()
+
+    locations = _create_search_locations(artifact_name)
+    path = context.find(artifact_name, locations)
+    return _abs_norm(path) if path else None
diff --git a/cuda_pathfinder/cuda/pathfinder/_static_libs/supported_nvidia_static_libs.py b/cuda_pathfinder/cuda/pathfinder/_static_libs/supported_nvidia_static_libs.py
new file mode 100644
index 0000000000..f0b7a62bfb
--- /dev/null
+++ b/cuda_pathfinder/cuda/pathfinder/_static_libs/supported_nvidia_static_libs.py
@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+# THIS FILE NEEDS TO BE REVIEWED/UPDATED FOR EACH CTK RELEASE
+# Likely candidates for updates are:
+#     SUPPORTED_STATIC_LIBS
+#     SITE_PACKAGES_STATIC_LIBDIRS
+
+# Supported CUDA static libraries and artifacts (canonical names)
+SUPPORTED_STATIC_LIBS_COMMON = (
+    "libdevice.10.bc",  # Bitcode file (same name on all platforms)
+    "cudadevrt",  # Static device runtime library (libcudadevrt.a on Linux, cudadevrt.lib on Windows)
+)
+
+SUPPORTED_STATIC_LIBS = SUPPORTED_STATIC_LIBS_COMMON
+
+# Map from canonical artifact name to relative paths under site-packages
+SITE_PACKAGES_STATIC_LIBDIRS = {
+    "libdevice.10.bc": ["nvidia/cuda_nvvm/nvvm/libdevice"],
+    "cudadevrt": [
+        "nvidia/cuda_cudart/lib",  # Linux
+        "nvidia/cuda_cudart/lib/x64",  # Windows (if present)
+    ],
+}
diff --git a/cuda_pathfinder/cuda/pathfinder/_utils/path_utils.py b/cuda_pathfinder/cuda/pathfinder/_utils/path_utils.py
new file mode 100644
index 0000000000..b5105d1950
--- /dev/null
+++ b/cuda_pathfinder/cuda/pathfinder/_utils/path_utils.py
@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+
+
+def _abs_norm(path: str | None) -> str | None:
+    """Normalize and convert a path to an absolute path.
+
+    Args:
+        path (str or None): The path to normalize and make absolute.
+
+    Returns:
+        str or None: The normalized absolute path, or None if the input is None
+        or empty.
+    """
+    if path:
+        return os.path.normpath(os.path.abspath(path))
+    return None
diff --git a/cuda_pathfinder/cuda/pathfinder/_utils/toolchain_tracker.py b/cuda_pathfinder/cuda/pathfinder/_utils/toolchain_tracker.py
new file mode 100644
index 0000000000..d4f91ff1ab
--- /dev/null
+++ b/cuda_pathfinder/cuda/pathfinder/_utils/toolchain_tracker.py
@@ -0,0 +1,177 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Callable, Optional, Sequence
+
+
+class ToolchainSource(Enum):
+    """Source location of a CUDA artifact."""
+
+    SITE_PACKAGES = auto()
+    CONDA = auto()
+    CUDA_HOME = auto()
+
+
+@dataclass(frozen=True)
+class SearchLocation:
+    """Defines where and how to search for artifacts.
+
+    Attributes:
+        source: Which toolchain source this represents.
+        base_dir_func: Function that returns the base directory to search, or None if unavailable.
+        subdirs: Subdirectories to check under the base (e.g., ["bin"], ["Library/bin", "bin"]).
+        filename_variants: Function that takes artifact name and returns possible filenames.
+    """
+
+    source: ToolchainSource
+    base_dir_func: Callable[[], Optional[str]]
+    subdirs: Sequence[str]
+    filename_variants: Callable[[str], Sequence[str]]
+
+
+@dataclass(frozen=True)
+class ArtifactRecord:
+    """Record of a found CUDA artifact."""
+
+    name: str
+    path: str
+    source: ToolchainSource
+
+
+class ToolchainMismatchError(RuntimeError):
+    """Raised when artifacts from different sources are mixed."""
+
+    def __init__(
+        self,
+        artifact_name: str,
+        attempted_source: ToolchainSource,
+        preferred_source: ToolchainSource,
+        preferred_artifacts: list[ArtifactRecord],
+    ):
+        self.artifact_name = artifact_name
+        self.attempted_source = attempted_source
+        self.preferred_source = preferred_source
+        self.preferred_artifacts = preferred_artifacts
+
+        artifact_list = ", ".join(f"'{a.name}'" for a in preferred_artifacts)
+        message = (
+            f"Toolchain mismatch: '{artifact_name}' found in {attempted_source.name}, "
+            f"but using {preferred_source.name} (previous: {artifact_list})"
+        )
+        super().__init__(message)
+
+
+def search_location(location: SearchLocation, artifact_name: str) -> Optional[str]:
+    """Search for an artifact in a specific location.
+
+    Args:
+        location: The search location configuration.
+        artifact_name: Name of the artifact to find.
+
+    Returns:
+        Path to artifact if found, None otherwise.
+    """
+    base_dir = location.base_dir_func()
+    if not base_dir:
+        return None
+
+    filenames = location.filename_variants(artifact_name)
+
+    for subdir in location.subdirs:
+        dir_path = os.path.join(base_dir, subdir)
+        for filename in filenames:
+            file_path = os.path.join(dir_path, filename)
+            if os.path.isfile(file_path):
+                return file_path
+
+    return None
+
+
+class SearchContext:
+    """Tracks toolchain consistency across artifact searches.
+
+    This context ensures all artifacts come from the same source to prevent
+    version mismatches. The first artifact found establishes the preferred
+    source for subsequent searches.
+    """
+
+    def __init__(self):
+        self._artifacts: dict[str, ArtifactRecord] = {}
+        self._preferred_source: Optional[ToolchainSource] = None
+
+    @property
+    def preferred_source(self) -> Optional[ToolchainSource]:
+        """The preferred toolchain source, or None if not yet determined."""
+        return self._preferred_source
+
+    def record(self, name: str, path: str, source: ToolchainSource) -> None:
+        """Record an artifact and enforce consistency.
+
+        Args:
+            name: Artifact name.
+            path: Absolute path where found.
+            source: Source where found.
+
+        Raises:
+            ToolchainMismatchError: If source conflicts with preferred source.
+        """
+        if self._preferred_source is None:
+            self._preferred_source = source
+        elif source != self._preferred_source:
+            raise ToolchainMismatchError(
+                artifact_name=name,
+                attempted_source=source,
+                preferred_source=self._preferred_source,
+                preferred_artifacts=list(self._artifacts.values()),
+            )
+
+        self._artifacts[name] = ArtifactRecord(name=name, path=path, source=source)
+
+    def find(self, artifact_name: str, locations: Sequence[SearchLocation]) -> Optional[str]:
+        """Search for artifact respecting toolchain consistency.
+
+        Args:
+            artifact_name: Name of artifact to find.
+            locations: Search locations to try.
+
+        Returns:
+            Path to artifact, or None if not found.
+
+        Raises:
+            ToolchainMismatchError: If found in different source than preferred.
+        """
+        # Reorder to search preferred source first, maintaining original order for ties
+        # (stable sort: preferred source gets priority 0, others get priority 1)
+        if self._preferred_source:
+            ordered_locations = sorted(
+                locations,
+                key=lambda loc: 0 if loc.source == self._preferred_source else 1
+            )
+        else:
+            ordered_locations = list(locations)
+
+        # Try each location
+        for location in ordered_locations:
+            if path := search_location(location, artifact_name):
+                self.record(artifact_name, path, location.source)
+                return path
+
+        return None
+
+
+# Module-level default context
+_default_context = SearchContext()
+
+
+def get_default_context() -> SearchContext:
+    """Get the default module-level search context."""
+    return _default_context
+
+
+def reset_default_context() -> None:
+    """Reset the default context to a fresh state."""
+    global _default_context
+    _default_context = SearchContext()
diff --git a/cuda_pathfinder/tests/conftest.py b/cuda_pathfinder/tests/conftest.py
index 42cff8ac52..8b28416436 100644
--- a/cuda_pathfinder/tests/conftest.py
+++ b/cuda_pathfinder/tests/conftest.py
@@ -29,3 +29,13 @@ def _append(message):
         request.config.custom_info.append(f"{request.node.name}: {message}")
 
     return _append
+
+
+@pytest.fixture(autouse=True)
+def reset_search_context():
+    """Reset the default search context between tests."""
+    from cuda.pathfinder._utils.toolchain_tracker import reset_default_context
+
+    reset_default_context()
+    yield
+    reset_default_context()
diff --git a/cuda_pathfinder/tests/test_find_nvidia_binaries.py b/cuda_pathfinder/tests/test_find_nvidia_binaries.py
new file mode 100644
index 0000000000..f12ba9ee99
--- /dev/null
+++ b/cuda_pathfinder/tests/test_find_nvidia_binaries.py
@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+
+import pytest
+
+from cuda.pathfinder import find_nvidia_binary
+from cuda.pathfinder._binaries.supported_nvidia_binaries import SUPPORTED_BINARIES
+
+
+def test_unknown_binary():
+    with pytest.raises(RuntimeError, match=r"^UNKNOWN binary_name='unknown-binary'$"):
+        find_nvidia_binary("unknown-binary")
+
+
+@pytest.mark.parametrize("binary_name", SUPPORTED_BINARIES)
+def test_find_binaries(info_summary_append, binary_name):
+    binary_path = find_nvidia_binary(binary_name)
+    info_summary_append(f"{binary_path=!r}")
+    if binary_path:
+        assert os.path.isfile(binary_path)
+        # Verify the binary name is in the path
+        assert binary_name in os.path.basename(binary_path)
+
+
+def test_nvdisasm_specific(info_summary_append):
+    """Specific test for nvdisasm to ensure it's working."""
+    binary_path = find_nvidia_binary("nvdisasm")
+    info_summary_append(f"nvdisasm path: {binary_path!r}")
+    if binary_path:
+        assert os.path.isfile(binary_path)
+
+
+def test_cuobjdump_specific(info_summary_append):
+    """Specific test for cuobjdump to ensure it's working."""
+    binary_path = find_nvidia_binary("cuobjdump")
+    info_summary_append(f"cuobjdump path: {binary_path!r}")
+    if binary_path:
+        assert os.path.isfile(binary_path)
diff --git a/cuda_pathfinder/tests/test_find_nvidia_headers.py b/cuda_pathfinder/tests/test_find_nvidia_headers.py
index 494d7c0ae9..2c1f2b51d2 100644
--- a/cuda_pathfinder/tests/test_find_nvidia_headers.py
+++ b/cuda_pathfinder/tests/test_find_nvidia_headers.py
@@ -29,9 +29,6 @@
     SUPPORTED_SITE_PACKAGE_HEADER_DIRS_CTK,
 )
 
-STRICTNESS = os.environ.get("CUDA_PATHFINDER_TEST_FIND_NVIDIA_HEADERS_STRICTNESS", "see_what_works")
-assert STRICTNESS in ("see_what_works", "all_must_work")
-
 NON_CTK_IMPORTLIB_METADATA_DISTRIBUTIONS_NAMES = {
     "cusparseLt": r"^nvidia-cusparselt-.*$",
     "cutensor": r"^cutensor-.*$",
@@ -68,19 +65,6 @@ def test_find_non_ctk_headers(info_summary_append, libname):
         assert hdr_dir is not None
         hdr_dir_parts = hdr_dir.split(os.path.sep)
         assert "site-packages" in hdr_dir_parts
-    elif STRICTNESS == "all_must_work":
-        assert hdr_dir is not None
-        if conda_prefix := os.environ.get("CONDA_PREFIX"):
-            assert hdr_dir.startswith(conda_prefix)
-        else:
-            inst_dirs = SUPPORTED_INSTALL_DIRS_NON_CTK.get(libname)
-            if inst_dirs is not None:
-                for inst_dir in inst_dirs:
-                    globbed = glob.glob(inst_dir)
-                    if hdr_dir in globbed:
-                        break
-                else:
-                    raise RuntimeError(f"{hdr_dir=} does not match any {inst_dirs=}")
 
 
 def test_supported_headers_site_packages_ctk_consistency():
@@ -95,5 +79,3 @@ def test_find_ctk_headers(info_summary_append, libname):
         assert os.path.isdir(hdr_dir)
         h_filename = SUPPORTED_HEADERS_CTK[libname]
         assert os.path.isfile(os.path.join(hdr_dir, h_filename))
-    if STRICTNESS == "all_must_work":
-        assert hdr_dir is not None
diff --git a/cuda_pathfinder/tests/test_find_nvidia_static_libs.py b/cuda_pathfinder/tests/test_find_nvidia_static_libs.py
new file mode 100644
index 0000000000..98ba50bdaa
--- /dev/null
+++ b/cuda_pathfinder/tests/test_find_nvidia_static_libs.py
@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+
+import pytest
+
+from cuda.pathfinder import find_nvidia_static_lib
+from cuda.pathfinder._static_libs.supported_nvidia_static_libs import SUPPORTED_STATIC_LIBS
+
+
+def test_unknown_artifact():
+    with pytest.raises(RuntimeError, match=r"^UNKNOWN artifact_name='unknown-artifact'$"):
+        find_nvidia_static_lib("unknown-artifact")
+
+
+@pytest.mark.parametrize("artifact_name", SUPPORTED_STATIC_LIBS)
+def test_find_static_libs(info_summary_append, artifact_name):
+    artifact_path = find_nvidia_static_lib(artifact_name)
+    info_summary_append(f"{artifact_path=!r}")
+    if artifact_path:
+        assert os.path.isfile(artifact_path)
+        # Verify the artifact name (or its base) is in the path
+        base_name = artifact_name.replace(".10", "")  # Handle libdevice.10.bc -> libdevice
+        assert base_name.split(".")[0] in artifact_path.lower()
+
+
+def test_libdevice_specific(info_summary_append):
+    """Specific test for libdevice.10.bc to ensure it's working."""
+    artifact_path = find_nvidia_static_lib("libdevice.10.bc")
+    info_summary_append(f"libdevice.10.bc path: {artifact_path!r}")
+    if artifact_path:
+        assert os.path.isfile(artifact_path)
+        assert "libdevice" in artifact_path
+        # Should end with .bc
+        assert artifact_path.endswith(".bc")
+
+
+def test_libcudadevrt_specific(info_summary_append):
+    """Specific test for cudadevrt to ensure it's working."""
+    artifact_path = find_nvidia_static_lib("cudadevrt")
+    info_summary_append(f"cudadevrt path: {artifact_path!r}")
+    if artifact_path:
+        assert os.path.isfile(artifact_path)
+        # On Linux it should be .a, on Windows it might be .lib
+        assert artifact_path.endswith((".a", ".lib"))
+        assert "cudadevrt" in artifact_path.lower()
+
+
+def test_caching():
+    """Test that the find functions are properly cached."""
+    # Call twice and ensure we get the same object (due to functools.cache)
+    path1 = find_nvidia_static_lib("libdevice.10.bc")
+    path2 = find_nvidia_static_lib("libdevice.10.bc")
+    assert path1 is path2  # Should be the exact same object due to caching
diff --git a/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py b/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py
index cff5b74290..bcfe4aaaf1 100644
--- a/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py
+++ b/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py
@@ -15,9 +15,6 @@
 from cuda.pathfinder._dynamic_libs import supported_nvidia_libs
 from cuda.pathfinder._utils.platform_aware import IS_WINDOWS, quote_for_shell
 
-STRICTNESS = os.environ.get("CUDA_PATHFINDER_TEST_LOAD_NVIDIA_DYNAMIC_LIB_STRICTNESS", "see_what_works")
-assert STRICTNESS in ("see_what_works", "all_must_work")
-
 
 def test_supported_libnames_linux_sonames_consistency():
     assert tuple(sorted(supported_nvidia_libs.SUPPORTED_LIBNAMES_LINUX)) == tuple(
@@ -104,8 +101,6 @@ def raise_child_process_failed():
         raise_child_process_failed()
     assert not result.stderr
     if result.stdout.startswith("CHILD_LOAD_NVIDIA_DYNAMIC_LIB_HELPER_DYNAMIC_LIB_NOT_FOUND_ERROR:"):
-        if STRICTNESS == "all_must_work" and not _is_expected_load_nvidia_dynamic_lib_failure(libname):
-            raise_child_process_failed()
         info_summary_append(f"Not found: {libname=!r}")
     else:
         abs_path = json.loads(result.stdout.rstrip())
diff --git a/cuda_pathfinder/tests/test_toolchain_tracker.py b/cuda_pathfinder/tests/test_toolchain_tracker.py
new file mode 100644
index 0000000000..01600beb8c
--- /dev/null
+++ b/cuda_pathfinder/tests/test_toolchain_tracker.py
@@ -0,0 +1,145 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for toolchain consistency tracking."""
+
+import pytest
+
+from cuda.pathfinder._utils.toolchain_tracker import (
+    ArtifactRecord,
+    SearchContext,
+    SearchLocation,
+    ToolchainMismatchError,
+    ToolchainSource,
+    get_default_context,
+    reset_default_context,
+    search_location,
+)
+
+
+def test_context_initial_state():
+    """Test that a new context starts with no preferred source."""
+    ctx = SearchContext()
+    assert ctx.preferred_source is None
+
+
+def test_context_first_record_sets_preference():
+    """Test that first recorded artifact sets the preferred source."""
+    ctx = SearchContext()
+    ctx.record("nvcc", "/conda/bin/nvcc", ToolchainSource.CONDA)
+    assert ctx.preferred_source == ToolchainSource.CONDA
+
+
+def test_context_allows_same_source():
+    """Test that context allows multiple artifacts from same source."""
+    ctx = SearchContext()
+    ctx.record("nvcc", "/conda/bin/nvcc", ToolchainSource.CONDA)
+    ctx.record("nvdisasm", "/conda/bin/nvdisasm", ToolchainSource.CONDA)
+    assert ctx.preferred_source == ToolchainSource.CONDA
+
+
+def test_context_rejects_different_source():
+    """Test that context raises exception for mixed sources."""
+    ctx = SearchContext()
+    ctx.record("nvcc", "/conda/bin/nvcc", ToolchainSource.CONDA)
+
+    with pytest.raises(ToolchainMismatchError) as exc_info:
+        ctx.record("nvdisasm", "/cuda_home/bin/nvdisasm", ToolchainSource.CUDA_HOME)
+
+    assert exc_info.value.artifact_name == "nvdisasm"
+    assert exc_info.value.attempted_source == ToolchainSource.CUDA_HOME
+    assert exc_info.value.preferred_source == ToolchainSource.CONDA
+
+
+def test_find_prefers_established_source(tmp_path):
+    """Test that find searches preferred source first."""
+    ctx = SearchContext()
+
+    # Create test directories
+    conda_dir = tmp_path / "conda" / "bin"
+    conda_dir.mkdir(parents=True)
+    (conda_dir / "nvcc").touch()
+    (conda_dir / "nvdisasm").touch()  # Also add nvdisasm in conda
+
+    cuda_home_dir = tmp_path / "cuda_home" / "bin"
+    cuda_home_dir.mkdir(parents=True)
+    (cuda_home_dir / "nvcc").touch()
+
+    site_packages_dir = tmp_path / "site_packages" / "bin"
+    site_packages_dir.mkdir(parents=True)
+    (site_packages_dir / "nvdisasm").touch()
+
+    # Define locations
+    locations = [
+        SearchLocation(
+            source=ToolchainSource.SITE_PACKAGES,
+            base_dir_func=lambda: str(site_packages_dir.parent),
+            subdirs=["bin"],
+            filename_variants=lambda n: (n,),
+        ),
+        SearchLocation(
+            source=ToolchainSource.CONDA,
+            base_dir_func=lambda: str(conda_dir.parent),
+            subdirs=["bin"],
+            filename_variants=lambda n: (n,),
+        ),
+        SearchLocation(
+            source=ToolchainSource.CUDA_HOME,
+            base_dir_func=lambda: str(cuda_home_dir.parent),
+            subdirs=["bin"],
+            filename_variants=lambda n: (n,),
+        ),
+    ]
+
+    # First find establishes CONDA preference
+    result = ctx.find("nvcc", locations)
+    assert result == str(conda_dir / "nvcc")
+    assert ctx.preferred_source == ToolchainSource.CONDA
+
+    # Second find should prefer CONDA over SITE_PACKAGES (finds in conda)
+    result2 = ctx.find("nvdisasm", locations)
+    assert result2 == str(conda_dir / "nvdisasm")  # Should find in conda, not site_packages
+
+
+def test_search_location_basic(tmp_path):
+    """Test basic search_location functionality."""
+    # Create test directory
+    test_dir = tmp_path / "test" / "bin"
+    test_dir.mkdir(parents=True)
+    (test_dir / "nvcc").touch()
+
+    location = SearchLocation(
+        source=ToolchainSource.CONDA,
+        base_dir_func=lambda: str(test_dir.parent),
+        subdirs=["bin"],
+        filename_variants=lambda n: (n,),
+    )
+
+    result = search_location(location, "nvcc")
+    assert result == str(test_dir / "nvcc")
+
+
+def test_search_location_not_found(tmp_path):
+    """Test search_location returns None when file not found."""
+    location = SearchLocation(
+        source=ToolchainSource.CONDA,
+        base_dir_func=lambda: str(tmp_path),
+        subdirs=["bin"],
+        filename_variants=lambda n: (n,),
+    )
+
+    result = search_location(location, "nvcc")
+    assert result is None
+
+
+def test_reset_default_context():
+    """Test that reset creates a new default context."""
+    ctx1 = get_default_context()
+    ctx1.record("nvcc", "/conda/bin/nvcc", ToolchainSource.CONDA)
+
+    reset_default_context()
+
+    ctx2 = get_default_context()
+    assert ctx2.preferred_source is None
+    # Should be a fresh instance
+    assert len(ctx2._artifacts) == 0