diff --git a/fuzztest/BUILD b/fuzztest/BUILD
index 6dbe207..038cfee 100644
--- a/fuzztest/BUILD
+++ b/fuzztest/BUILD
@@ -345,6 +345,7 @@
     srcs = ["internal/serialization.cc"],
     hdrs = ["internal/serialization.h"],
     deps = [
+        ":logging",
         ":meta",
         "@com_google_absl//absl/numeric:int128",
         "@com_google_absl//absl/strings",
diff --git a/fuzztest/internal/serialization.cc b/fuzztest/internal/serialization.cc
index d276d9c..73dd439 100644
--- a/fuzztest/internal/serialization.cc
+++ b/fuzztest/internal/serialization.cc
@@ -18,7 +18,6 @@
 #include <cstddef>
 #include <cstdint>
 #include <limits>
-#include <optional>
 #include <string>
 #include <vector>
 
@@ -72,36 +71,12 @@
   }
 };
 
-constexpr std::string_view kHeader = "FUZZTESTv1";
-
-absl::string_view AsAbsl(std::string_view str) {
-  return {str.data(), str.size()};
-}
-
-std::string_view ReadToken(std::string_view& in) {
-  while (!in.empty() && std::isspace(in[0])) in.remove_prefix(1);
-  if (in.empty()) return in;
-  size_t end = 1;
-  const auto is_literal = [](char c) {
-    return std::isalnum(c) != 0 || c == '+' || c == '-' || c == '.';
-  };
-  if (is_literal(in[0])) {
-    while (end < in.size() && is_literal(in[end])) ++end;
-  } else if (in[0] == '"') {
-    while (end < in.size() && in[end] != '"') ++end;
-    if (end < in.size()) ++end;
-  }
-  std::string_view res = in.substr(0, end);
-  in.remove_prefix(end);
-  return res;
-}
-
 bool ReadScalar(uint64_t& out, std::string_view value) {
-  return absl::SimpleAtoi(AsAbsl(value), &out);
+  return absl::SimpleAtoi(IRObject{}.AsAbsl(value), &out);
 }
 
 bool ReadScalar(double& out, std::string_view value) {
-  return absl::SimpleAtod(AsAbsl(value), &out);
+  return absl::SimpleAtod(IRObject{}.AsAbsl(value), &out);
 }
 
 bool ReadScalar(std::string& out, std::string_view value) {
@@ -134,7 +109,31 @@
   return true;
 }
 
-bool ParseImpl(IRObject& obj, std::string_view& str) {
+}  // namespace
+
+void IRObject::Visit(std::string& out) const {
+  absl::visit(OutputVisitor{value.index(), 0, out}, value);
+}
+
+std::string_view IRObject::ReadToken(std::string_view& in) const {
+  while (!in.empty() && std::isspace(in[0])) in.remove_prefix(1);
+  if (in.empty()) return in;
+  size_t end = 1;
+  const auto is_literal = [](char c) {
+    return std::isalnum(c) != 0 || c == '+' || c == '-' || c == '.';
+  };
+  if (is_literal(in[0])) {
+    while (end < in.size() && is_literal(in[end])) ++end;
+  } else if (in[0] == '"') {
+    while (end < in.size() && in[end] != '"') ++end;
+    if (end < in.size()) ++end;
+  }
+  std::string_view res = in.substr(0, end);
+  in.remove_prefix(end);
+  return res;
+}
+
+bool IRObject::ParseImpl(IRObject& obj, std::string_view& str) {
   std::string_view key = ReadToken(str);
   if (key.empty() || key == "}") {
     // The object is empty. Put the token back and return.
@@ -171,19 +170,4 @@
   }
 }
 
-}  // namespace
-
-std::string IRObject::ToString() const {
-  std::string out = absl::StrCat(AsAbsl(kHeader), "\n");
-  absl::visit(OutputVisitor{value.index(), 0, out}, value);
-  return out;
-}
-
-std::optional<IRObject> IRObject::FromString(std::string_view str) {
-  IRObject object;
-  if (ReadToken(str) != kHeader) return std::nullopt;
-  if (!ParseImpl(object, str) || !ReadToken(str).empty()) return std::nullopt;
-  return object;
-}
-
 }  // namespace fuzztest::internal
diff --git a/fuzztest/internal/serialization.h b/fuzztest/internal/serialization.h
index 2ce6092..82c2d65 100644
--- a/fuzztest/internal/serialization.h
+++ b/fuzztest/internal/serialization.h
@@ -23,11 +23,15 @@
 #include <tuple>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/numeric/int128.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "absl/types/variant.h"
+#include "./fuzztest/internal/logging.h"
 #include "./fuzztest/internal/meta.h"
 
 namespace fuzztest::internal {
@@ -260,10 +264,45 @@
     }
   }
 
+  static constexpr std::string_view kHeader = "FUZZTESTv1";
+
+  absl::string_view AsAbsl(std::string_view str) const {
+    return {str.data(), str.size()};
+  }
+
   // Serialize the object as a string. This is used to persist the object on
   // files for reproducing bugs later.
-  std::string ToString() const;
-  static std::optional<IRObject> FromString(std::string_view str);
+  template <typename ValueType>
+  std::string ToString() const {
+    // Return single string-like or proto values as raw strings.
+    if constexpr (std::is_same_v<ValueType, std::string> ||
+                  is_protocol_buffer_v<ValueType>) {
+      FUZZTEST_INTERNAL_CHECK_PRECONDITION(
+          absl::holds_alternative<std::string>(value),
+          "String-like value should hold a string!");
+      return absl::get<std::string>(value);
+    }
+    std::string out = absl::StrCat(AsAbsl(kHeader), "\n");
+    // Construct out using IRObject format.
+    IRObject::Visit(out);
+    return out;
+  }
+
+  template <typename ValueType>
+  std::optional<IRObject> FromString(std::string_view str) {
+    IRObject object;
+    if constexpr (std::is_same_v<ValueType, std::string>) {
+      object.value.emplace<std::string>(str);
+      FUZZTEST_INTERNAL_CHECK(
+          absl::holds_alternative<std::string>(object.value),
+          "IRObject value should hold a string after deserializing from a "
+          "single string-like value!");
+      return object;
+    }
+    if (ReadToken(str) != kHeader) return std::nullopt;
+    if (!ParseImpl(object, str) || !ReadToken(str).empty()) return std::nullopt;
+    return object;
+  }
 
  private:
   template <typename T>
@@ -272,6 +311,10 @@
   template <typename K, typename V>
   static std::pair<std::remove_const_t<K>, std::remove_const_t<V>>
       RemoveConstFromPair(std::pair<K, V>);
+
+  void Visit(std::string& out) const;
+  std::string_view ReadToken(std::string_view& in) const;
+  bool ParseImpl(IRObject& obj, std::string_view& str);
 };
 
 }  // namespace fuzztest::internal
diff --git a/fuzztest/internal/serialization_test.cc b/fuzztest/internal/serialization_test.cc
index d0113ac..773228c 100644
--- a/fuzztest/internal/serialization_test.cc
+++ b/fuzztest/internal/serialization_test.cc
@@ -39,8 +39,8 @@
 
 using testing::_;
 using testing::ElementsAre;
-using testing::Eq;
 using testing::FieldsAre;
+using testing::HasSubstr;
 using testing::NanSensitiveDoubleEq;
 using testing::Not;
 using testing::Optional;
@@ -92,7 +92,10 @@
 
 void VerifyProtobufFormat(const IRObject& object) {
   IRObjectTestProto proto;
-  std::string s = object.ToString();
+  std::string s = object.ToString<IRObject>();
+  // TODO(cnie0017) This is not a IRObjectTestProto
+  // since it is already being parsed to String once. It is now of IRObject form
+
   // Chop the header.
   s.erase(0, strlen("FUZZTESTv1\n"));
 
@@ -104,14 +107,19 @@
 void RoundTripVerify(const T&... values) {
   IRObject object;
   object.value = std::vector{IRObject{values}...};
-  std::string s = object.ToString();
+  std::string s = object.ToString<IRObject>();
 
   SCOPED_TRACE(s);
 
   VerifyProtobufFormat(object);
 
-  EXPECT_THAT(IRObject::FromString(s),
+  // TODO(cnie0017): why can't use T?
+  EXPECT_THAT(IRObject{}.FromString<IRObject>(s),
               Optional(SubsAre(ValueIs<T>(values)...)));
+  // EXPECT_THAT(IRObject::FromString<T>(s),
+  //             Optional(SubsAre(ValueIs<T>(values)...)));
+  // // Initializer contains unexpanded parameter pack
+  // // 'T'clang(unexpanded_parameter_pack)
 }
 
 template <typename T>
@@ -134,13 +142,13 @@
                                                      IRObject{"child3.2.2"}}}}},
       IRObject{"child4"}}};
 
-  std::string s = root.ToString();
+  std::string s = root.ToString<IRObject>();
 
   SCOPED_TRACE(s);
 
   VerifyProtobufFormat(root);
 
-  std::optional<IRObject> obj = IRObject::FromString(s);
+  std::optional<IRObject> obj = IRObject{}.FromString<IRObject>(s);
   EXPECT_THAT(
       obj, Optional(SubsAre(
                ValueIs<std::string>("child1"), ValueIs<std::string>("child2"),
@@ -151,9 +159,10 @@
 }
 
 TEST(SerializerTest, EmptyObjectRoundTrips) {
-  std::string s = IRObject{}.ToString();
+  std::string s = IRObject{}.ToString<std::nullptr_t>();
   SCOPED_TRACE(s);
-  EXPECT_THAT(IRObject::FromString(s), Optional(ValueIs<std::monostate>({})));
+  EXPECT_THAT(IRObject{}.FromString<std::nullptr_t>(s),
+              Optional(ValueIs<std::monostate>({})));
 }
 
 TEST(SerializerTest, IndentationIsCorrect) {
@@ -169,7 +178,7 @@
                                            IRObject{uint64_t{322}}}}}},
                   IRObject{uint64_t{4}}}};
 
-  std::string s = root.ToString();
+  std::string s = root.ToString<IRObject>();
 
   EXPECT_EQ(s, R"(FUZZTESTv1
 sub { i: 1 }
@@ -185,50 +194,67 @@
 )");
 }
 
+// TODO(cnie0017): ensure the type passed in are correct
 // We manually write the serialized form to test the error handling of the
 // parser. The serializer would not generate these, so we can't use it.
 TEST(SerializerTest, WrongHeaderWontParse) {
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 i: 0"), Optional(_));
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv2"), Not(Optional(_)));
-  EXPECT_THAT(IRObject::FromString("FUZZtESTv1"), Not(Optional(_)));
-  EXPECT_THAT(IRObject::FromString("-FUZZTESTv1"), Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<std::int64_t>("FUZZTESTv1 i: 0"),
+              Optional(_));
+  EXPECT_THAT(IRObject{}.FromString<std::nullptr_t>("FUZZTESTv2"),
+              Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<std::nullptr_t>("FUZZtESTv1"),
+              Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<std::nullptr_t>("-FUZZTESTv1"),
+              Not(Optional(_)));
 }
 
 TEST(SerializerTest, HandlesUnterminatedString) {
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1\""), Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<std::nullptr_t>("FUZZTESTv1\""),
+              Not(Optional(_)));
 }
 
 TEST(SerializerTest, BadScalarWontParse) {
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 i: 1"),
+  EXPECT_THAT(IRObject{}.FromString<std::int64_t>("FUZZTESTv1 i: 1"),
               Optional(ValueIs<uint64_t>(1)));
   // Out of bounds values
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 i: 123456789012345678901"),
+  EXPECT_THAT(IRObject{}.FromString<std::int64_t>(
+                  "FUZZTESTv1 i: 123456789012345678901"),
               Not(Optional(_)));
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 i: -1"), Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<std::int64_t>("FUZZTESTv1 i: -1"),
+              Not(Optional(_)));
   // Missing :
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 i 1"), Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<std::int64_t>("FUZZTESTv1 i 1"),
+              Not(Optional(_)));
   // Bad tag
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 x: 1"), Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<std::int64_t>("FUZZTESTv1 x: 1"),
+              Not(Optional(_)));
   // Wrong separator
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 i; 1"), Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<std::int64_t>("FUZZTESTv1 i; 1"),
+              Not(Optional(_)));
   // Extra close
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 i: 1}"), Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<std::int64_t>("FUZZTESTv1 i: 1}"),
+              Not(Optional(_)));
 }
 
 TEST(SerializerTest, BadSubWontParse) {
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 sub { i: 0 }"),
+  EXPECT_THAT(IRObject{}.FromString<IRObject>("FUZZTESTv1 sub { i: 0 }"),
               Optional(SubsAre(ValueIs<uint64_t>(0))));
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 sub: { }"), Not(Optional(_)));
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 sub  }"), Not(Optional(_)));
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 sub { "), Not(Optional(_)));
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 sub { } }"), Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<IRObject>("FUZZTESTv1 sub: { }"),
+              Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<IRObject>("FUZZTESTv1 sub  }"),
+              Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<IRObject>("FUZZTESTv1 sub { "),
+              Not(Optional(_)));
+  EXPECT_THAT(IRObject{}.FromString<IRObject>("FUZZTESTv1 sub { } }"),
+              Not(Optional(_)));
 }
 
 TEST(SerializerTest, ExtraWhitespaceIsFine) {
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 i: 0 \n "),
+  EXPECT_THAT(IRObject{}.FromString<std::int64_t>("FUZZTESTv1 i: 0 \n "),
               Optional(ValueIs<uint64_t>(0)));
-  EXPECT_THAT(IRObject::FromString("FUZZTESTv1 sub {   \n i:   0 \n}  \n "),
-              Optional(SubsAre(ValueIs<uint64_t>(0))));
+  EXPECT_THAT(
+      IRObject{}.FromString<IRObject>("FUZZTESTv1 sub {   \n i:   0 \n}  \n "),
+      Optional(SubsAre(ValueIs<uint64_t>(0))));
 }
 
 template <typename T>
@@ -239,7 +265,7 @@
   obj.SetScalar(value);
   EXPECT_THAT(obj.GetScalar<T>(), Optional(value));
 
-  auto roundtrip = IRObject::FromString(obj.ToString());
+  auto roundtrip = IRObject{}.FromString<IRObject>(obj.ToString<IRObject>());
   EXPECT_THAT(obj.GetScalar<T>(), Optional(value));
 }
 
@@ -383,6 +409,51 @@
                    .ToCorpus<Tuple>());
 }
 
+TEST(SerializerTest, SingleStringValueIsSerializedAsRawString) {
+  std::string s("ABC");
+  IRObject obj;
+  obj.value = s;
+  std::string s_serialized = obj.ToString<std::string>();
+
+  // Should have no header.
+  EXPECT_THAT(s_serialized, Not(HasSubstr("FUZZTESTv1\n")));
+  EXPECT_EQ(s, s_serialized);
+}
+
+TEST(SerializerTest, SingleProtoValueIsSerializaedAsRawString) {
+  IRObjectTestProto proto;
+  IRObject obj = IRObject::FromCorpus(proto);
+  std::string proto_serialized = obj.ToString<IRObjectTestProto>();
+
+  // Should have no header.
+  EXPECT_THAT(proto_serialized, Not(HasSubstr("FUZZTESTv1\n")));
+  ASSERT_TRUE(google::protobuf::TextFormat::ParseFromString(proto_serialized, &proto));
+  std::visit(VerifyVisitor{proto}, obj.value);
+}
+
+TEST(SerializerTest, SingleStringSerializationRoundTripVerify) {
+  std::string s("ABC");
+  IRObject obj;
+  obj.value = s;
+  std::string s_serialized = obj.ToString<std::string>();
+  std::optional<IRObject> obj_from_str =
+      IRObject{}.FromString<std::string>(s_serialized);
+
+  EXPECT_THAT(obj_from_str, Optional(ValueIs<std::string>(s)));
+}
+
+TEST(SerializerTest, SingleProtoSerializationRoundTripVerify) {
+  IRObjectTestProto proto;
+  std::string proto_str;
+  ASSERT_TRUE(google::protobuf::TextFormat::PrintToString(proto, &proto_str));
+  IRObject obj = IRObject::FromCorpus(proto);
+  std::string proto_serialized = obj.ToString<IRObjectTestProto>();
+  std::optional<IRObject> obj_from_str =
+      IRObject{}.FromString<std::string>(proto_serialized);
+
+  EXPECT_THAT(obj_from_str, Optional(ValueIs<std::string>(proto_str)));
+}
+
 // TODO(sbenzaquen): Add tests for failing conditions in the IR->Corpus conversion.
 
 }  // namespace