diff --git a/compiler/src/iree/compiler/ConstEval/Runtime.cpp b/compiler/src/iree/compiler/ConstEval/Runtime.cpp
index d14198a..7ba471a 100644
--- a/compiler/src/iree/compiler/ConstEval/Runtime.cpp
+++ b/compiler/src/iree/compiler/ConstEval/Runtime.cpp
@@ -145,7 +145,8 @@
                                     << " got " << iree_vm_list_size(outputs);
             }
             iree_vm_variant_t variant = iree_vm_variant_empty();
-            IREE_CHECK_OK(iree_vm_list_get_variant(outputs, 0, &variant));
+            IREE_CHECK_OK(
+                iree_vm_list_get_variant_assign(outputs, 0, &variant));
             result = convertVariantToAttribute(loc, variant);
             return success(result != nullptr);
           }))) {
diff --git a/experimental/web/sample_dynamic/main.c b/experimental/web/sample_dynamic/main.c
index 17bb4be..8f75a40 100644
--- a/experimental/web/sample_dynamic/main.c
+++ b/experimental/web/sample_dynamic/main.c
@@ -283,8 +283,9 @@
   iree_vm_list_t* variants_list = iree_runtime_call_outputs(call);
   for (iree_host_size_t i = 0; i < iree_vm_list_size(variants_list); ++i) {
     iree_vm_variant_t variant = iree_vm_variant_empty();
-    IREE_RETURN_IF_ERROR(iree_vm_list_get_variant(variants_list, i, &variant),
-                         "variant %" PRIhsz " not present", i);
+    IREE_RETURN_IF_ERROR(
+        iree_vm_list_get_variant_assign(variants_list, i, &variant),
+        "variant %" PRIhsz " not present", i);
 
     if (iree_vm_variant_is_value(variant)) {
       switch (variant.type.value_type) {
diff --git a/runtime/bindings/python/vm.cc b/runtime/bindings/python/vm.cc
index 41e979b..70e5f53 100644
--- a/runtime/bindings/python/vm.cc
+++ b/runtime/bindings/python/vm.cc
@@ -255,7 +255,7 @@
 
 py::object VmVariantList::GetVariant(int index) {
   iree_vm_variant_t v = iree_vm_variant_empty();
-  CheckApiStatus(iree_vm_list_get_variant(raw_ptr(), index, &v),
+  CheckApiStatus(iree_vm_list_get_variant_assign(raw_ptr(), index, &v),
                  "Could not access list element");
   if (iree_vm_type_def_is_value(&v.type)) {
     // Convert a value type.
@@ -288,7 +288,7 @@
 
 py::object VmVariantList::GetAsSerializedTraceValue(int index) {
   iree_vm_variant_t v = iree_vm_variant_empty();
-  CheckApiStatus(iree_vm_list_get_variant(raw_ptr(), index, &v),
+  CheckApiStatus(iree_vm_list_get_variant_assign(raw_ptr(), index, &v),
                  "Could not access list element");
   if (iree_vm_type_def_is_value(&v.type)) {
     // Convert a value type.
@@ -398,7 +398,7 @@
 
 py::object VmVariantList::GetAsRef(int index) {
   iree_vm_variant_t v = iree_vm_variant_empty();
-  CheckApiStatus(iree_vm_list_get_variant(raw_ptr(), index, &v),
+  CheckApiStatus(iree_vm_list_get_variant_assign(raw_ptr(), index, &v),
                  "Could not access list element");
   if (!iree_vm_variant_is_ref(v)) {
     throw std::invalid_argument("list element is not a ref");
@@ -432,7 +432,7 @@
                         std::unordered_set<iree_vm_list_t*>& visited) {
   for (iree_host_size_t i = 0, e = iree_vm_list_size(list); i < e; ++i) {
     iree_vm_variant_t variant = iree_vm_variant_empty();
-    iree_status_t status = iree_vm_list_get_variant(list, i, &variant);
+    iree_status_t status = iree_vm_list_get_variant_assign(list, i, &variant);
     if (!iree_status_is_ok(status)) {
       iree_status_ignore(status);
       out.append("Error");
diff --git a/runtime/src/iree/tooling/comparison.cc b/runtime/src/iree/tooling/comparison.cc
index 7cc3c76..b01e3c9 100644
--- a/runtime/src/iree/tooling/comparison.cc
+++ b/runtime/src/iree/tooling/comparison.cc
@@ -244,9 +244,10 @@
   for (iree_host_size_t i = 0; i < iree_vm_list_size(expected_list); ++i) {
     iree_vm_variant_t expected_variant = iree_vm_variant_empty();
     IREE_CHECK_OK(
-        iree_vm_list_get_variant(expected_list, i, &expected_variant));
+        iree_vm_list_get_variant_assign(expected_list, i, &expected_variant));
     iree_vm_variant_t actual_variant = iree_vm_variant_empty();
-    IREE_CHECK_OK(iree_vm_list_get_variant(actual_list, i, &actual_variant));
+    IREE_CHECK_OK(
+        iree_vm_list_get_variant_assign(actual_list, i, &actual_variant));
     bool did_match = iree_tooling_compare_variants(
         (int)i, expected_variant, actual_variant, host_allocator,
         /*max_element_count=*/1024, builder);
diff --git a/runtime/src/iree/tooling/trace_replay.c b/runtime/src/iree/tooling/trace_replay.c
index 67760a1..64fe7a3 100644
--- a/runtime/src/iree/tooling/trace_replay.c
+++ b/runtime/src/iree/tooling/trace_replay.c
@@ -387,7 +387,7 @@
     iree_vm_variant_t variant = iree_vm_variant_empty();
     variant.type.value_type = IREE_VM_VALUE_TYPE_I8;
     variant.i8 = (int8_t)value;
-    return iree_vm_list_push_variant(target_list, &variant);
+    return iree_vm_list_push_variant_move(target_list, &variant);
   }
   IREE_RETURN_IF_ERROR(iree_yaml_mapping_try_find(document, value_node,
                                                   IREE_SV("i16"), &data_node));
@@ -402,7 +402,7 @@
     iree_vm_variant_t variant = iree_vm_variant_empty();
     variant.type.value_type = IREE_VM_VALUE_TYPE_I16;
     variant.i16 = (int16_t)value;
-    return iree_vm_list_push_variant(target_list, &variant);
+    return iree_vm_list_push_variant_move(target_list, &variant);
   }
   IREE_RETURN_IF_ERROR(iree_yaml_mapping_try_find(document, value_node,
                                                   IREE_SV("i32"), &data_node));
@@ -415,7 +415,7 @@
           IREE_STATUS_INVALID_ARGUMENT, "failed to parse i32 value: '%.*s'",
           (int)data_node->data.scalar.length, data_node->data.scalar.value);
     }
-    return iree_vm_list_push_variant(target_list, &variant);
+    return iree_vm_list_push_variant_move(target_list, &variant);
   }
   IREE_RETURN_IF_ERROR(iree_yaml_mapping_try_find(document, value_node,
                                                   IREE_SV("i64"), &data_node));
@@ -428,7 +428,7 @@
           IREE_STATUS_INVALID_ARGUMENT, "failed to parse i64 value: '%.*s'",
           (int)data_node->data.scalar.length, data_node->data.scalar.value);
     }
-    return iree_vm_list_push_variant(target_list, &variant);
+    return iree_vm_list_push_variant_move(target_list, &variant);
   }
   IREE_RETURN_IF_ERROR(iree_yaml_mapping_try_find(document, value_node,
                                                   IREE_SV("f32"), &data_node));
@@ -441,7 +441,7 @@
           IREE_STATUS_INVALID_ARGUMENT, "failed to parse f32 value: '%.*s'",
           (int)data_node->data.scalar.length, data_node->data.scalar.value);
     }
-    return iree_vm_list_push_variant(target_list, &variant);
+    return iree_vm_list_push_variant_move(target_list, &variant);
   }
   IREE_RETURN_IF_ERROR(iree_yaml_mapping_try_find(document, value_node,
                                                   IREE_SV("f64"), &data_node));
@@ -454,7 +454,7 @@
           IREE_STATUS_INVALID_ARGUMENT, "failed to parse f64 value: '%.*s'",
           (int)data_node->data.scalar.length, data_node->data.scalar.value);
     }
-    return iree_vm_list_push_variant(target_list, &variant);
+    return iree_vm_list_push_variant_move(target_list, &variant);
   }
   return iree_make_status(IREE_STATUS_UNIMPLEMENTED,
                           "(%zu): unimplemented scalar type parser",
@@ -937,7 +937,7 @@
   iree_string_view_t type = iree_yaml_node_as_string(type_node);
   if (iree_string_view_equal(type, IREE_SV("null"))) {
     iree_vm_variant_t null_value = iree_vm_variant_empty();
-    return iree_vm_list_push_variant(target_list, &null_value);
+    return iree_vm_list_push_variant_move(target_list, &null_value);
   } else if (iree_string_view_equal(type, IREE_SV("value"))) {
     return iree_trace_replay_parse_scalar(replay, document, value_node,
                                           target_list);
@@ -1007,7 +1007,7 @@
     iree_vm_list_t* list, iree_allocator_t host_allocator) {
   for (iree_host_size_t i = 0; i < iree_vm_list_size(list); ++i) {
     iree_vm_variant_t variant = iree_vm_variant_empty();
-    IREE_RETURN_IF_ERROR(iree_vm_list_get_variant(list, i, &variant),
+    IREE_RETURN_IF_ERROR(iree_vm_list_get_variant_assign(list, i, &variant),
                          "variant %zu not present", i);
     IREE_RETURN_IF_ERROR(
         iree_trace_replay_print_item(&variant, host_allocator));
diff --git a/runtime/src/iree/tooling/vm_util.c b/runtime/src/iree/tooling/vm_util.c
index 3052b9b..39dd4f5 100644
--- a/runtime/src/iree/tooling/vm_util.c
+++ b/runtime/src/iree/tooling/vm_util.c
@@ -376,7 +376,7 @@
   for (iree_host_size_t i = 0; i < iree_vm_list_size(list); ++i) {
     iree_vm_variant_t variant = iree_vm_variant_empty();
     IREE_RETURN_AND_END_ZONE_IF_ERROR(
-        z0, iree_vm_list_get_variant(list, i, &variant),
+        z0, iree_vm_list_get_variant_assign(list, i, &variant),
         "variant %zu not present", i);
     iree_string_builder_append_format(builder, "result[%zu]: ", i);
     IREE_RETURN_AND_END_ZONE_IF_ERROR(
@@ -482,7 +482,7 @@
   for (iree_host_size_t i = 0; i < output_strings_count; ++i) {
     iree_vm_variant_t variant = iree_vm_variant_empty();
     IREE_RETURN_AND_END_ZONE_IF_ERROR(
-        z0, iree_vm_list_get_variant(list, i, &variant));
+        z0, iree_vm_list_get_variant_assign(list, i, &variant));
     IREE_RETURN_AND_END_ZONE_IF_ERROR(
         z0, iree_tooling_output_variant(variant, output_strings[i],
                                         max_element_count, file));
diff --git a/runtime/src/iree/vm/BUILD b/runtime/src/iree/vm/BUILD
index 1fac929..3969e8d 100644
--- a/runtime/src/iree/vm/BUILD
+++ b/runtime/src/iree/vm/BUILD
@@ -75,6 +75,7 @@
         "stack.h",
         "type_def.h",
         "value.h",
+        "variant.h",
     ],
     deps = [
         "//runtime/src/iree/base",
diff --git a/runtime/src/iree/vm/CMakeLists.txt b/runtime/src/iree/vm/CMakeLists.txt
index b0447c3..48013b5 100644
--- a/runtime/src/iree/vm/CMakeLists.txt
+++ b/runtime/src/iree/vm/CMakeLists.txt
@@ -51,6 +51,7 @@
     "stack.h"
     "type_def.h"
     "value.h"
+    "variant.h"
   SRCS
     "buffer.c"
     "context.c"
diff --git a/runtime/src/iree/vm/api.h b/runtime/src/iree/vm/api.h
index 87e5750..45a0d39 100644
--- a/runtime/src/iree/vm/api.h
+++ b/runtime/src/iree/vm/api.h
@@ -20,5 +20,6 @@
 #include "iree/vm/stack.h"          // IWYU pragma: export
 #include "iree/vm/type_def.h"       // IWYU pragma: export
 #include "iree/vm/value.h"          // IWYU pragma: export
+#include "iree/vm/variant.h"        // IWYU pragma: export
 
 #endif  // IREE_VM_API_H_
diff --git a/runtime/src/iree/vm/list.c b/runtime/src/iree/vm/list.c
index 0dafa55..cc4b703 100644
--- a/runtime/src/iree/vm/list.c
+++ b/runtime/src/iree/vm/list.c
@@ -925,34 +925,60 @@
   return iree_ok_status();
 }
 
-IREE_API_EXPORT iree_status_t
-iree_vm_list_get_variant(const iree_vm_list_t* list, iree_host_size_t i,
-                         iree_vm_variant_t* out_value) {
+typedef enum {
+  IREE_VM_LIST_REF_ASSIGN = 0,
+  IREE_VM_LIST_REF_RETAIN,
+  IREE_VM_LIST_REF_MOVE,
+} iree_vm_list_ref_mode_t;
+
+static void iree_vm_list_ref_op(iree_vm_list_ref_mode_t mode,
+                                iree_vm_ref_t* ref, iree_vm_ref_t* out_ref) {
+  switch (mode) {
+    case IREE_VM_LIST_REF_ASSIGN:
+      iree_vm_ref_assign(ref, out_ref);
+      break;
+    case IREE_VM_LIST_REF_RETAIN:
+      iree_vm_ref_retain(ref, out_ref);
+      break;
+    case IREE_VM_LIST_REF_MOVE:
+      iree_vm_ref_move(ref, out_ref);
+      break;
+  }
+}
+
+static iree_status_t iree_vm_list_get_variant(const iree_vm_list_t* list,
+                                              iree_host_size_t i,
+                                              iree_vm_list_ref_mode_t ref_mode,
+                                              iree_vm_variant_t* out_variant) {
+  IREE_ASSERT_ARGUMENT(list);
+  IREE_ASSERT_ARGUMENT(out_variant);
   if (i >= list->count) {
     return iree_make_status(IREE_STATUS_OUT_OF_RANGE,
                             "index %zu out of bounds (%zu)", i, list->count);
   }
+  iree_vm_variant_reset(out_variant);
   uintptr_t element_ptr = (uintptr_t)list->storage + i * list->element_size;
   switch (list->storage_mode) {
     case IREE_VM_LIST_STORAGE_MODE_VALUE: {
-      out_value->type = list->element_type;
-      memcpy(out_value->value_storage, (void*)element_ptr, list->element_size);
+      out_variant->type = list->element_type;
+      memcpy(out_variant->value_storage, (void*)element_ptr,
+             list->element_size);
       break;
     }
     case IREE_VM_LIST_STORAGE_MODE_REF: {
       iree_vm_ref_t* element_ref = (iree_vm_ref_t*)element_ptr;
-      out_value->type.ref_type = element_ref->type;
-      out_value->type.value_type = IREE_VM_VALUE_TYPE_NONE;
-      iree_vm_ref_assign(element_ref, &out_value->ref);
+      out_variant->type.ref_type = element_ref->type;
+      out_variant->type.value_type = IREE_VM_VALUE_TYPE_NONE;
+      iree_vm_list_ref_op(ref_mode, element_ref, &out_variant->ref);
       break;
     }
     case IREE_VM_LIST_STORAGE_MODE_VARIANT: {
       iree_vm_variant_t* variant = (iree_vm_variant_t*)element_ptr;
-      out_value->type = variant->type;
+      out_variant->type = variant->type;
       if (iree_vm_type_def_is_ref(&variant->type)) {
-        iree_vm_ref_assign(&variant->ref, &out_value->ref);
+        iree_vm_list_ref_op(ref_mode, &variant->ref, &out_variant->ref);
       } else {
-        memcpy(out_value->value_storage, variant->value_storage,
+        memcpy(out_variant->value_storage, variant->value_storage,
                sizeof(variant->value_storage));
       }
       break;
@@ -963,17 +989,80 @@
   return iree_ok_status();
 }
 
-IREE_API_EXPORT iree_status_t iree_vm_list_set_variant(
-    iree_vm_list_t* list, iree_host_size_t i, const iree_vm_variant_t* value) {
-  return iree_make_status(IREE_STATUS_UNIMPLEMENTED,
-                          "iree_vm_list_set_variant unimplemented");
+IREE_API_EXPORT iree_status_t
+iree_vm_list_get_variant_assign(const iree_vm_list_t* list, iree_host_size_t i,
+                                iree_vm_variant_t* out_variant) {
+  return iree_vm_list_get_variant(list, i, IREE_VM_LIST_REF_ASSIGN,
+                                  out_variant);
 }
 
-IREE_API_EXPORT iree_status_t iree_vm_list_push_variant(
-    iree_vm_list_t* list, const iree_vm_variant_t* value) {
+IREE_API_EXPORT iree_status_t
+iree_vm_list_get_variant_retain(const iree_vm_list_t* list, iree_host_size_t i,
+                                iree_vm_variant_t* out_variant) {
+  return iree_vm_list_get_variant(list, i, IREE_VM_LIST_REF_RETAIN,
+                                  out_variant);
+}
+
+IREE_API_EXPORT iree_status_t
+iree_vm_list_get_variant_move(const iree_vm_list_t* list, iree_host_size_t i,
+                              iree_vm_variant_t* out_variant) {
+  return iree_vm_list_get_variant(list, i, IREE_VM_LIST_REF_MOVE, out_variant);
+}
+
+static iree_status_t iree_vm_list_set_variant(iree_vm_list_t* list,
+                                              iree_host_size_t i, bool is_move,
+                                              iree_vm_variant_t* variant) {
+  if (iree_vm_type_def_is_variant(&variant->type)) {
+    iree_vm_value_t value = iree_vm_variant_value(*variant);
+    return iree_vm_list_set_value(list, i, &value);
+  } else if (iree_vm_type_def_is_value(&variant->type)) {
+    iree_vm_value_t value = {
+        .type = variant->type.value_type,
+    };
+    memcpy(value.value_storage, variant->value_storage,
+           sizeof(value.value_storage));
+    return iree_vm_list_set_value(list, i, &value);
+  } else if (iree_vm_type_def_is_ref(&variant->type)) {
+    iree_status_t status =
+        iree_vm_list_set_ref(list, i, is_move, &variant->ref);
+    if (iree_status_is_ok(status) && is_move) {
+      variant->type.ref_type = IREE_VM_REF_TYPE_NULL;
+    }
+    return status;
+  } else {
+    return iree_make_status(IREE_STATUS_UNIMPLEMENTED,
+                            "unhandled variant value type");
+  }
+}
+
+IREE_API_EXPORT iree_status_t
+iree_vm_list_set_variant_retain(iree_vm_list_t* list, iree_host_size_t i,
+                                const iree_vm_variant_t* variant) {
+  return iree_vm_list_set_variant(list, i, /*is_move=*/false,
+                                  (iree_vm_variant_t*)variant);
+}
+
+IREE_API_EXPORT iree_status_t iree_vm_list_set_variant_move(
+    iree_vm_list_t* list, iree_host_size_t i, iree_vm_variant_t* variant) {
+  return iree_vm_list_set_variant(list, i, /*is_move=*/true, variant);
+}
+
+static iree_status_t iree_vm_list_push_variant(
+    iree_vm_list_t* list, bool is_move, const iree_vm_variant_t* variant) {
   iree_host_size_t i = iree_vm_list_size(list);
   IREE_RETURN_IF_ERROR(iree_vm_list_resize(list, i + 1));
-  return iree_vm_list_set_variant(list, i, value);
+  return iree_vm_list_set_variant(list, i, is_move,
+                                  (iree_vm_variant_t*)variant);
+}
+
+IREE_API_EXPORT iree_status_t iree_vm_list_push_variant_retain(
+    iree_vm_list_t* list, const iree_vm_variant_t* variant) {
+  return iree_vm_list_push_variant(list, /*is_move=*/false, variant);
+}
+
+IREE_API_EXPORT iree_status_t iree_vm_list_push_variant_move(
+    iree_vm_list_t* list, iree_vm_variant_t* variant) {
+  return iree_vm_list_push_variant(list, /*is_move=*/true, variant);
 }
 
 iree_status_t iree_vm_list_register_types(iree_vm_instance_t* instance) {
diff --git a/runtime/src/iree/vm/list.h b/runtime/src/iree/vm/list.h
index b7d2ba3..3b9b176 100644
--- a/runtime/src/iree/vm/list.h
+++ b/runtime/src/iree/vm/list.h
@@ -13,6 +13,7 @@
 #include "iree/vm/ref.h"
 #include "iree/vm/type_def.h"
 #include "iree/vm/value.h"
+#include "iree/vm/variant.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -202,22 +203,48 @@
 // a ref it will *not* be retained and the caller must retain it to extend its
 // lifetime.
 IREE_API_EXPORT iree_status_t
-iree_vm_list_get_variant(const iree_vm_list_t* list, iree_host_size_t i,
-                         iree_vm_variant_t* out_value);
+iree_vm_list_get_variant_assign(const iree_vm_list_t* list, iree_host_size_t i,
+                                iree_vm_variant_t* out_variant);
+
+// Returns the value of the element at the given index.
+// If the variant is a ref then it will be retained.
+IREE_API_EXPORT iree_status_t
+iree_vm_list_get_variant_retain(const iree_vm_list_t* list, iree_host_size_t i,
+                                iree_vm_variant_t* out_variant);
+
+// Returns the value of the element at the given index.
+// If the variant is a ref then it will be moved.
+IREE_API_EXPORT iree_status_t
+iree_vm_list_get_variant_move(const iree_vm_list_t* list, iree_host_size_t i,
+                              iree_vm_variant_t* out_variant);
 
 // Sets the value of the element at the given index. If the specified |value|
 // type differs from the list storage type the value will be converted using the
 // value type semantics (such as sign/zero extend, etc). If the variant is a ref
 // then it will be retained.
-IREE_API_EXPORT iree_status_t iree_vm_list_set_variant(
-    iree_vm_list_t* list, iree_host_size_t i, const iree_vm_variant_t* value);
+IREE_API_EXPORT iree_status_t iree_vm_list_set_variant_retain(
+    iree_vm_list_t* list, iree_host_size_t i, const iree_vm_variant_t* variant);
+
+// Sets the value of the element at the given index. If the specified |value|
+// type differs from the list storage type the value will be converted using the
+// value type semantics (such as sign/zero extend, etc). If the variant is a ref
+// then it will be moved.
+IREE_API_EXPORT iree_status_t iree_vm_list_set_variant_move(
+    iree_vm_list_t* list, iree_host_size_t i, iree_vm_variant_t* variant);
 
 // Pushes the value of the element to the end of the list. If the specified
-// |value| type differs from the list storage type the value will be converted
+// |variant| type differs from the list storage type the value will be converted
 // using the value type semantics (such as sign/zero extend, etc). If the
 // variant is a ref then it will be retained.
-IREE_API_EXPORT iree_status_t
-iree_vm_list_push_variant(iree_vm_list_t* list, const iree_vm_variant_t* value);
+IREE_API_EXPORT iree_status_t iree_vm_list_push_variant_retain(
+    iree_vm_list_t* list, const iree_vm_variant_t* variant);
+
+// Pushes the value of the element to the end of the list. If the specified
+// |variant| type differs from the list storage type the value will be converted
+// using the value type semantics (such as sign/zero extend, etc). If the
+// variant is a ref then it will be moved.
+IREE_API_EXPORT iree_status_t iree_vm_list_push_variant_move(
+    iree_vm_list_t* list, iree_vm_variant_t* variant);
 
 #ifdef __cplusplus
 }  // extern "C"
diff --git a/runtime/src/iree/vm/list_test.cc b/runtime/src/iree/vm/list_test.cc
index f20bc06..a18c4f5 100644
--- a/runtime/src/iree/vm/list_test.cc
+++ b/runtime/src/iree/vm/list_test.cc
@@ -101,7 +101,7 @@
   result.resize(iree_vm_list_size(list));
   for (iree_host_size_t i = 0; i < result.size(); ++i) {
     iree_vm_variant_t variant = iree_vm_variant_empty();
-    IREE_CHECK_OK(iree_vm_list_get_variant(list, i, &variant));
+    IREE_CHECK_OK(iree_vm_list_get_variant_assign(list, i, &variant));
     if (iree_vm_type_def_is_value(&variant.type)) {
       result[i].type = variant.type.value_type;
       memcpy(result[i].value_storage, variant.value_storage,
@@ -622,7 +622,7 @@
   IREE_ASSERT_OK(iree_vm_list_resize(list, 5));
   for (iree_host_size_t i = 0; i < 5; ++i) {
     iree_vm_variant_t value = iree_vm_variant_empty();
-    IREE_ASSERT_OK(iree_vm_list_get_variant(list, i, &value));
+    IREE_ASSERT_OK(iree_vm_list_get_variant_assign(list, i, &value));
     EXPECT_TRUE(iree_vm_variant_is_empty(value));
   }
 
@@ -655,7 +655,7 @@
   }
   for (iree_host_size_t i = 2; i < 5; ++i) {
     iree_vm_variant_t value = iree_vm_variant_empty();
-    IREE_ASSERT_OK(iree_vm_list_get_variant(list, i, &value));
+    IREE_ASSERT_OK(iree_vm_list_get_variant_assign(list, i, &value));
     EXPECT_TRUE(iree_vm_variant_is_empty(value));
   }
 
diff --git a/runtime/src/iree/vm/type_def.h b/runtime/src/iree/vm/type_def.h
index d8cc8b6..3de996c 100644
--- a/runtime/src/iree/vm/type_def.h
+++ b/runtime/src/iree/vm/type_def.h
@@ -58,32 +58,6 @@
   ((v)->value_type == IREE_VM_VALUE_TYPE_NONE && \
    (v)->ref_type == IREE_VM_REF_TYPE_NULL)
 
-// An variant value that can be either a primitive value type or a ref type.
-// Each variant value stores its type but users are required to check the type
-// prior to accessing any of the data.
-typedef struct iree_vm_variant_t {
-  iree_vm_type_def_t type;
-  union {
-    // TODO(benvanik): replace with iree_vm_value_t.
-    int8_t i8;
-    int16_t i16;
-    int32_t i32;
-    int64_t i64;
-    float f32;
-    double f64;
-    iree_vm_ref_t ref;
-
-    uint8_t value_storage[IREE_VM_VALUE_STORAGE_SIZE];  // max size of all value
-                                                        // types
-  };
-} iree_vm_variant_t;
-
-#define iree_vm_variant_empty() \
-  { {IREE_VM_VALUE_TYPE_NONE, IREE_VM_REF_TYPE_NULL}, {0}, }
-#define iree_vm_variant_is_value(v) iree_vm_type_def_is_value(&(v).type)
-#define iree_vm_variant_is_ref(v) iree_vm_type_def_is_ref(&(v).type)
-#define iree_vm_variant_is_empty(v) iree_vm_type_def_is_variant(&(v).type)
-
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus
diff --git a/runtime/src/iree/vm/variant.h b/runtime/src/iree/vm/variant.h
new file mode 100644
index 0000000..dfff9ed
--- /dev/null
+++ b/runtime/src/iree/vm/variant.h
@@ -0,0 +1,103 @@
+// Copyright 2023 The IREE Authors
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef IREE_VM_VARIANT_H_
+#define IREE_VM_VARIANT_H_
+
+#include "iree/vm/ref.h"
+#include "iree/vm/value.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif  // __cplusplus
+
+// An variant value that can be either a primitive value type or a ref type.
+// Each variant value stores its type but users are required to check the type
+// prior to accessing any of the data.
+typedef struct iree_vm_variant_t {
+  iree_vm_type_def_t type;
+  union {
+    // TODO(benvanik): replace with iree_vm_value_t. Don't want to pay for 2x
+    // the type storage, though.
+    int8_t i8;
+    int16_t i16;
+    int32_t i32;
+    int64_t i64;
+    float f32;
+    double f64;
+    iree_vm_ref_t ref;
+    uint8_t value_storage[IREE_VM_VALUE_STORAGE_SIZE];  // max size of all value
+                                                        // types
+  };
+} iree_vm_variant_t;
+
+// Returns an empty variant.
+static inline iree_vm_variant_t iree_vm_variant_empty(void) {
+  iree_vm_variant_t result;
+  result.type = iree_vm_type_def_make_variant_type();
+  result.ref = iree_vm_ref_null();
+  return result;
+}
+
+// Returns true if |variant| is empty (no value/NULL ref).
+static inline bool iree_vm_variant_is_empty(iree_vm_variant_t variant) {
+  return iree_vm_type_def_is_variant(&variant.type);
+}
+
+// Returns true if |variant| represents a primitive value.
+static inline bool iree_vm_variant_is_value(iree_vm_variant_t variant) {
+  return iree_vm_type_def_is_value(&variant.type);
+}
+
+// Returns true if |variant| represents a non-NULL ref type.
+static inline bool iree_vm_variant_is_ref(iree_vm_variant_t variant) {
+  return iree_vm_type_def_is_ref(&variant.type);
+}
+
+// Makes a variant containing the given primitive |value|.
+static inline iree_vm_variant_t iree_vm_make_variant_value(
+    iree_vm_value_t value) {
+  iree_vm_variant_t result = iree_vm_variant_empty();
+  result.type.value_type = value.type;
+  memcpy(result.value_storage, value.value_storage,
+         sizeof(result.value_storage));
+  return result;
+}
+
+// Makes a variant containing the given |ref| type with assignment semantics.
+static inline iree_vm_variant_t iree_vm_make_variant_ref_assign(
+    iree_vm_ref_t ref) {
+  iree_vm_variant_t result = iree_vm_variant_empty();
+  result.type.ref_type = ref.type;
+  result.ref = ref;
+  return result;
+}
+
+// Returns the primitive value contained within |variant|, if any.
+// If the variant is not a value type the return will be the same as
+// iree_vm_value_make_none.
+static inline iree_vm_value_t iree_vm_variant_value(iree_vm_variant_t variant) {
+  iree_vm_value_t value;
+  value.type = variant.type.value_type;
+  memcpy(value.value_storage, variant.value_storage,
+         sizeof(value.value_storage));
+  return value;
+}
+
+// Resets |variant| to empty in-place and releases the contained ref, if set.
+static inline void iree_vm_variant_reset(iree_vm_variant_t* variant) {
+  if (!variant) return;
+  if (iree_vm_variant_is_ref(*variant)) {
+    iree_vm_ref_release(&variant->ref);
+  }
+  *variant = iree_vm_variant_empty();
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+#endif  // IREE_VM_VARIANT_H_
diff --git a/tools/iree-e2e-matmul-test.c b/tools/iree-e2e-matmul-test.c
index e77a89c..3615249 100644
--- a/tools/iree-e2e-matmul-test.c
+++ b/tools/iree-e2e-matmul-test.c
@@ -166,7 +166,7 @@
     iree_vm_list_t* list, iree_host_size_t i,
     iree_hal_buffer_view_t** out_value) {
   iree_vm_variant_t variant = iree_vm_variant_empty();
-  IREE_RETURN_IF_ERROR(iree_vm_list_get_variant(list, i, &variant));
+  IREE_RETURN_IF_ERROR(iree_vm_list_get_variant_assign(list, i, &variant));
   if (!iree_vm_variant_is_ref(variant)) {
     return iree_make_status(IREE_STATUS_INVALID_ARGUMENT,
                             "expected list item %zu to be a ref", i);