@@ -77,13 +77,16 @@ fbcode_target(
     srcs = [
         "passes/__init__.py",
         "passes/move_cond_predicate_to_cpu.py",
+        "passes/lower_offgraph_kv.py",
         "passes/replace_int64_floordiv.py",
     ],
     visibility = [
         "//executorch/backends/cuda/...",
     ],
     deps = [
+        ":triton_kernels",
         "//caffe2:torch",
+        "//executorch/backends/transforms:utils",
         "//executorch/exir/dialects:lib",
     ],
 )
 
@@ -24,6 +24,11 @@
     CudaWeightCollector,
     trim_host_memory,
 )
+from executorch.backends.cuda.passes.lower_offgraph_kv import (
+    LowerOffGraphKVPass,
+    OFFGRAPH_KV_COMPILE_SPEC,
+    parse_offgraph_kv_manifest,
+)
 from executorch.backends.cuda.passes.move_cond_predicate_to_cpu import (
     MoveCondPredicateToCpuPass,
 )
@@ -777,6 +782,11 @@ def get_custom_passes(cls, compile_specs: List[CompileSpec]) -> List[typing.Any]
                     )
                 triton_kernel_mode = mode
         passes = [MoveCondPredicateToCpuPass(), ReplaceInt64FloorDivWithFloatPass()]
+        for spec in compile_specs:
+            if spec.key == OFFGRAPH_KV_COMPILE_SPEC:
+                passes.append(
+                    LowerOffGraphKVPass(parse_offgraph_kv_manifest(spec.value))
+                )
         if triton_kernel_mode == "ON":
             passes.append(ReplaceEdgeOpWithTritonOpPass())
         return passes
 
@@ -16,6 +16,7 @@
 from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple
 
 import torch
+from executorch.backends.cuda.passes.lower_offgraph_kv import OFFGRAPH_KV_FQN_PREFIX
 from executorch.exir._serialize._cord import FileBackedData
 from executorch.exir._serialize._named_data_store import NamedDataStore
 from executorch.exir.backend.backend_details import PreprocessResult
@@ -111,6 +112,42 @@ def write_chunk(output, chunk) -> None:
     return digest.digest()
 
 
+def _materialize_storage(tensor: torch.Tensor, directory: str) -> FileBackedData:
+    fd, storage_path = tempfile.mkstemp(
+        prefix=".cuda_weight_", suffix=".storage", dir=directory
+    )
+    os.close(fd)
+    try:
+        digest = _write_tensor_storage(tensor, storage_path)
+        return FileBackedData.move_from(storage_path, sha256=digest)
+    except Exception:
+        with contextlib.suppress(OSError):
+            os.remove(storage_path)
+        raise
+
+
+def _required_view_nbytes(
+    fqn: str,
+    sizes: Tuple[int, ...],
+    strides: Tuple[int, ...],
+    storage_offset: int,
+    element_size: int,
+) -> int:
+    if (
+        len(sizes) != len(strides)
+        or storage_offset < 0
+        or any(size < 0 for size in sizes)
+        or any(stride < 0 for stride in strides)
+    ):
+        raise RuntimeError(f"AOTI view {fqn!r} has invalid tensor metadata")
+    if any(size == 0 for size in sizes):
+        return 0
+    last_element = storage_offset + sum(
+        stride * (size - 1) for size, stride in zip(sizes, strides)
+    )
+    return (last_element + 1) * element_size
+
+
 def _storage_key(
     fqn: str, device_type: int, aoti_library_key: Optional[str] = None
 ) -> str:
@@ -132,6 +169,10 @@ def _is_aoti_library_local_fqn(fqn: str) -> bool:
     return fqn.startswith("_tensor_constant")
 
 
+def _is_offgraph_kv_fqn(fqn: str) -> bool:
+    return fqn.startswith(OFFGRAPH_KV_FQN_PREFIX)
+
+
 def _validate_cuda_aoti_variant(
     variant: CudaAotiVariant, has_fallback: bool, regular_sms: set[int]
 ) -> None:
@@ -362,34 +403,23 @@ def materialize(
             storage_nbytes = storage.nbytes()
             del storage
             device_type = device_type_for_weight(tensor)
+            is_offgraph_kv = _is_offgraph_kv_fqn(fqn)
             expected_storage_nbytes = int(
                 getattr(properties, "storage_size", None) or 0
             )
-            if storage_nbytes < expected_storage_nbytes:
+            if not is_offgraph_kv and storage_nbytes < expected_storage_nbytes:
                 raise RuntimeError(
                     "AOTI cloned storage is smaller than its TensorProperties "
                     f"({storage_nbytes} < {expected_storage_nbytes} bytes)"
                 )
 
-            fd, storage_path = tempfile.mkstemp(
-                prefix=".cuda_weight_", suffix=".storage", dir=directory
-            )
-            os.close(fd)
-            try:
-                digest = _write_tensor_storage(tensor, storage_path)
-                data = FileBackedData.move_from(storage_path, sha256=digest)
-            except Exception:
-                try:
-                    os.remove(storage_path)
-                except OSError:
-                    pass
-                raise
-
             storage_key = _storage_key(fqn, device_type)
-            if storage_key in storages:
-                data.close()
-                raise RuntimeError(f"Duplicate CUDA FQN weight key for {fqn!r}")
-            storages[storage_key] = data
+            if not is_offgraph_kv:
+                data = _materialize_storage(tensor, directory)
+                if storage_key in storages:
+                    data.close()
+                    raise RuntimeError(f"Duplicate CUDA FQN weight key for {fqn!r}")
+                storages[storage_key] = data
 
             sizes = tuple(
                 int(size) for size in getattr(properties, "shape", tensor.shape)
@@ -398,24 +428,19 @@ def materialize(
                 int(stride) for stride in getattr(properties, "stride", tensor.stride())
             )
             storage_offset = int(getattr(properties, "offset", tensor.storage_offset()))
-            if (
-                len(sizes) != len(strides)
-                or storage_offset < 0
-                or any(size < 0 for size in sizes)
-                or any(stride < 0 for stride in strides)
-            ):
-                raise RuntimeError(f"AOTI view {fqn!r} has invalid tensor metadata")
-            required_nbytes = 0
-            if all(size != 0 for size in sizes):
-                last_element = storage_offset + sum(
-                    stride * (size - 1) for size, stride in zip(sizes, strides)
-                )
-                required_nbytes = (last_element + 1) * tensor.element_size()
-            if required_nbytes > storage_nbytes:
+            required_nbytes = _required_view_nbytes(
+                fqn, sizes, strides, storage_offset, tensor.element_size()
+            )
+            if not is_offgraph_kv and required_nbytes > storage_nbytes:
                 raise RuntimeError(
                     f"AOTI view {fqn!r} requires {required_nbytes} bytes from a "
                     f"{storage_nbytes}-byte cloned storage"
                 )
+            if is_offgraph_kv:
+                # Preserve the AOTI view contract; the runtime supplies storage.
+                storage_nbytes = max(
+                    storage_nbytes, expected_storage_nbytes, required_nbytes
+                )
             entries.append(
                 CudaWeightEntry(
                     fqn=fqn,
@@ -500,21 +525,24 @@ def add_preprocess_result(
         self._merge_aoti_data(
             parent_store,
             compatibility_blob_key,
-            keep_compatibility_blob=not artifact.storages,
+            keep_compatibility_blob=not artifact.entries,
         )
 
         external_tag = f"aoti_{device_name}_blob"
         serialized_entries = []
         for entry in artifact.entries:
-            data = artifact.storages[entry.storage_key]
+            data = artifact.storages.get(entry.storage_key)
             if _is_aoti_library_local_fqn(entry.fqn):
                 entry = replace(
                     entry,
                     storage_key=_storage_key(
                         entry.fqn, entry.device_type, aoti_library_key=so_blob_key
                     ),
                 )
-            self._add_weight(entry, data, external_tag)
+            if data is not None:
+                self._add_weight(entry, data, external_tag)
+            elif not _is_offgraph_kv_fqn(entry.fqn):
+                raise RuntimeError(f"Missing CUDA FQN weight storage for {entry.fqn!r}")
             serialized_entries.append(entry)
 
         result.processed_bytes = encode_cuda_aoti_metadata(