diff --git a/dump/dump_collect_main.cpp b/dump/dump_collect_main.cpp
new file mode 100644
index 0000000..c77b089
--- /dev/null
+++ b/dump/dump_collect_main.cpp
@@ -0,0 +1,82 @@
+#include "sbe_consts.hpp"
+#include "sbe_dump_collector.hpp"
+
+#include <CLI/App.hpp>
+#include <CLI/Config.hpp>
+#include <CLI/Formatter.hpp>
+
+#include <filesystem>
+#include <iostream>
+
+int main(int argc, char** argv)
+{
+    using namespace openpower::dump::sbe_chipop;
+    using std::filesystem::path;
+    using namespace openpower::dump::SBE;
+
+    CLI::App app{"Dump Collector Application", "dump-collect"};
+    app.description(
+        "Collects dumps from the Self Boot Engine (SBE) based on "
+        "provided parameters.\nSupports different types of dumps and requires "
+        "specific options based on the dump type.");
+
+    int type = 0;
+    uint32_t id;
+    std::string pathStr;
+    std::optional<uint64_t> failingUnit;
+
+    app.add_option("--type, -t", type, "Type of the dump")
+        ->required()
+        ->check(
+            CLI::IsMember({SBE_DUMP_TYPE_HARDWARE, SBE_DUMP_TYPE_HOSTBOOT}));
+
+    app.add_option("--id, -i", id, "ID of the dump")->required();
+
+    app.add_option("--path, -p", pathStr,
+                   "Path to store the collected dump files")
+        ->required();
+
+    app.add_option("--failingunit, -f", failingUnit, "ID of the failing unit");
+
+    try
+    {
+        CLI11_PARSE(app, argc, argv);
+    }
+    catch (const CLI::ParseError& e)
+    {
+        return app.exit(e);
+    }
+
+    if (type == SBE_DUMP_TYPE_HARDWARE && !failingUnit.has_value())
+    {
+        std::cerr << "Failing unit ID is required for Hardware type dumps\n";
+        return EXIT_FAILURE;
+    }
+
+    // Directory creation should happen here, after successful parsing
+    std::filesystem::path dirPath{pathStr};
+    if (!std::filesystem::exists(dirPath))
+    {
+        std::filesystem::create_directories(dirPath);
+    }
+
+    SbeDumpCollector dumpCollector;
+
+    auto failingUnitId = 0xFFFFFF; // Default or unspecified value
+    if (failingUnit.has_value())
+    {
+        failingUnitId = failingUnit.value();
+    }
+
+    try
+    {
+        dumpCollector.collectDump(type, id, failingUnitId, pathStr);
+    }
+    catch (const std::exception& e)
+    {
+        std::cerr << "Failed to collect dump: " << e.what() << std::endl;
+        std::exit(EXIT_FAILURE);
+    }
+
+    return 0;
+}
diff --git a/dump/dump_utils.cpp b/dump/dump_utils.cpp
new file mode 100644
index 0000000..81b1cc3
--- /dev/null
+++ b/dump/dump_utils.cpp
@@ -0,0 +1,56 @@
+#include "dump_utils.hpp"
+
+#include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <phosphor-logging/lg2.hpp>
+#include <phosphor-logging/log.hpp>
+#include <xyz/openbmc_project/Common/File/error.hpp>
+
+#include <format>
+#include <fstream>
+#include <string>
+
+namespace openpower::dump::util
+{
+using namespace phosphor::logging;
+
+std::string getService(sdbusplus::bus::bus& bus, const std::string& intf,
+                       const std::string& path)
+{
+    constexpr auto MAPPER_BUSNAME = "xyz.openbmc_project.ObjectMapper";
+    constexpr auto MAPPER_PATH = "/xyz/openbmc_project/object_mapper";
+    constexpr auto MAPPER_INTERFACE = "xyz.openbmc_project.ObjectMapper";
+    try
+    {
+        auto mapper = bus.new_method_call(MAPPER_BUSNAME, MAPPER_PATH,
+                                          MAPPER_INTERFACE, "GetObject");
+
+        mapper.append(path, std::vector<std::string>({intf}));
+
+        auto mapperResponseMsg = bus.call(mapper);
+        std::map<std::string, std::vector<std::string>> mapperResponse;
+        mapperResponseMsg.read(mapperResponse);
+
+        if (mapperResponse.empty())
+        {
+            lg2::error(
+                "Empty mapper response for GetObject interface({INTERFACE}), "
+                "path({PATH})",
+                "INTERFACE", intf, "PATH", path);
+
+            throw std::runtime_error("Empty mapper response for GetObject");
+        }
+        return mapperResponse.begin()->first;
+    }
+    catch (const sdbusplus::exception::exception& ex)
+    {
+        lg2::error(
+            "Mapper call failed for GetObject errorMsg({ERROR}), path({PATH}),"
+            "interface({INTERFACE})",
+            "ERROR", ex, "PATH", path, "INTERFACE", intf);
+
+        throw;
+    }
+}
+
+} // namespace openpower::dump::util
diff --git a/dump/dump_utils.hpp b/dump/dump_utils.hpp
new file mode 100644
index 0000000..8918024
--- /dev/null
+++ b/dump/dump_utils.hpp
@@ -0,0 +1,84 @@
+#pragma once
+
+#include <sdbusplus/server.hpp>
+
+#include <filesystem>
+#include <map>
+#include <string>
+#include <variant>
+namespace openpower::dump::util
+{
+
+using DumpCreateParams =
+    std::map<std::string, std::variant<std::string, uint64_t>>;
+
+/** @struct DumpPtr
+ * @brief a structure holding the data pointer
+ * @details This is a RAII container for the dump data
+ * returned by the SBE
+ */
+struct DumpDataPtr
+{
+  public:
+    /** @brief Destructor for the object, free the allocated memory.
+     */
+    ~DumpDataPtr()
+    {
+        // The memory is allocated using malloc
+        free(dataPtr);
+    }
+    /** @brief Returns the pointer to the data
+     */
+    uint8_t** getPtr()
+    {
+        return &dataPtr;
+    }
+    /** @brief Returns the stored data
+     */
+    uint8_t* getData()
+    {
+        return dataPtr;
+    }
+
+  private:
+    /** The pointer to the data */
+    uint8_t* dataPtr = nullptr;
+};
+
+/**
+ * @brief Get DBUS service for input interface via mapper call
+ *
+ * @param[in] bus -  DBUS Bus Object
+ * @param[in] intf - DBUS Interface
+ * @param[in] path - DBUS Object Path
+ *
+ * @return distinct dbus name for input interface/path
+ **/
+std::string getService(sdbusplus::bus::bus& bus, const std::string& intf,
+                       const std::string& path);
+
+/**
+ * @brief Set the property value based on the inputs
+ *
+ * @param[in] interface - the interface the property is on
+ * @param[in] propertName - the name of the property
+ * @param[in] path - the D-Bus path
+ * @param[in] service - the D-Bus service
+ * @param[in] bus - the D-Bus object
+ * @param[in] value - the value to set the property to
+ */
+template <typename T>
+void setProperty(const std::string& interface, const std::string& propertyName,
+                 const std::string& path, sdbusplus::bus::bus& bus,
+                 const T& value)
+{
+    constexpr auto PROPERTY_INTF = "org.freedesktop.DBus.Properties";
+
+    auto service = getService(bus, interface, path);
+    auto method = bus.new_method_call(service.c_str(), path.c_str(),
+                                      PROPERTY_INTF, "Set");
+    method.append(interface, propertyName, value);
+    auto reply = bus.call(method);
+}
+
+} // namespace openpower::dump::util
diff --git a/dump/meson.build b/dump/meson.build
new file mode 100644
index 0000000..45140d0
--- /dev/null
+++ b/dump/meson.build
@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cxx = meson.get_compiler('cpp')
+
+collect_deps = [
+   CLI11_dep,
+   phosphorlogging,
+   cxx.find_library('pdbg'),
+   cxx.find_library('libdt-api'),
+   cxx.find_library('phal'),
+]
+
+# source files
+
+collect_src = files(
+    'sbe_dump_collector.cpp',
+    'dump_collect_main.cpp',
+    'dump_utils.cpp',
+)
+
+executable('dump-collect',
+    collect_src,
+    dependencies: collect_deps,
+    implicit_include_directories: true,
+    install: true
+)
diff --git a/dump/sbe_consts.hpp b/dump/sbe_consts.hpp
new file mode 100644
index 0000000..9fea1f0
--- /dev/null
+++ b/dump/sbe_consts.hpp
@@ -0,0 +1,18 @@
+#pragma once
+namespace openpower::dump::SBE
+{
+// Dump type to the sbe_dump chipop
+constexpr auto SBE_DUMP_TYPE_HOSTBOOT = 0x5;
+constexpr auto SBE_DUMP_TYPE_HARDWARE = 0x1;
+
+// SBE dump type
+constexpr auto SBE_DUMP_TYPE_SBE = 0xA;
+
+// Clock state requested
+// Collect the dump with clocks on
+constexpr auto SBE_CLOCK_ON = 0x1;
+
+// Collect the dumps with clock off
+constexpr auto SBE_CLOCK_OFF = 0x2;
+
+} // namespace openpower::dump::SBE
diff --git a/dump/sbe_dump_collector.cpp b/dump/sbe_dump_collector.cpp
new file mode 100644
index 0000000..5f0f83f
--- /dev/null
+++ b/dump/sbe_dump_collector.cpp
@@ -0,0 +1,120 @@
+extern "C"
+{
+#include <libpdbg.h>
+#include <libpdbg_sbe.h>
+}
+
+#include "sbe_consts.hpp"
+#include "sbe_dump_collector.hpp"
+
+#include <libphal.H>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <phosphor-logging/lg2.hpp>
+#include <phosphor-logging/log.hpp>
+
+#include <format>
+#include <stdexcept>
+
+namespace openpower::dump::sbe_chipop
+{
+
+using namespace phosphor::logging;
+using namespace openpower::dump::SBE;
+
+void SbeDumpCollector::collectDump(uint8_t type, uint32_t id,
+                                   uint64_t failingUnit,
+                                   const std::filesystem::path& path)
+{
+    lg2::error("Starting dump collection: type:{TYPE} id:{ID} "
+               "failingUnit:{FAILINGUNIT}, path:{PATH}",
+               "TYPE", type, "ID", id, "FAILINGUNIT", failingUnit, "PATH",
+               path.string());
+
+    initializePdbg();
+
+    std::vector<struct pdbg_target*> targets;
+
+    struct pdbg_target* target = nullptr;
+    pdbg_for_each_class_target("proc", target)
+    {
+        if (pdbg_target_probe(target) != PDBG_TARGET_ENABLED ||
+            !openpower::phal::pdbg::isTgtFunctional(target))
+        {
+            continue;
+        }
+
+        targets.push_back(target);
+    }
+
+    std::vector<uint8_t> clockStates = {SBE_CLOCK_ON, SBE_CLOCK_OFF};
+    for (auto cstate : clockStates)
+    {
+        auto futures = spawnDumpCollectionProcesses(type, id, path, failingUnit,
+                                                    cstate, targets);
+
+        // Wait for all asynchronous tasks to complete
+        for (auto& future : futures)
+        {
+            future.wait();
+        }
+        lg2::info(
+            "Dump collection completed for clock state({CSTATE}): type({TYPE}) "
+            "id({ID}) failingUnit({FAILINGUNIT}), path({PATH})",
+            "CSTATE", cstate, "TYPE", type, "ID", id, "FAILINGUNIT",
+            failingUnit, "PATH", path.string());
+    }
+
+    lg2::info("Dump collection completed");
+}
+
+void SbeDumpCollector::initializePdbg()
+{
+    openpower::phal::pdbg::init();
+}
+
+std::vector<std::future<void>> SbeDumpCollector::spawnDumpCollectionProcesses(
+    uint8_t type, uint32_t id, const std::filesystem::path& path,
+    uint64_t failingUnit, uint8_t cstate,
+    const std::vector<struct pdbg_target*>& targets)
+{
+    std::vector<std::future<void>> futures;
+
+    for (auto target : targets)
+    {
+        if (pdbg_target_probe(target) != PDBG_TARGET_ENABLED ||
+            !openpower::phal::pdbg::isTgtFunctional(target))
+        {
+            continue;
+        }
+
+        // Launch an asynchronous task instead of forking
+        auto future =
+            std::async(std::launch::async,
+                       [this, target, path, id, type, cstate, failingUnit]() {
+            this->collectDumpFromSBE(target, path, id, type, cstate,
+                                     failingUnit);
+        });
+
+        futures.push_back(std::move(future));
+    }
+
+    return futures;
+}
+
+void SbeDumpCollector::collectDumpFromSBE(struct pdbg_target* chip,
+                                          const std::filesystem::path& path,
+                                          uint32_t id, uint8_t type,
+                                          uint8_t clockState,
+                                          uint64_t failingUnit)
+{
+    auto chipPos = pdbg_target_index(chip);
+    lg2::info(
+        "Collecting dump from proc({PROC}): path({PATH}) id({ID}) "
+        "type({TYPE}) clockState({CLOCKSTATE}) failingUnit({FAILINGUNIT})",
+        "PROC", chipPos, "PATH", path.string(), "ID", id, "TYPE", type,
+        "CLOCKSTATE", clockState, "FAILINGUNIT", failingUnit);
+}
+
+} // namespace openpower::dump::sbe_chipop
diff --git a/dump/sbe_dump_collector.hpp b/dump/sbe_dump_collector.hpp
new file mode 100644
index 0000000..000022c
--- /dev/null
+++ b/dump/sbe_dump_collector.hpp
@@ -0,0 +1,119 @@
+#pragma once
+
+extern "C"
+{
+#include <libpdbg.h>
+#include <libpdbg_sbe.h>
+}
+
+#include <cstdint>
+#include <filesystem>
+#include <future>
+#include <vector>
+
+namespace openpower::dump::sbe_chipop
+{
+
+/**
+ * @class SbeDumpCollector
+ * @brief Manages the collection of dumps from SBEs on failure.
+ *
+ * This class provides functionalities to orchestrate the collection of
+ * diagnostic dumps from Self Boot Engines across multiple processors
+ * in response to failures or for diagnostic purposes.
+ */
+class SbeDumpCollector
+{
+  public:
+    /**
+     * @brief Constructs a new SbeDumpCollector object.
+     */
+    SbeDumpCollector() = default;
+
+    /**
+     * @brief Destroys the SbeDumpCollector object.
+     */
+    ~SbeDumpCollector() = default;
+
+    /**
+     * @brief Orchestrates the collection of dumps from all available SBEs.
+     *
+     * Initiates the process of collecting diagnostic dumps from SBEs. This
+     * involves identifying available processors, initiating the dump
+     * collection process, and managing the collected dump files.
+     *
+     * @param type The type of dump to collect.
+     * @param id A unique identifier for the dump collection operation.
+     * @param failingUnit The identifier of the failing unit prompting the dump
+     * collection.
+     * @param path The filesystem path where collected dumps should be stored.
+     */
+    void collectDump(uint8_t type, uint32_t id, uint64_t failingUnit,
+                     const std::filesystem::path& path);
+
+  private:
+    /**
+     * @brief Collects a dump from a single SBE.
+     *
+     * Executes the low-level operations required to collect a diagnostic
+     * dump from the specified SBE.
+     *
+     * @param chip A pointer to the pdbg_target structure representing the SBE.
+     * @param path The filesystem path where the dump should be stored.
+     * @param id The unique identifier for this dump collection operation.
+     * @param type The type of dump to collect.
+     * @param clockState The clock state of the SBE during dump collection.
+     * @param failingUnit The identifier of the failing unit.
+     */
+    void collectDumpFromSBE(struct pdbg_target* chip,
+                            const std::filesystem::path& path, uint32_t id,
+                            uint8_t type, uint8_t clockState,
+                            uint64_t failingUnit);
+
+    /**
+     * @brief Initializes the PDBG library.
+     *
+     * Prepares the PDBG library for interacting with processor targets. This
+     * must be called before any PDBG-related operations are performed.
+     */
+    void initializePdbg();
+
+    /**
+     * @brief Launches asynchronous dump collection tasks for a set of targets.
+     *
+     * This method initiates the dump collection process asynchronously for each
+     * target provided in the `targets` vector. It launches a separate
+     * asynchronous task for each target, where each task calls
+     * `collectDumpFromSBE` with the specified parameters, including the clock
+     * state.
+     *
+     * @param type The type of the dump to collect. This could be a hardware
+     * dump, software dump, etc., as defined by the SBE dump type enumeration.
+     * @param id A unique identifier for the dump collection operation. This ID
+     * is used to tag the collected dump for identification.
+     * @param path The filesystem path where the collected dumps should be
+     * stored. Each dump file will be stored under this directory.
+     * @param failingUnit The identifier of the unit or component that is
+     * failing or suspected to be the cause of the issue prompting the dump
+     * collection. This is used for diagnostic purposes.
+     * @param cstate The clock state during the dump collection. This parameter
+     *               dictates whether the dump should be collected with the
+     * clocks running (SBE_CLOCK_ON) or with the clocks stopped (SBE_CLOCK_OFF).
+     * @param targets A vector of `pdbg_target*` representing the targets from
+     * which dumps should be collected. Each target corresponds to a physical or
+     * logical component in the system, such as a processor or an SBE.
+     *
+     * @return A vector of `std::future<void>` objects. Each future represents
+     * the completion state of an asynchronous dump collection task. The caller
+     *         can wait on these futures to determine when all dump collection
+     * tasks have completed. Exceptions thrown by the asynchronous tasks are
+     * captured by the futures and can be rethrown when the futures are
+     * accessed.
+     */
+    std::vector<std::future<void>> spawnDumpCollectionProcesses(
+        uint8_t type, uint32_t id, const std::filesystem::path& path,
+        uint64_t failingUnit, uint8_t cstate,
+        const std::vector<struct pdbg_target*>& targets);
+};
+
+} // namespace openpower::dump::sbe_chipop
diff --git a/meson.build b/meson.build
index 94dabd2..9c01593 100644
--- a/meson.build
+++ b/meson.build
@@ -48,6 +48,10 @@
 
 configure_file(output: 'config.h', configuration: conf_data)
 
+if get_option('dump-collection').enabled()
+    subdir('dump')
+endif
+
 deps = [
     CLI11_dep,
     sdbusplus_dep,
diff --git a/meson.options b/meson.options
index c271593..124926d 100644
--- a/meson.options
+++ b/meson.options
@@ -1,5 +1,12 @@
+# SPDX-License-Identifier: Apache-2.0
+
 # Feature to enable hostboot dump collection when watchdog times out
 option('hostboot-dump-collection',
        type: 'feature',
        value: 'disabled',
        description : 'Enables hostboot dump collection')
+
+# Feature to enable the dump collection
+option('dump-collection', type: 'feature',
+       value : 'disabled',
+       description : 'Enables dump collection')