diff --git a/centipede/batch_fuzz_example/BUILD b/centipede/batch_fuzz_example/BUILD
index 774a6e9..b5f77b1 100644
--- a/centipede/batch_fuzz_example/BUILD
+++ b/centipede/batch_fuzz_example/BUILD
@@ -27,3 +27,26 @@
         "@com_google_fuzztest//centipede:centipede_runner_no_main",  # build-cleaner:keep
     ],
 )
+
+cc_binary(
+    name = "customized_centipede",
+    srcs = ["customized_centipede.cc"],
+    deps = [
+        "@com_google_absl//absl/base:log_severity",
+        "@com_google_absl//absl/flags:parse",
+        "@com_google_absl//absl/log",
+        "@com_google_absl//absl/log:check",
+        "@com_google_absl//absl/log:globals",
+        "@com_google_absl//absl/log:initialize",
+        "@com_google_absl//absl/strings",
+        "@com_google_fuzztest//centipede:centipede_callbacks",
+        "@com_google_fuzztest//centipede:centipede_interface",
+        "@com_google_fuzztest//centipede:command",
+        "@com_google_fuzztest//centipede:config_file",
+        "@com_google_fuzztest//centipede:defs",
+        "@com_google_fuzztest//centipede:environment",
+        "@com_google_fuzztest//centipede:execution_result",
+        "@com_google_fuzztest//centipede:shared_memory_blob_sequence",
+        "@com_google_fuzztest//centipede:util",
+    ],
+)
diff --git a/centipede/batch_fuzz_example/customized_centipede.cc b/centipede/batch_fuzz_example/customized_centipede.cc
new file mode 100644
index 0000000..a686396
--- /dev/null
+++ b/centipede/batch_fuzz_example/customized_centipede.cc
@@ -0,0 +1,141 @@
+// Copyright 2023 The Centipede Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <sys/types.h>
+
+#include <string>
+#include <vector>
+
+#include "absl/base/log_severity.h"
+#include "absl/flags/parse.h"
+#include "absl/log/check.h"
+#include "absl/log/globals.h"
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "./centipede/centipede_callbacks.h"
+#include "./centipede/centipede_interface.h"
+#include "./centipede/command.h"
+#include "./centipede/config_file.h"
+#include "./centipede/defs.h"
+#include "./centipede/environment.h"
+#include "./centipede/execution_result.h"
+#include "./centipede/shared_memory_blob_sequence.h"
+#include "./centipede/util.h"
+
+namespace centipede {
+namespace {
+
+bool UpdateBatchResult(absl::string_view output_file,
+                       BatchResult& batch_result) {
+  ByteArray content;
+  ReadFromLocalFile(output_file, content);
+  if (content.empty()) {
+    LOG(WARNING) << "Skip updating batch result with an emtpy output file: "
+                 << output_file;
+    return true;
+  }
+
+  BlobSequence blob_seq(content.data(), content.size());
+  if (batch_result.Read(blob_seq)) return true;
+
+  LOG(ERROR) << "Failed to read blob sequence from file: " << output_file;
+  return false;
+}
+
+// This class implements the `Execute()` method of the `CentipedeCallbacks`
+// class. It saves a collection of inputs into files and passes them to a target
+// binary. The binary should exercise them in a batch and store the execution
+// result of each input into an output file. Those execution results will be
+// loaded from the output file and packed as the given `batch_result`.
+class CustomizedCallbacks : public CentipedeCallbacks {
+ public:
+  explicit CustomizedCallbacks(const Environment& env)
+      : CentipedeCallbacks(env) {}
+
+  bool Execute(std::string_view binary, const std::vector<ByteArray>& inputs,
+               BatchResult& batch_result) override {
+    const std::string temp_dir = TemporaryLocalDirPath();
+    CHECK(!temp_dir.empty());
+    std::filesystem::create_directory(temp_dir);
+
+    std::string input_file_list;
+    int index = 0;
+    for (const auto& input : inputs) {
+      const std::string temp_file_path = std::filesystem::path(temp_dir).append(
+          absl::StrCat("input-", index++));
+      WriteToLocalFile(temp_file_path, input);
+      absl::StrAppend(&input_file_list, temp_file_path);
+      absl::StrAppend(&input_file_list, "\n");
+    }
+    const std::string input_list_filepath =
+        std::filesystem::path(temp_dir).append("input_file_list");
+    WriteToLocalFile(input_list_filepath, input_file_list);
+
+    const std::string tmp_output_filepath =
+        std::filesystem::path(temp_dir).append("output_execution_results");
+    const std::string tmp_log_filepath =
+        std::filesystem::path(temp_dir).append("tmp_log");
+
+    // Execute.
+    Command cmd{env_.binary,
+                {input_list_filepath, tmp_output_filepath},
+                // TODO: pass additional runner flags, such as use_cmp_features,
+                // based on `env`. Will require a small refactoring.
+                /*env=*/{},
+                tmp_log_filepath,
+                tmp_log_filepath};
+    const int retval = cmd.Execute();
+
+    std::string tmp_log;
+    ReadFromLocalFile(tmp_log_filepath, tmp_log);
+    LOG(INFO) << tmp_log;
+
+    batch_result.ClearAndResize(inputs.size());
+    CHECK(UpdateBatchResult(tmp_output_filepath, batch_result));
+    return retval == 0;
+  }
+};
+}  // namespace
+}  // namespace centipede
+
+int main(int argc, char** argv) {
+  // TODO: Refactoring the following code into a utility function that takes
+  // callbacks_factory as an argument.
+  const centipede::config::MainRuntimeInit runtime_init =
+      [](int argc, char** argv) -> std::vector<std::string> {
+    // NB: The invocation order is important here.
+    // By default, log everything to stderr. Explicit --stderrthreshold=N on the
+    // command line takes precedence.
+    absl::SetStderrThreshold(absl::LogSeverityAtLeast::kInfo);
+    // Perform the initial command line parsing.
+    std::vector<std::string> leftover_argv =
+        centipede::config::CastArgv(absl::ParseCommandLine(argc, argv));
+    // Initialize the logging subsystem.
+    absl::InitializeLog();
+    return leftover_argv;
+  };
+
+  // Resolve any possible config-related flags in the command line and reparse
+  // it if any augmentations had to be made.
+  const auto leftover_argv =
+      centipede::config::InitCentipede(argc, argv, runtime_init);
+
+  // Reads flags; must happen after ParseCommandLine().
+  centipede::Environment env{leftover_argv};
+  centipede::DefaultCallbacksFactory<centipede::CustomizedCallbacks>
+      callbacks_factory;
+  return CentipedeMain(env, callbacks_factory);
+}