diff --git a/doc/domains-reference.md b/doc/domains-reference.md
index e330fcb..ac8ae23 100644
--- a/doc/domains-reference.md
+++ b/doc/domains-reference.md
@@ -60,7 +60,7 @@
 
 ```c++
 void MyProperty(const absl::flat_hash_map<uint32, MyProtoMessage>& m,
-                const absl::optional<std::string>& s) {
+                const std::optional<std::string>& s) {
   //...
 }
 FUZZ_TEST(MySuite, MyProperty);
diff --git a/domain_tests/BUILD b/domain_tests/BUILD
index a07a4ab..c9d1854 100644
--- a/domain_tests/BUILD
+++ b/domain_tests/BUILD
@@ -44,6 +44,8 @@
     deps = [
         ":domain_testing",
         "@com_google_absl//absl/random",
+        "@com_google_absl//absl/types:optional",
+        "@com_google_absl//absl/types:variant",
         "@com_google_fuzztest//fuzztest:domain",
         "@com_google_googletest//:gtest_main",
     ],
diff --git a/domain_tests/aggregate_combinators_test.cc b/domain_tests/aggregate_combinators_test.cc
index 122f036..ab83bdb 100644
--- a/domain_tests/aggregate_combinators_test.cc
+++ b/domain_tests/aggregate_combinators_test.cc
@@ -30,6 +30,8 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/random/random.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
 #include "./fuzztest/domain.h"
 #include "./domain_tests/domain_testing.h"
 
diff --git a/fuzztest/BUILD b/fuzztest/BUILD
index bde26bc..d564647 100644
--- a/fuzztest/BUILD
+++ b/fuzztest/BUILD
@@ -353,7 +353,6 @@
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings:str_format",
         "@com_google_absl//absl/types:span",
-        "@com_google_absl//absl/types:variant",
     ],
 )
 
diff --git a/fuzztest/internal/serialization.cc b/fuzztest/internal/serialization.cc
index d276d9c..587f5f3 100644
--- a/fuzztest/internal/serialization.cc
+++ b/fuzztest/internal/serialization.cc
@@ -20,13 +20,13 @@
 #include <limits>
 #include <optional>
 #include <string>
+#include <variant>
 #include <vector>
 
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
 
 namespace fuzztest::internal {
 
@@ -62,10 +62,10 @@
   void operator()(const std::vector<IRObject>& value) const {
     for (const auto& sub : value) {
       const bool sub_is_scalar =
-          !absl::holds_alternative<std::vector<IRObject>>(sub.value);
+          !std::holds_alternative<std::vector<IRObject>>(sub.value);
       absl::StrAppendFormat(&out, "%*ssub {%s", indent, "",
                             sub_is_scalar ? " " : "\n");
-      absl::visit(OutputVisitor{sub.value.index(), indent + 2, out}, sub.value);
+      std::visit(OutputVisitor{sub.value.index(), indent + 2, out}, sub.value);
       absl::StrAppendFormat(&out, "%*s}\n", sub_is_scalar ? 0 : indent,
                             sub_is_scalar ? " " : "");
     }
@@ -175,7 +175,7 @@
 
 std::string IRObject::ToString() const {
   std::string out = absl::StrCat(AsAbsl(kHeader), "\n");
-  absl::visit(OutputVisitor{value.index(), 0, out}, value);
+  std::visit(OutputVisitor{value.index(), 0, out}, value);
   return out;
 }
 
diff --git a/fuzztest/internal/serialization.h b/fuzztest/internal/serialization.h
index 2ce6092..3f91d9f 100644
--- a/fuzztest/internal/serialization.h
+++ b/fuzztest/internal/serialization.h
@@ -23,11 +23,11 @@
 #include <tuple>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/numeric/int128.h"
 #include "absl/types/span.h"
-#include "absl/types/variant.h"
 #include "./fuzztest/internal/meta.h"
 
 namespace fuzztest::internal {
@@ -54,8 +54,8 @@
 // set.
 
 struct IRObject {
-  using Value = absl::variant<std::monostate, uint64_t, double, std::string,
-                              std::vector<IRObject>>;
+  using Value = std::variant<std::monostate, uint64_t, double, std::string,
+                             std::vector<IRObject>>;
   Value value;
 
   IRObject() = default;
@@ -77,15 +77,15 @@
       auto inner = GetScalar<std::underlying_type_t<T>>();
       return inner ? std::optional(static_cast<T>(*inner)) : std::nullopt;
     } else if constexpr (std::is_integral_v<T>) {
-      const uint64_t* i = absl::get_if<uint64_t>(&value);
+      const uint64_t* i = std::get_if<uint64_t>(&value);
       return i != nullptr ? std::optional(static_cast<T>(*i)) : std::nullopt;
     } else if constexpr (std::is_same_v<float, T> ||
                          std::is_same_v<double, T>) {
-      const double* i = absl::get_if<double>(&value);
+      const double* i = std::get_if<double>(&value);
       return i != nullptr ? std::optional(static_cast<T>(*i)) : std::nullopt;
     } else if constexpr (std::is_same_v<std::string, T>) {
       std::optional<std::string_view> out;
-      if (const auto* s = absl::get_if<std::string>(&value)) {
+      if (const auto* s = std::get_if<std::string>(&value)) {
         out = *s;
       }
       return out;
@@ -113,12 +113,12 @@
 
   // If this node contains subs, return it as a Span. Otherwise, nullopt.
   std::optional<absl::Span<const IRObject>> Subs() const {
-    if (const auto* i = absl::get_if<std::vector<IRObject>>(&value)) {
+    if (const auto* i = std::get_if<std::vector<IRObject>>(&value)) {
       return *i;
     }
     // The empty vector is serialized the same way as the monostate: nothing.
     // Handle that case too.
-    if (absl::holds_alternative<std::monostate>(value)) {
+    if (std::holds_alternative<std::monostate>(value)) {
       return absl::Span<const IRObject>{};
     }
     return std::nullopt;
@@ -128,10 +128,10 @@
   // them.
   // Overwrites any existing data.
   std::vector<IRObject>& MutableSubs() {
-    if (!absl::holds_alternative<std::vector<IRObject>>(value)) {
+    if (!std::holds_alternative<std::vector<IRObject>>(value)) {
       value.emplace<std::vector<IRObject>>();
     }
-    return absl::get<std::vector<IRObject>>(value);
+    return std::get<std::vector<IRObject>>(value);
   }
 
   // Conversion functions to map IRObject to/from corpus values.
@@ -198,7 +198,7 @@
     if constexpr (std::is_const_v<T>) {
       return ToCorpus<std::remove_const_t<T>>();
     } else if constexpr (is_monostate_v<T>) {
-      if (absl::holds_alternative<std::monostate>(value)) return T{};
+      if (std::holds_alternative<std::monostate>(value)) return T{};
       return std::nullopt;
     } else if constexpr (std::is_same_v<T, IRObject>) {
       return *this;
@@ -226,7 +226,7 @@
       }
       return std::nullopt;
     } else if constexpr (is_protocol_buffer_v<T>) {
-      const std::string* v = absl::get_if<std::string>(&value);
+      const std::string* v = std::get_if<std::string>(&value);
       T out;
       if (v && out.ParseFromString(*v)) return out;
       return std::nullopt;