@@ -159,6 +159,104 @@ jobs:
           ./cmake-out/executor_runner --model_path "./${model}.pte" --data_path "./aoti_cuda_blob.ptd"
         done
 
+  export-cuda-target-smem-cross-arch:
+    name: export-cuda-target-smem-cross-arch-a100
+    needs: [changed-files, run-decision]
+    if: |
+      contains(needs.changed-files.outputs.changed-files, 'backends/cuda') ||
+      contains(needs.changed-files.outputs.changed-files, 'backends/aoti') ||
+      contains(needs.changed-files.outputs.changed-files, '.github/workflows/cuda.yml') ||
+      needs.run-decision.outputs.is-full-run == 'true'
+    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
+    permissions:
+      id-token: write
+      contents: read
+    with:
+      timeout: 90
+      runner: mt-l-x86iavx512-11-125-a100
+      gpu-arch-type: cuda
+      gpu-arch-version: "13.0"
+      use-custom-docker-registry: false
+      submodules: recursive
+      upload-artifact: cuda-target-smem-cross-arch
+      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
+      script: |
+        set -eux
+
+        PYTHON_EXECUTABLE=python ./install_executorch.sh
+        export LD_LIBRARY_PATH="/opt/conda/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+        # A10G (sm_86) supports 99 KiB of opt-in shared memory per block.
+        export ET_CUDA_TARGET_SMEM_BYTES=101376
+        # The A100 exporter has an AVX-512 host CPU while the A10G runner has
+        # AVX2. Keep the generated AOTI host wrapper compatible with both.
+        export ATEN_CPU_CAPABILITY=avx2
+        export TORCHINDUCTOR_CPP_MARCH=x86-64-v3
+
+        python - <<'PY'
+        import torch
+
+        capability = torch.cuda.get_device_capability()
+        assert capability == (8, 0), f"Expected A100 sm_80 exporter, got {capability}"
+        PY
+
+        for model in linear sdpa; do
+          model_dir="${RUNNER_ARTIFACT_DIR}/${model}"
+          mkdir -p "${model_dir}"
+          python -m examples.cuda.scripts.export \
+            --model_name="${model}" \
+            --output_dir "${model_dir}"
+        done
+
+  test-cuda-target-smem-cross-arch:
+    name: test-cuda-target-smem-cross-arch-a10g
+    needs: [export-cuda-target-smem-cross-arch]
+    if: needs.export-cuda-target-smem-cross-arch.result == 'success'
+    uses: pytorch/test-infra/.github/workflows/linux_job_v3.yml@main
+    permissions:
+      id-token: write
+      contents: read
+    with:
+      timeout: 90
+      runner: mt-l-x86aavx2-29-113-a10g
+      gpu-arch-type: cuda
+      gpu-arch-version: "13.0"
+      use-custom-docker-registry: false
+      submodules: recursive
+      download-artifact: cuda-target-smem-cross-arch
+      ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
+      script: |
+        set -eux
+
+        PYTHON_EXECUTABLE=python ./install_executorch.sh
+        export LD_LIBRARY_PATH="/opt/conda/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+
+        python - <<'PY'
+        import torch
+
+        capability = torch.cuda.get_device_capability()
+        assert capability == (8, 6), f"Expected A10G sm_86 runner, got {capability}"
+        properties = torch.cuda.get_device_properties(0)
+        target = 101376
+        assert properties.shared_memory_per_block_optin >= target, (
+            properties.shared_memory_per_block_optin,
+            target,
+        )
+        PY
+
+        cmake -DCMAKE_BUILD_TYPE=Release \
+            -DEXECUTORCH_BUILD_CUDA=ON \
+            -DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON \
+            -DPYTHON_EXECUTABLE=python \
+            -Bcmake-out .
+        cmake --build cmake-out --target executor_runner -j4
+
+        for model in linear sdpa; do
+          model_dir="${RUNNER_ARTIFACT_DIR}/${model}"
+          ./cmake-out/executor_runner \
+            --model_path "${model_dir}/${model}.pte" \
+            --data_path "${model_dir}/aoti_cuda_blob.ptd"
+        done
+
   unittest-cuda:
     name: unittest-cuda
     needs: [changed-files, run-decision]
 
@@ -93,6 +93,7 @@ fbcode_target(
     name = "cuda_backend",
     srcs = [
         "cuda_backend.py",
+        "target_smem.py",
         "cuda_weight_collector.py",
     ],
     visibility = ["PUBLIC"],
 
@@ -30,6 +30,7 @@
 from executorch.backends.cuda.passes.replace_int64_floordiv import (
     ReplaceInt64FloorDivWithFloatPass,
 )
+from executorch.backends.cuda.target_smem import target_smem_context
 from executorch.backends.cuda.triton.replacement_pass import (
     ReplaceEdgeOpWithTritonOpPass,
 )
@@ -855,6 +856,7 @@ def get_extra_aoti_compile_context_manager(
         compilation for the CUDA backend. Each manager is documented at
         its own `enter_context` call site below.
 
+        The optional shared-memory target applies to every CUDA compilation.
         The low-memory export monkey-patch (CPU clones for mutated buffers)
         is gated on the ``low_memory_mode`` compile spec — only models that
         explicitly opt in (currently Qwen3.5 MoE) get it. Other models go
@@ -882,6 +884,7 @@ def _combined():
                 # `ReplaceEdgeOpWithTritonOpPass` are unaffected; this is
                 # only the fallback for the `triton_kernel_mode="OFF"` path.
                 stack.enter_context(torch.nn.attention.sdpa_kernel([SDPBackend.MATH]))
+                stack.enter_context(target_smem_context())
                 if low_memory_mode == "ON":
                     # Force AOTI's mutated-buffer clones onto CPU during
                     # compile so we stay under tight GPU memory caps (e.g.
 
@@ -0,0 +1,63 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Export-time CUDA shared-memory targeting for cross-architecture artifacts.
+
+This experiment-only helper is intentionally inactive unless
+``ET_CUDA_TARGET_SMEM_BYTES`` is set to a positive integer.
+"""
+
+import os
+from contextlib import contextmanager
+from typing import Iterator
+
+
+_TARGET_SMEM_ENV = "ET_CUDA_TARGET_SMEM_BYTES"
+
+
+def _target_smem_bytes() -> int | None:
+    raw = os.environ.get(_TARGET_SMEM_ENV)
+    if raw is None:
+        return None
+    try:
+        value = int(raw)
+    except ValueError as exc:
+        raise ValueError(f"{_TARGET_SMEM_ENV} must be an integer, got {raw!r}") from exc
+    if value <= 0:
+        raise ValueError(f"{_TARGET_SMEM_ENV} must be positive, got {value}")
+    return value
+
+
+@contextmanager
+def target_smem_context() -> Iterator[int | None]:
+    """Constrain generated CUDA kernels to a target dynamic-smem budget.
+
+    Triton kernels are checked after each candidate is compiled, using the
+    exact ``metadata.shared`` value while retaining the local GPU limit as an
+    upper bound.
+    """
+
+    target = _target_smem_bytes()
+    if target is None:
+        yield None
+        return
+
+    from triton.compiler import compiler as triton_compiler
+
+    original_max_shared_mem = triton_compiler.max_shared_mem
+
+    def target_max_shared_mem(device):
+        return min(int(original_max_shared_mem(device)), target)
+
+    triton_compiler.max_shared_mem = target_max_shared_mem
+    print(
+        f"CUDA export target shared-memory budget: {target} bytes "
+        "(exact Triton metadata filter)"
+    )
+    try:
+        yield target
+    finally:
+        triton_compiler.max_shared_mem = original_max_shared_mem
@@ -4,9 +4,12 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+import contextlib
+import os
 import unittest
 from typing import Tuple
 from unittest import mock
+from unittest.mock import patch
 
 import torch
 from executorch.backends.cuda.cuda_backend import CudaBackend
@@ -101,6 +104,35 @@ def test_invalid_autotune_at_compile_time_compile_spec(self):
                 [CompileSpec(key="autotune_at_compile_time", value=b"MAYBE")]
             )
 
+    def test_target_smem_context_is_applied(self):
+        with patch(
+            "executorch.backends.cuda.cuda_backend.target_smem_context",
+            return_value=contextlib.nullcontext(),
+        ) as target_smem_context:
+            with CudaBackend.get_extra_aoti_compile_context_manager([]):
+                pass
+
+        target_smem_context.assert_called_once_with()
+
+    def test_target_smem_context_only_patches_exact_triton_limit(self):
+        from executorch.backends.cuda.target_smem import target_smem_context
+        from torch._inductor.template_heuristics.triton import BaseConfigHeuristic
+        from triton.compiler import compiler as triton_compiler
+
+        original_checker = BaseConfigHeuristic._get_exceeding_shared_memory_checker
+        with mock.patch.dict(os.environ, {"ET_CUDA_TARGET_SMEM_BYTES": "4096"}):
+            with mock.patch.object(
+                triton_compiler, "max_shared_mem", return_value=8192
+            ) as local_max_shared_mem:
+                with target_smem_context():
+                    self.assertIs(
+                        BaseConfigHeuristic._get_exceeding_shared_memory_checker,
+                        original_checker,
+                    )
+                    self.assertEqual(triton_compiler.max_shared_mem(0), 4096)
+
+                self.assertIs(triton_compiler.max_shared_mem, local_max_shared_mem)
+
 
 class TestCudaExport(unittest.TestCase):
     """Test CUDA export functionality for various operations using to_edge_transform_and_lower."""