@@ -78,6 +78,7 @@ def export_and_lower(
     backend: str = "cuda",
     sample: bool = True,
     use_turboquant: bool = False,
+    use_offgraph_kv_cache: bool = False,
     activation_dtype: torch.dtype = torch.bfloat16,
     max_prefill_chunk: int = 512,
     vision_model: nn.Module | None = None,
@@ -92,12 +93,20 @@ def export_and_lower(
             output_dir,
             sample=sample,
             use_turboquant=use_turboquant,
+            use_offgraph_kv_cache=use_offgraph_kv_cache,
             vision_model=vision_model,
             pos_embed_table=pos_embed_table,
             max_vision_patches=max_vision_patches,
             vision_fp32_mm=vision_fp32_mm,
         )
     elif backend == "mlx":
+        # The off-graph cache is lowered by the CUDA backend only, and dropping
+        # the flag silently would hand back an in-graph model that looks like
+        # what was asked for.
+        if use_offgraph_kv_cache:
+            raise ValueError(
+                "--use-offgraph-kv-cache is not supported by the mlx backend"
+            )
         _export_mlx(
             model,
             config,
@@ -119,7 +128,7 @@ def _solo_constant_methods(
     config: MuseGlimmerConfig,
     max_prefill: int,
     activation_dtype: torch.dtype,
-    mutable_buffer_metadata: str,
+    mutable_buffer_metadata: str | None,
     has_vision: bool,
     max_vision_patches: int,
 ) -> dict[str, object]:
@@ -136,12 +145,13 @@ def _solo_constant_methods(
         "get_vocab_size": config.vocab_size,
         "get_max_prefill_chunk": max_prefill,
         "get_activation_dtype": common.activation_dtype_tag(activation_dtype),
-        "get_mutable_buffer_metadata": mutable_buffer_metadata,
         "use_kv_cache": True,
         "use_sdpa_with_kv_cache": False,
         "enable_dynamic_shape": True,
         "has_vision_encoder": bool(has_vision),
     }
+    if mutable_buffer_metadata is not None:
+        constant_methods["get_mutable_buffer_metadata"] = mutable_buffer_metadata
     if has_vision:
         constant_methods["get_vision_hidden_size"] = config.dim
         constant_methods["get_max_vision_patches"] = int(max_vision_patches)
@@ -154,6 +164,7 @@ def _export_cuda(
     output_dir: str,
     sample: bool = True,
     use_turboquant: bool = False,
+    use_offgraph_kv_cache: bool = False,
     vision_model: nn.Module | None = None,
     pos_embed_table: torch.Tensor | None = None,
     max_vision_patches: int = 16384,
@@ -162,6 +173,9 @@ def _export_cuda(
     import torch._inductor.config as inductor_config
     from executorch.backends.cuda.cuda_backend import CudaBackend
     from executorch.backends.cuda.cuda_partitioner import CudaPartitioner
+    from executorch.backends.cuda.passes.lower_offgraph_kv import (
+        OFFGRAPH_KV_STEP_WIDTH_COMPILE_SPEC,
+    )
     from executorch.exir import (
         EdgeCompileConfig,
         ExecutorchBackendConfig,
@@ -191,17 +205,31 @@ def _export_cuda(
     from executorch.examples.models.muse_glimmer.source_transformations.cuda import (
         add_on_device_sampler,
         cuda_source_transformations,
+        enable_offgraph_kv_cache,
+        offgraph_kv_cache_geometry,
         vision_cuda_source_transformations,
     )
 
     # Always applied: bounds global-attention SDPA to the valid context via a
     # runtime kv_len (O(context) decode). With use_turboquant=True it also swaps
     # the global KV caches for TurboQuant TQ4.
-    cuda_source_transformations(model, use_turboquant=use_turboquant)
+    if use_offgraph_kv_cache and use_turboquant:
+        raise ValueError("off-graph KV cache and TurboQuant are mutually exclusive")
 
-    # Max prefill chunk must fit in the ring buffer (2 * sliding_window)
+    # A prefill chunk is one write step, so the ring must hold the union of the
+    # step's per-query windows. enable_offgraph_kv_cache sizes it from this.
     max_prefill = min(config.max_seq_len - 1, model._sliding_window * 2)
 
+    offgraph_manifest = None
+    offgraph_geometry = {}
+    if use_offgraph_kv_cache:
+        offgraph_manifest = enable_offgraph_kv_cache(model, max_prefill)
+        # Read the geometry while the model is alive; it is freed before the
+        # constant methods are assembled.
+        offgraph_geometry = offgraph_kv_cache_geometry(model)
+    else:
+        cuda_source_transformations(model, use_turboquant=use_turboquant)
+
     has_vision = vision_model is not None
     programs: dict[str, "torch.export.ExportedProgram"] = {}
 
@@ -267,20 +295,31 @@ def _export_cuda(
             vision_model, pos_embed_table, max_vision_patches
         )
 
-    mutable_buffer_metadata = common.mutable_buffer_metadata(model)
-    del model
-    if has_vision:
-        del vision_model
+    mutable_buffer_metadata = (
+        None if offgraph_manifest else common.mutable_buffer_metadata(model)
+    )
+    del model, vision_model
     gc.collect()
     torch.cuda.empty_cache()
 
     def _partitioner_for(name: str) -> "CudaPartitioner":
-        return CudaPartitioner(
-            [
-                CudaBackend.generate_method_name_compile_spec(name),
-                CompileSpec("low_memory_mode", b"ON"),
-            ]
-        )
+        compile_specs = [
+            CudaBackend.generate_method_name_compile_spec(name),
+            CompileSpec("low_memory_mode", b"ON"),
+        ]
+        if offgraph_manifest is not None:
+            compile_specs.extend(
+                (
+                    CompileSpec("offgraph_kv_manifest", offgraph_manifest.encode()),
+                    # Where the delegate reads this step's token count, as
+                    # "input_index:dim". Lowering compiles the cache op away, so
+                    # the runtime cannot recover the width from the graph; every
+                    # method here takes input_pos second, shaped [T].
+                    CompileSpec(OFFGRAPH_KV_STEP_WIDTH_COMPILE_SPEC, b"1:0"),
+                    CompileSpec("autotune_at_compile_time", b"OFF"),
+                )
+            )
+        return CudaPartitioner(compile_specs)
 
     constant_methods = _solo_constant_methods(
         config=config,
@@ -292,6 +331,13 @@ def _partitioner_for(name: str) -> "CudaPartitioner":
     )
     constant_methods["get_min_prefill_chunk"] = _CUDA_MIN_PREFILL_CHUNK
     constant_methods["use_sampling"] = sample
+    if offgraph_manifest is not None:
+        # The manifest is a compile spec (the lowering pass needs geometry at
+        # partition time). The runtime instead reads the neutral cache-geometry
+        # constant methods, the same ones the MLX off-graph path publishes.
+        # Sizing already travels as get_max_seq_len (context) and
+        # get_max_prefill_chunk (largest step); only the geometry is new.
+        constant_methods.update(offgraph_geometry)
 
     print(
         f"Lowering {len(programs)} methods to ExecuTorch (CUDA): "
@@ -570,6 +616,11 @@ def main() -> None:
         action="store_true",
         help="Use TurboQuant TQ4 KV cache on global (NoPE) layers (CUDA).",
     )
+    parser.add_argument(
+        "--use-offgraph-kv-cache",
+        action="store_true",
+        help="Allocate CUDA KV cache at runtime instead of storing it in the PTE/PTD.",
+    )
     parser.add_argument(
         "--activation-dtype",
         default=None,
@@ -623,6 +674,10 @@ def main() -> None:
         parser.error("--activation-dtype is only supported with --backend mlx.")
     if args.backend != "mlx" and args.max_prefill_chunk != 512:
         parser.error("--max-prefill-chunk is only supported with --backend mlx.")
+    if args.use_offgraph_kv_cache and args.backend != "cuda":
+        parser.error("--use-offgraph-kv-cache requires --backend cuda.")
+    if args.use_offgraph_kv_cache and args.turboquant:
+        parser.error("--use-offgraph-kv-cache cannot be combined with --turboquant.")
     if args.gguf:
         from executorch.examples.models.muse_glimmer.loaders.checkpoint_loader import (
             load_gguf_model,
@@ -679,6 +734,7 @@ def main() -> None:
         backend=args.backend,
         sample=not args.logits,
         use_turboquant=args.turboquant,
+        use_offgraph_kv_cache=args.use_offgraph_kv_cache,
         activation_dtype=activation_dtype,
         max_prefill_chunk=args.max_prefill_chunk,
         vision_model=vision_model,
 
@@ -12,13 +12,15 @@
 
 from __future__ import annotations
 
+import json
 import types
 
 # Register the length-aware global-attention operator.
 import executorch.backends.cuda.triton.kernels.sdpa  # noqa: F401
 
 # Register the TurboQuant attention operator.
 import executorch.backends.cuda.triton.kernels.tq4_sdpa  # noqa: F401
+import executorch.extension.llm.cache.update_and_attend  # noqa: F401
 
 import torch
 import torch.nn as nn
@@ -30,11 +32,16 @@
     build_dflash_swa_mask,
     rotate_half,
 )
-from executorch.examples.models.muse_glimmer.model.model import FlatKVCache, RingKVCache
+from executorch.examples.models.muse_glimmer.model.model import (
+    apply_rotary_emb,
+    FlatKVCache,
+    RingKVCache,
+)
 from executorch.examples.models.muse_glimmer.source_transformations.sampler import (
     sample,
 )
-from executorch.extension.llm.modules.turboquant import TurboQuantKVCache
+
+from executorch.extension.llm.export.model_metadata import write_cache_geometry
 from torch.library import triton_op, wrap_triton
 
 
@@ -564,6 +571,99 @@ def _lenaware_attention_forward(
     return self.o_proj(y)
 
 
+def _offgraph_attention_forward(
+    self,
+    x: torch.Tensor,
+    input_pos: torch.Tensor,
+    attn_mask: torch.Tensor,
+) -> torch.Tensor:
+    B, T, _ = x.shape
+    h = self.qkv_proj_norm(x)
+    xq, xk, xv, og = _project_qkvo(self, h)
+    xq = xq.view(B, T, self.n_heads, self.head_dim)
+    xk = xk.view(B, T, self.n_kv_heads, self.head_dim)
+    xv = xv.view(B, T, self.n_kv_heads, self.head_dim)
+
+    if self.q_norm is not None:
+        xq = self.q_norm(xq)
+        xk = self.k_norm(xk)
+
+    xq = xq.transpose(1, 2)
+    xk = xk.transpose(1, 2)
+    xv = xv.transpose(1, 2)
+    if self.use_rope:
+        freqs = torch.outer(input_pos.float(), self.inv_freq)
+        cos = torch.cos(freqs).unsqueeze(0).unsqueeze(0)
+        sin = torch.sin(freqs).unsqueeze(0).unsqueeze(0)
+        xq, xk = apply_rotary_emb(xq, xk, cos, sin)
+
+    # The neutral op takes per-token positions as [q_len, n_dims].
+    y = torch.ops.kvcache.update_and_attend(
+        xq,
+        xk,
+        xv,
+        input_pos.reshape(-1, 1),
+        self.layer_idx,
+        self.attn_scale,
+        xq.dtype,
+    )
+    y = y.transpose(1, 2).contiguous()
+    if self.use_o_gate and og is not None:
+        og = og.view(B, T, self.n_heads, self.head_dim)
+        y = torch.sigmoid(og) * y
+    return self.o_proj(y.reshape(B, T, -1))
+
+
+def enable_offgraph_kv_cache(model: nn.Module, max_write: int) -> str:
+    """Replace graph-owned caches and return the CUDA lowering manifest.
+
+    ``max_write`` is the largest number of tokens one forward writes, which is
+    what a ring layer sizes its slots from.
+    """
+    layers = []
+    for layer in model.layers:
+        attn = layer.self_attn
+        # Only what the graph cannot express: head counts, head dim and dtype
+        # are read off the step's K tensor by the lowering pass.
+        layers.append(
+            {
+                "layer_id": attn.layer_idx,
+                "policy": "ring" if attn.is_sliding else "flat",
+                "window": attn.window_size if attn.is_sliding else 0,
+            }
+        )
+        del attn.kv_cache
+        attn.forward = types.MethodType(_offgraph_attention_forward, attn)
+
+    return json.dumps(
+        {
+            "version": 1,
+            "maximum_capacity": model.config.max_seq_len,
+            "max_write": max_write,
+            "layers": layers,
+        },
+        sort_keys=True,
+        separators=(",", ":"),
+    )
+
+
+def offgraph_kv_cache_geometry(model: nn.Module) -> dict[str, object]:
+    """Neutral cache-geometry constant methods for the off-graph runtime.
+
+    The runtime reads these through read_cache_geometry() rather than parsing
+    the lowering manifest, so CUDA and MLX describe a cache the same way.
+    """
+    kv_heads = []
+    head_dims = []
+    windows = []
+    for layer in model.layers:
+        attn = layer.self_attn
+        kv_heads.append(attn.n_kv_heads)
+        head_dims.append(attn.head_dim)
+        windows.append(attn.window_size if attn.is_sliding else 0)
+    return write_cache_geometry(kv_heads, head_dims, windows)
+
+
 def cuda_source_transformations(
     model: nn.Module,
     *,
@@ -605,6 +705,8 @@ def cuda_source_transformations(
         return
 
     config = model.config
+    from executorch.extension.llm.modules.turboquant import TurboQuantKVCache
+
     n_swapped = 0
     for layer in model.layers:
         attn = layer.self_attn