@@ -1594,6 +1594,10 @@ cdef class ExecutableMemcpyNode(ExecutableGraphNode):
             c_dst, c_src, size, &params.memcpy.copyParams,
             &dst_type, &src_type)
         # A destroyed node is reported by _set_executable_node_params below.
+        # The memory types are read from the definition node, not from the
+        # instantiated graph. That is correct only while MemcpyNode.update()
+        # keeps a unified operand unified, which it does; an executable update
+        # rejects a change of memory type.
         if node != NULL:
             with nogil:
                 HANDLE_RETURN(cydriver.cuGraphMemcpyNodeGetParams(
 
@@ -264,6 +264,10 @@ Fixes and enhancements
   addresses, and ``update`` rejected that descriptor with a message about
   multidimensional copies. Such an operand stays unified when it is replaced,
   because the driver does not accept a change of an operand's memory type in
-  an instantiated graph, so :meth:`~graph.Graph.update` applies the change as
-  well. The node's ``repr`` now shows ``U`` for unified operands.
+  an instantiated graph. Replacing a device operand with another device
+  buffer can therefore also be applied with :meth:`~graph.Graph.update`;
+  replacing it with host memory takes effect in a new instantiation only,
+  because the driver does not let an executable update move an operand to
+  another device or to the host. The node's ``repr`` now shows ``U`` for
+  unified operands.
   (`#2649 <https://github.com/NVIDIA/cuda-python/issues/2649>`__)
@@ -787,6 +787,7 @@ def test_memcpy_update_captured_node_size(init_cuda):
         pytest.skip("individual graph node updates require CUDA 12.2+")
 
     stream = init_cuda.create_stream()
+    # The builder is unused; it keeps the captured graph alive.
     builder, graph_def, node, dst, src = _capture_device_memcpy(init_cuda, stream)
     recorded = handle_return(driver.cuGraphMemcpyNodeGetParams(node.handle))
     assert node.size == 64
@@ -818,6 +819,7 @@ def test_memcpy_update_captured_node_operand(init_cuda, operand):
         pytest.skip("individual graph node updates require CUDA 12.2+")
 
     stream = init_cuda.create_stream()
+    # The builder is unused; it keeps the captured graph alive.
     builder, graph_def, node, dst, src = _capture_device_memcpy(init_cuda, stream)
     recorded = handle_return(driver.cuGraphMemcpyNodeGetParams(node.handle))
     instantiated_before = graph_def.instantiate()
@@ -863,6 +865,7 @@ def test_executable_memcpy_update_on_captured_node(init_cuda):
         pytest.skip("individual graph node updates require CUDA 12.2+")
 
     stream = init_cuda.create_stream()
+    # The builder is unused; it keeps the captured graph alive.
     builder, graph_def, node, dst, src = _capture_device_memcpy(init_cuda, stream)
     new_src = init_cuda.memory_resource.allocate(64, stream=stream)
     new_dst = init_cuda.memory_resource.allocate(64, stream=stream)
@@ -878,6 +881,39 @@ def test_executable_memcpy_update_on_captured_node(init_cuda):
     assert _read_device_bytes(dst, stream) == [0] * 64
 
 
+@pytest.mark.agent_authored(model="claude-fable-5-1")
+def test_memcpy_update_captured_node_host_operand(init_cuda):
+    """Replacing a captured node's device operand with host memory needs a new instantiation.
+
+    The definition node accepts the host buffer and a fresh instantiation
+    copies from it. An executable update does not: the driver does not let a
+    memcpy operand move to another device or to the host, so both
+    :meth:`Graph.update` and the executable view raise. This is a driver
+    restriction, not something cuda.core enforces.
+    """
+    if driver_version() < (12, 2, 0):
+        pytest.skip("individual graph node updates require CUDA 12.2+")
+
+    stream = init_cuda.create_stream()
+    # The builder is unused; it keeps the captured graph alive.
+    builder, graph_def, node, dst, src = _capture_device_memcpy(init_cuda, stream)
+    instantiated_before = graph_def.instantiate()
+    host_src = LegacyPinnedMemoryResource().allocate(64)
+    ctypes.memset(int(host_src.handle), 0xA5, 64)
+
+    node.update(src=host_src)
+    assert node.src == int(host_src.handle)
+
+    fresh = graph_def.instantiate()
+    fresh.launch(stream)
+    assert _read_device_bytes(dst, stream) == [0xA5] * 64
+
+    with pytest.raises(CUDAError, match="PARAMETERS_CHANGED"):
+        instantiated_before.update(graph_def)
+    with pytest.raises(CUDAError):
+        instantiated_before[node].update(dst=dst, src=host_src, size=64)
+
+
 @pytest.mark.agent_authored(model="gpt-5.6")
 def test_definition_node_update_changes_future_instantiations(
     definition_update_case,