@@ -33,6 +33,11 @@ quantize/dequantize ops. TorchAO int4 group-wise weights of `linear` and
 stored packed with their scheme in tensor metadata. Each method must lower wholly
 to one delegate; `to_native` raises otherwise.
 
+Immutable constant keys are namespaced as `<method>/<key>`, even for a single
+method. A key mutated by any method becomes `state/<key>` in every method, so
+methods share its runtime state. Method names may not be `state` or start with
+`state/`. `to_native` raises if namespaced keys collide.
+
 A `.ptn` is an uncompressed zip with fixed entry names:
 
 | Entry | Contents |
 
@@ -31,6 +31,7 @@
 from enum import IntEnum
 from typing import (
     Any,
+    Callable,
     cast,
     get_args,
     get_origin,
@@ -1487,39 +1488,48 @@ def _iter_graph_args(value: object) -> Iterator[GraphArg]:
             yield from _iter_graph_args(item)
 
 
-def collect_data_keys(program: Program) -> set[str]:
-    """Return every out-of-line data key the program references.
+def map_data_keys(method: Method, fn: Callable[[str], str]) -> None:
+    """Replace every out-of-line data key in ``method`` with ``fn(key)``, in place.
 
     Covers constant references (NamedTensorRef.data_key) plus the quant keys
     (AffineGroup scale and zero-point) carried on any TensorMeta.quant, whether
     it is attached to a constant or to a graph value (intermediates and I/O),
     recursing into HOP subgraphs wherever a schema field carries a ``GraphArg``.
     PackedQuant carries no external keys.
     """
-    keys: set[str] = set()
 
-    def add_meta(meta: Optional[TensorMeta]) -> None:
+    def map_meta(meta: Optional[TensorMeta]) -> None:
         if meta is None or meta.quant is None:
             return
         scheme = meta.quant.scheme
         if isinstance(scheme, AffineGroup):
-            keys.add(scheme.scale_data_key)
+            scheme.scale_data_key = fn(scheme.scale_data_key)
             if scheme.zero_point_data_key:
-                keys.add(scheme.zero_point_data_key)
+                scheme.zero_point_data_key = fn(scheme.zero_point_data_key)
 
     def visit_graph(graph: Graph) -> None:
         for value in graph.tensor_values or []:
-            add_meta(value.meta)
+            map_meta(value.meta)
         for node in graph.nodes:
             for graph_arg in _iter_graph_args(node):
                 visit_graph(graph_arg.graph)
 
-    for method in program.methods:
-        for constant in method.constants or []:
-            keys.add(constant.data_key)
-            add_meta(constant.meta)
-        visit_graph(method.graph)
+    for constant in method.constants or []:
+        constant.data_key = fn(constant.data_key)
+        map_meta(constant.meta)
+    visit_graph(method.graph)
 
+
+def collect_data_keys(program: Program) -> set[str]:
+    """Return every out-of-line data key the program references."""
+    keys: set[str] = set()
+
+    def add(key: str) -> str:
+        keys.add(key)
+        return key
+
+    for method in program.methods:
+        map_data_keys(method, add)
     return keys
 
 
 
@@ -38,20 +38,24 @@
 
 from executorch.backends.native.preprocess import NativeDelegateInfo
 from executorch.backends.native.serialization.graph_serialize import (
+    _compile_to_bytes,
     _same_tensor,
     collect_data_keys,
     deserialize_program,
+    map_data_keys,
     merge_programs,
     validate_program,
 )
-from executorch.backends.native.serialization.schema import Program
+from executorch.backends.native.serialization.schema import OutputKind, Program
 from executorch.exir._serialize._ptn import write_ptn
 from torch.utils import _pytree as pytree
 
 if TYPE_CHECKING:
     from torch.export import ExportedProgram
     from torch.fx import GraphModule
 
+_STATE_NAMESPACE = "state"
+
 
 class NativeProgramManager:
     """One or more methods lowered for the native runtime, ready to save.
@@ -255,13 +259,7 @@ def _delegate_info(lowered: object, method_name: str) -> NativeDelegateInfo:
 def _merge_constants(
     per_method: dict[str, dict[str, torch.Tensor]],
 ) -> dict[str, torch.Tensor]:
-    """Union per-method constants by fqn.
-
-    serialize_program treats an fqn as one buffer across every method, so hold to
-    that here rather than letting a later method silently clobber an earlier one.
-    _same_tensor short-circuits on identity and shared storage, which is the usual
-    case for a weight referenced by several methods.
-    """
+    """Merge constants by their final data keys, rejecting differing values."""
     merged: dict[str, torch.Tensor] = {}
     source: dict[str, str] = {}
     for method_name, constants in per_method.items():
@@ -347,6 +345,11 @@ def _normalize_programs(
             )
         if not method_name:
             raise ValueError("to_native: method names must be non-empty strings.")
+        if method_name.split("/")[0] == _STATE_NAMESPACE:
+            raise ValueError(
+                f"to_native: method name {method_name!r} is reserved; "
+                f"{_STATE_NAMESPACE!r} namespaces mutable state keys."
+            )
         if not isinstance(program, TorchExportedProgram):
             raise TypeError(
                 f"to_native: method {method_name!r} must map to an "
@@ -365,6 +368,11 @@ def to_native(
     ``programs`` is a single ``ExportedProgram`` (lowered as the sole ``forward``
     method) or a dict mapping method name to ``ExportedProgram``.
 
+    Immutable constant keys are namespaced as ``<method>/<key>``, including for a
+    single method. Keys mutated by any method become ``state/<key>`` in every
+    method, so state remains shared across methods. Equal immutable tensors
+    deduplicate on save.
+
     Nothing about lowering is configurable yet. The passes, the partitioner, and
     the edge compile config are all owned here, because correctness of the package
     depends on them. Exposing the compile config is worth reconsidering.
@@ -379,9 +387,10 @@ def to_native(
     Raises:
         TypeError: If ``programs`` is not an ``ExportedProgram`` or a method-name
             dictionary containing only ``ExportedProgram`` values.
-        ValueError: If the method dictionary is empty, a method name is empty, a
-            method does not fully delegate to the native backend, a constant
-            differs between methods, or a data key the graph references has no
+        ValueError: If the method dictionary is empty, a method name is empty or
+            in the reserved ``state`` namespace, a method does not fully delegate
+            to the native backend, a mutable constant differs between methods,
+            namespaced keys conflict, or a data key the graph references has no
             backing tensor.
     """
     method_programs = _normalize_programs(programs)
@@ -447,13 +456,44 @@ def to_native(
         method_blobs[method_name] = module.processed_bytes
         method_constants[method_name] = _delegate_info(module, method_name).constants
 
-    ptg_blob = merge_programs(method_blobs)
-    constants = _merge_constants(method_constants)
+    program = deserialize_program(merge_programs(method_blobs))
+    state_keys = _mutable_data_keys(program) | {
+        buffer.fqn
+        for method in program.methods
+        for buffer in method.mutable_buffers or []
+    }
+    state = {key: f"{_STATE_NAMESPACE}/{key}" for key in state_keys}
+    data_keys = set(state.values())
+    for method in program.methods:
+        constants_for_method = method_constants[method.name]
+        namespaced = {
+            key: f"{method.name}/{key}"
+            for key in constants_for_method
+            if key not in state
+        }
+        conflicts = set(namespaced.values()) & data_keys
+        if conflicts:
+            raise ValueError(
+                "to_native: namespaced constant keys already exist: "
+                f"{sorted(conflicts)}"
+            )
+        data_keys.update(namespaced.values())
+        mapping = state | namespaced
+        map_data_keys(method, lambda key, mapping=mapping: mapping.get(key, key))
+        for buffer in method.mutable_buffers or []:
+            buffer.fqn = state[buffer.fqn]
+        for spec in method.output_specs or []:
+            if spec.kind == OutputKind.BUFFER_MUTATION and spec.target is not None:
+                spec.target = state.get(spec.target, spec.target)
+        method_constants[method.name] = {
+            mapping.get(key, key): tensor
+            for key, tensor in constants_for_method.items()
+        }
 
-    program = deserialize_program(ptg_blob)
+    constants = _merge_constants(method_constants)
     _validate_merged_program(program, constants)
 
-    return NativeProgramManager(ptg=ptg_blob, constants=constants)
+    return NativeProgramManager(ptg=_compile_to_bytes(program), constants=constants)
 
 
 __all__ = ["NativeProgramManager", "to_native"]