diff --git a/common/transport.cpp b/common/transport.cpp
new file mode 100644
index 0000000..d992415
--- /dev/null
+++ b/common/transport.cpp
@@ -0,0 +1,159 @@
+#include "common/transport.hpp"
+
+#include <libpldm/transport.h>
+#include <libpldm/transport/af-mctp.h>
+#include <libpldm/transport/mctp-demux.h>
+
+#include <algorithm>
+#include <ranges>
+#include <system_error>
+
+struct pldm_transport* transport_impl_init(TransportImpl& impl, pollfd& pollfd);
+void transport_impl_destroy(TransportImpl& impl);
+
+static constexpr uint8_t MCTP_EID_VALID_MIN = 8;
+static constexpr uint8_t MCTP_EID_VALID_MAX = 255;
+
+/*
+ * Currently the OpenBMC ecosystem assumes TID == EID. Pre-populate the TID
+ * mappings over the EID space excluding the Null (0), Reserved (1 to 7),
+ * Broadcast EIDs (255) defined by Section 8.2 Special endpoint IDs in DSP0236
+ * v1.3.1. Further, by Section 8.1.1 SetTID command (0x01) in DSP0240 v1.1.0,
+ * the TIDs 0x00 and 0xff are also reserved. These overlap with the reserved
+ * EIDs so no additional filtering is required.
+ *
+ * Further, pldmtool and pldmd are two separate processes. They are opening two
+ * different sockets, but with the mctp-demux-daemon, the response messages are
+ * broadcasted to all sockets. When pldmd receives the response for a request
+ * issued by pldmtool, pldm_transport_mctp_demux_recv() may return with error
+ * PLDM_REQUESTER_RECV_FAIL if it fails to map the EID of the source endpoint to
+ * its TID. The EID to TID mappings of pldmtool and pldmd should be coherent to
+ * prevent the failure of pldm_transport_mctp_demux_recv().
+ */
+
+[[maybe_unused]] static struct pldm_transport*
+    pldm_transport_impl_mctp_demux_init(TransportImpl& impl, pollfd& pollfd)
+{
+    impl.mctp_demux = nullptr;
+    pldm_transport_mctp_demux_init(&impl.mctp_demux);
+    if (!impl.mctp_demux)
+    {
+        return nullptr;
+    }
+
+    for (const auto eid :
+         std::views::iota(MCTP_EID_VALID_MIN, MCTP_EID_VALID_MAX))
+    {
+        int rc = pldm_transport_mctp_demux_map_tid(impl.mctp_demux, eid, eid);
+        if (rc)
+        {
+            pldm_transport_af_mctp_destroy(impl.af_mctp);
+            return nullptr;
+        }
+    }
+
+    pldm_transport* pldmTransport =
+        pldm_transport_mctp_demux_core(impl.mctp_demux);
+
+    if (pldmTransport != nullptr)
+    {
+        pldm_transport_mctp_demux_init_pollfd(pldmTransport, &pollfd);
+    }
+
+    return pldmTransport;
+}
+
+[[maybe_unused]] static struct pldm_transport*
+    pldm_transport_impl_af_mctp_init(TransportImpl& impl, pollfd& pollfd)
+{
+    impl.af_mctp = nullptr;
+    pldm_transport_af_mctp_init(&impl.af_mctp);
+    if (!impl.af_mctp)
+    {
+        return nullptr;
+    }
+
+    for (const auto eid :
+         std::views::iota(MCTP_EID_VALID_MIN, MCTP_EID_VALID_MAX))
+    {
+        int rc = pldm_transport_af_mctp_map_tid(impl.af_mctp, eid, eid);
+        if (rc)
+        {
+            pldm_transport_af_mctp_destroy(impl.af_mctp);
+            return nullptr;
+        }
+    }
+
+    /* Listen for requests on any interface */
+    if (pldm_transport_af_mctp_bind(impl.af_mctp, nullptr, 0))
+    {
+        return nullptr;
+    }
+
+    pldm_transport* pldmTransport = pldm_transport_af_mctp_core(impl.af_mctp);
+
+    if (pldmTransport != nullptr)
+    {
+        pldm_transport_af_mctp_init_pollfd(pldmTransport, &pollfd);
+    }
+
+    return pldmTransport;
+}
+
+struct pldm_transport* transport_impl_init(TransportImpl& impl, pollfd& pollfd)
+{
+#if defined(PLDM_TRANSPORT_WITH_MCTP_DEMUX)
+    return pldm_transport_impl_mctp_demux_init(impl, pollfd);
+#elif defined(PLDM_TRANSPORT_WITH_AF_MCTP)
+    return pldm_transport_impl_af_mctp_init(impl, pollfd);
+#else
+    return nullptr;
+#endif
+}
+
+void transport_impl_destroy(TransportImpl& impl)
+{
+#if defined(PLDM_TRANSPORT_WITH_MCTP_DEMUX)
+    pldm_transport_mctp_demux_destroy(impl.mctp_demux);
+#elif defined(PLDM_TRANSPORT_WITH_AF_MCTP)
+    pldm_transport_af_mctp_destroy(impl.af_mctp);
+#endif
+}
+
+PldmTransport::PldmTransport()
+{
+    transport = transport_impl_init(impl, pfd);
+    if (!transport)
+    {
+        throw std::system_error(ENOMEM, std::generic_category());
+    }
+}
+
+PldmTransport::~PldmTransport()
+{
+    transport_impl_destroy(impl);
+}
+
+int PldmTransport::getEventSource() const
+{
+    return pfd.fd;
+}
+
+pldm_requester_rc_t PldmTransport::sendMsg(pldm_tid_t tid, const void* tx,
+                                           size_t len)
+{
+    return pldm_transport_send_msg(transport, tid, tx, len);
+}
+
+pldm_requester_rc_t PldmTransport::recvMsg(pldm_tid_t& tid, void*& rx,
+                                           size_t& len)
+{
+    return pldm_transport_recv_msg(transport, &tid, (void**)&rx, &len);
+}
+
+pldm_requester_rc_t PldmTransport::sendRecvMsg(pldm_tid_t tid, const void* tx,
+                                               size_t txLen, void*& rx,
+                                               size_t& rxLen)
+{
+    return pldm_transport_send_recv_msg(transport, tid, tx, txLen, &rx, &rxLen);
+}
diff --git a/common/transport.hpp b/common/transport.hpp
new file mode 100644
index 0000000..0601488
--- /dev/null
+++ b/common/transport.hpp
@@ -0,0 +1,105 @@
+#pragma once
+
+#include <libpldm/base.h>
+#include <libpldm/pldm.h>
+#include <poll.h>
+#include <stddef.h>
+
+struct pldm_transport_mctp_demux;
+struct pldm_transport_af_mctp;
+
+union TransportImpl
+{
+    struct pldm_transport_mctp_demux* mctp_demux;
+    struct pldm_transport_af_mctp* af_mctp;
+};
+
+/* RAII for pldm_transport */
+class PldmTransport
+{
+  public:
+    PldmTransport();
+    PldmTransport(const PldmTransport& other) = delete;
+    PldmTransport(const PldmTransport&& other) = delete;
+    PldmTransport& operator=(const PldmTransport& other) = delete;
+    PldmTransport& operator=(const PldmTransport&& other) = delete;
+    ~PldmTransport();
+
+    /** @brief Provides a file descriptor that can be polled for readiness.
+     *
+     * Readiness generally indicates that a call to recvMsg() will immediately
+     * yield a message.
+     *
+     * @return The relevant file descriptor.
+     */
+    int getEventSource() const;
+
+    /** @brief Asynchronously send a PLDM message to the specified terminus
+     *
+     * The message may be either a request or a response.
+     *
+     * @param[in] tid - The terminus ID of the message destination
+     * @param[in] tx - The encoded and framed message to send
+     * @param[in] len - The length of the buffer pointed-to by tx
+     *
+     * @return PLDM_REQUESTER_SUCCESS on success, otherwise an appropriate
+     *         PLDM_REQUESTER_* error code.
+     */
+    pldm_requester_rc_t sendMsg(pldm_tid_t tid, const void* tx, size_t len);
+
+    /** @brief Asynchronously receive a PLDM message addressed to the local
+     * terminus
+     *
+     * The message may be either a request or a response.
+     *
+     * @param[out] tid - The terminus ID of the message source
+     * @param[out] rx - A pointer to the received, encoded message
+     * @param[out] len - The length of the buffer pointed-to by rx
+     *
+     * @return PLDM_REQUESTER_SUCCESS on success, otherwise an appropriate
+     *         PLDM_REQUESTER_* error code.
+     */
+    pldm_requester_rc_t recvMsg(pldm_tid_t& tid, void*& rx, size_t& len);
+
+    /** @brief Synchronously exchange a request and response with the specified
+     * terminus.
+     *
+     * sendRecvMsg() is a wrapper for the non-compliant
+     * pldm_transport_send_recv_msg() API from libpldm. It is a crutch that may
+     * be used for to fulfil a PLDM request until libpldm implements a correct
+     * requester flow in accordance with the PLDM base specification (DSP0240).
+     *
+     * The implementation blocks after the request is sent until a response is
+     * received, or the upper time-bound on a PLDM exchange is reached. Control
+     * is only handed back to the caller once one of these two outcomes is
+     * achieved.
+     *
+     * @param[in] tid - The terminus ID of the endpoint with which the exchange
+     *                  will occur
+     * @param[in] tx - The encoded and framed message to send
+     * @param[in] txLen - The length of the buffer pointed-to by tx
+     * @param[out] rx - A pointer to the received, encoded message
+     * @param[out] rxLen - The length of the buffer pointed-to by rx
+     *
+     * @return PLDM_REQUESTER_SUCCESS on success, otherwise an appropriate
+     *         PLDM_REQUESTER_* error code.
+     */
+    pldm_requester_rc_t sendRecvMsg(pldm_tid_t tid, const void* tx,
+                                    size_t txLen, void*& rx, size_t& rxLen);
+
+  private:
+    /** @brief A pollfd object for holding a file descriptor from the libpldm
+     *         transport implementation
+     */
+    pollfd pfd;
+
+    /** @brief A union holding an appropriately-typed pointer to the selected
+     *         libpldm transport implementation
+     */
+    TransportImpl impl;
+
+    /** @brief The abstract libpldm transport object for sending and receiving
+     *         PLDM messages.
+     */
+    struct pldm_transport* transport;
+};
diff --git a/fw-update/inventory_manager.hpp b/fw-update/inventory_manager.hpp
index fdb6369..a2e86ad 100644
--- a/fw-update/inventory_manager.hpp
+++ b/fw-update/inventory_manager.hpp
@@ -4,8 +4,6 @@
 #include "common/types.hpp"
 #include "requester/handler.hpp"
 
-#include <libpldm/pldm.h>
-
 namespace pldm
 {
 
diff --git a/fw-update/manager.hpp b/fw-update/manager.hpp
index 0608a62..018a703 100644
--- a/fw-update/manager.hpp
+++ b/fw-update/manager.hpp
@@ -8,8 +8,6 @@
 #include "requester/handler.hpp"
 #include "update_manager.hpp"
 
-#include <libpldm/pldm.h>
-
 #include <unordered_map>
 #include <vector>
 
diff --git a/fw-update/test/inventory_manager_test.cpp b/fw-update/test/inventory_manager_test.cpp
index 3876563..9d80be2 100644
--- a/fw-update/test/inventory_manager_test.cpp
+++ b/fw-update/test/inventory_manager_test.cpp
@@ -16,7 +16,7 @@
   protected:
     InventoryManagerTest() :
         event(sdeventplus::Event::get_default()), instanceIdDb(),
-        reqHandler(fd, event, instanceIdDb, false, 90000, seconds(1), 2,
+        reqHandler(nullptr, event, instanceIdDb, false, seconds(1), 2,
                    milliseconds(100)),
         inventoryManager(reqHandler, instanceIdDb, outDescriptorMap,
                          outComponentInfoMap)
diff --git a/fw-update/update_manager.hpp b/fw-update/update_manager.hpp
index 07c0ef9..b47f89d 100644
--- a/fw-update/update_manager.hpp
+++ b/fw-update/update_manager.hpp
@@ -8,7 +8,6 @@
 #include "watch.hpp"
 
 #include <libpldm/base.h>
-#include <libpldm/pldm.h>
 
 #include <chrono>
 #include <filesystem>
diff --git a/host-bmc/dbus_to_event_handler.cpp b/host-bmc/dbus_to_event_handler.cpp
index fcc56f9..2b55c6b 100644
--- a/host-bmc/dbus_to_event_handler.cpp
+++ b/host-bmc/dbus_to_event_handler.cpp
@@ -2,8 +2,6 @@
 
 #include "libpldmresponder/pdr.hpp"
 
-#include <libpldm/pldm.h>
-
 #include <phosphor-logging/lg2.hpp>
 
 PHOSPHOR_LOG2_USING;
diff --git a/host-bmc/dbus_to_host_effecters.cpp b/host-bmc/dbus_to_host_effecters.cpp
index a70b86b..b94d36a 100644
--- a/host-bmc/dbus_to_host_effecters.cpp
+++ b/host-bmc/dbus_to_host_effecters.cpp
@@ -2,7 +2,6 @@
 
 #include <libpldm/pdr.h>
 #include <libpldm/platform.h>
-#include <libpldm/pldm.h>
 
 #include <phosphor-logging/lg2.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
diff --git a/host-bmc/host_pdr_handler.cpp b/host-bmc/host_pdr_handler.cpp
index a9a914b..8317cf0 100644
--- a/host-bmc/host_pdr_handler.cpp
+++ b/host-bmc/host_pdr_handler.cpp
@@ -8,7 +8,6 @@
 #include "custom_dbus.hpp"
 
 #include <assert.h>
-#include <libpldm/pldm.h>
 
 #include <nlohmann/json.hpp>
 #include <phosphor-logging/lg2.hpp>
diff --git a/libpldmresponder/base.cpp b/libpldmresponder/base.cpp
index e675be8..e1d86ec 100644
--- a/libpldmresponder/base.cpp
+++ b/libpldmresponder/base.cpp
@@ -7,7 +7,6 @@
 #include <libpldm/bios.h>
 #include <libpldm/fru.h>
 #include <libpldm/platform.h>
-#include <libpldm/pldm.h>
 
 #include <phosphor-logging/lg2.hpp>
 
diff --git a/meson.build b/meson.build
index 2c277ec..310f987 100644
--- a/meson.build
+++ b/meson.build
@@ -25,6 +25,12 @@
 package_localstatedir = join_paths(get_option('prefix'), get_option('localstatedir'), meson.project_name())
 
 conf_data = configuration_data()
+cpp = meson.get_compiler('cpp')
+
+# Enable POSIX poll APIs in libpldm
+if cpp.has_header('poll.h')
+    conf_data.set('PLDM_HAS_POLL', 1)
+endif
 if get_option('libpldmresponder').enabled()
 conf_data.set_quoted('BIOS_JSONS_DIR', join_paths(package_datadir, 'bios'))
 conf_data.set_quoted('BIOS_TABLES_DIR', join_paths(package_localstatedir, 'bios'))
@@ -59,13 +65,17 @@
 conf_data.set('FLIGHT_RECORDER_MAX_ENTRIES',get_option('flightrecorder-max-entries'))
 conf_data.set_quoted('HOST_EID_PATH', join_paths(package_datadir, 'host_eid'))
 conf_data.set('MAXIMUM_TRANSFER_SIZE', get_option('maximum-transfer-size'))
+if get_option('transport-implementation') == 'mctp-demux'
+  conf_data.set('PLDM_TRANSPORT_WITH_MCTP_DEMUX', 1)
+elif get_option('transport-implementation') == 'af-mctp'
+  conf_data.set('PLDM_TRANSPORT_WITH_AF_MCTP', 1)
+endif
 config = configure_file(output: 'config.h',
   configuration: conf_data
 )
 
 add_project_arguments('-include', '@0@'.format(config), language: 'cpp')
 
-cpp = meson.get_compiler('cpp')
 filesystem = import('fs')
 
 phosphor_dbus_interfaces = dependency('phosphor-dbus-interfaces')
@@ -129,6 +139,7 @@
 libpldmutils_headers = ['.']
 libpldmutils = library(
   'pldmutils',
+  'common/transport.cpp',
   'common/utils.cpp',
   version: meson.project_version(),
   dependencies: [
diff --git a/meson.options b/meson.options
index 9a7aaf2..b11c0fb 100644
--- a/meson.options
+++ b/meson.options
@@ -33,6 +33,13 @@
     description: 'Include systemd support'
 )
 
+option(
+    'transport-implementation',
+    type: 'combo',
+    choices: ['mctp-demux', 'af-mctp'],
+    description: 'transport via af-mctp or mctp-demux'
+)
+
 # As per PLDM spec DSP0240 version 1.1.0, in Timing Specification for PLDM messages (Table 6),
 # the instance ID for a given response will expire and become reusable if a response has not been
 # received within a maximum of 6 seconds after a request is sent. By setting the dbus timeout
diff --git a/oem/ibm/libpldmresponder/oem_ibm_handler.cpp b/oem/ibm/libpldmresponder/oem_ibm_handler.cpp
index b53addc..db248a2 100644
--- a/oem/ibm/libpldmresponder/oem_ibm_handler.cpp
+++ b/oem/ibm/libpldmresponder/oem_ibm_handler.cpp
@@ -6,7 +6,6 @@
 
 #include <libpldm/entity.h>
 #include <libpldm/entity_oem_ibm.h>
-#include <libpldm/pldm.h>
 
 #include <phosphor-logging/lg2.hpp>
 
diff --git a/oem/ibm/libpldmresponder/platform_oem_ibm.cpp b/oem/ibm/libpldmresponder/platform_oem_ibm.cpp
index 022404c..ae608c8 100644
--- a/oem/ibm/libpldmresponder/platform_oem_ibm.cpp
+++ b/oem/ibm/libpldmresponder/platform_oem_ibm.cpp
@@ -4,7 +4,6 @@
 #include "libpldmresponder/pdr.hpp"
 
 #include <libpldm/platform_oem_ibm.h>
-#include <libpldm/pldm.h>
 
 #include <phosphor-logging/lg2.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
diff --git a/oem/ibm/requester/dbus_to_file_handler.cpp b/oem/ibm/requester/dbus_to_file_handler.cpp
index 6cb748a..57e6ab8 100644
--- a/oem/ibm/requester/dbus_to_file_handler.cpp
+++ b/oem/ibm/requester/dbus_to_file_handler.cpp
@@ -3,7 +3,6 @@
 #include "common/utils.hpp"
 
 #include <libpldm/file_io.h>
-#include <libpldm/pldm.h>
 
 #include <phosphor-logging/lg2.hpp>
 
diff --git a/pldmd/pldmd.cpp b/pldmd/pldmd.cpp
index da50615..23499e4 100644
--- a/pldmd/pldmd.cpp
+++ b/pldmd/pldmd.cpp
@@ -1,5 +1,7 @@
+
 #include "common/flight_recorder.hpp"
 #include "common/instance_id.hpp"
+#include "common/transport.hpp"
 #include "common/utils.hpp"
 #include "dbus_impl_requester.hpp"
 #include "fw-update/manager.hpp"
@@ -14,6 +16,7 @@
 #include <libpldm/bios.h>
 #include <libpldm/pdr.h>
 #include <libpldm/platform.h>
+#include <libpldm/transport.h>
 #include <poll.h>
 #include <stdlib.h>
 #include <sys/socket.h>
@@ -34,7 +37,7 @@
 #include <iostream>
 #include <iterator>
 #include <memory>
-#include <optional>
+#include <ranges>
 #include <sstream>
 #include <stdexcept>
 #include <string>
@@ -83,13 +86,12 @@
 static std::optional<Response>
     processRxMsg(const std::vector<uint8_t>& requestMsg, Invoker& invoker,
                  requester::Handler<requester::Request>& handler,
-                 fw_update::Manager* fwManager)
+                 fw_update::Manager* fwManager, pldm_tid_t tid)
 {
-    using type = uint8_t;
-    uint8_t eid = requestMsg[0];
+    uint8_t eid = tid;
+
     pldm_header_info hdrFields{};
-    auto hdr = reinterpret_cast<const pldm_msg_hdr*>(
-        requestMsg.data() + sizeof(eid) + sizeof(type));
+    auto hdr = reinterpret_cast<const pldm_msg_hdr*>(requestMsg.data());
     if (PLDM_SUCCESS != unpack_pldm_header(hdr, &hdrFields))
     {
         error("Empty PLDM request header");
@@ -100,8 +102,7 @@
     {
         Response response;
         auto request = reinterpret_cast<const pldm_msg*>(hdr);
-        size_t requestLen = requestMsg.size() - sizeof(struct pldm_msg_hdr) -
-                            sizeof(eid) - sizeof(type);
+        size_t requestLen = requestMsg.size() - sizeof(struct pldm_msg_hdr);
         try
         {
             if (hdrFields.pldm_type != PLDM_FWUP)
@@ -138,8 +139,7 @@
     else if (PLDM_RESPONSE == hdrFields.msg_type)
     {
         auto response = reinterpret_cast<const pldm_msg*>(hdr);
-        size_t responseLen = requestMsg.size() - sizeof(struct pldm_msg_hdr) -
-                             sizeof(eid) - sizeof(type);
+        size_t responseLen = requestMsg.size() - sizeof(struct pldm_msg_hdr);
         handler.handleResponse(eid, hdrFields.instance, hdrFields.pldm_type,
                                hdrFields.command, response, responseLen);
     }
@@ -172,28 +172,12 @@
             exit(EXIT_FAILURE);
     }
 
-    /* Create local socket. */
-    int returnCode = 0;
-    int sockfd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
-    if (-1 == sockfd)
-    {
-        returnCode = -errno;
-        error("Failed to create the socket, RC= {RC}", "RC", returnCode);
-        exit(EXIT_FAILURE);
-    }
-    socklen_t optlen;
-    int currentSendbuffSize;
-
-    // Get Current send buffer size
-    optlen = sizeof(currentSendbuffSize);
-
-    int res = getsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &currentSendbuffSize,
-                         &optlen);
-    if (res == -1)
-    {
-        error("Error in obtaining the default send buffer size, Error : {ERR}",
-              "ERR", strerror(errno));
-    }
+    // Setup PLDM requester transport
+    auto hostEID = pldm::utils::readHostEID();
+    /* To maintain current behaviour until we have the infrastructure to find
+     * and use the correct TIDs */
+    pldm_tid_t TID = hostEID;
+    PldmTransport pldmTransport{};
     auto event = Event::get_default();
     auto& bus = pldm::utils::DBusHandler::getBus();
     sdbusplus::server::manager_t objManager(bus,
@@ -206,8 +190,8 @@
         bus, "/xyz/openbmc_project/inventory");
 
     Invoker invoker{};
-    requester::Handler<requester::Request> reqHandler(
-        sockfd, event, instanceIdDb, currentSendbuffSize, verbose);
+    requester::Handler<requester::Request> reqHandler(&pldmTransport, event,
+                                                      instanceIdDb, verbose);
 
 #ifdef LIBPLDMRESPONDER
     using namespace pldm::state_sensor;
@@ -241,22 +225,22 @@
         hostEffecterParser;
     std::unique_ptr<DbusToPLDMEvent> dbusToPLDMEventHandler;
     DBusHandler dbusHandler;
-    auto hostEID = pldm::utils::readHostEID();
     if (hostEID)
     {
         hostPDRHandler = std::make_shared<HostPDRHandler>(
-            sockfd, hostEID, event, pdrRepo.get(), EVENTS_JSONS_DIR,
-            entityTree.get(), bmcEntityTree.get(), instanceIdDb, &reqHandler);
+            pldmTransport.getEventSource(), hostEID, event, pdrRepo.get(),
+            EVENTS_JSONS_DIR, entityTree.get(), bmcEntityTree.get(),
+            instanceIdDb, &reqHandler);
         // HostFirmware interface needs access to hostPDR to know if host
         // is running
         dbusImplHost.setHostPdrObj(hostPDRHandler);
 
         hostEffecterParser =
             std::make_unique<pldm::host_effecters::HostEffecterParser>(
-                &instanceIdDb, sockfd, pdrRepo.get(), &dbusHandler,
-                HOST_JSONS_DIR, &reqHandler);
+                &instanceIdDb, pldmTransport.getEventSource(), pdrRepo.get(),
+                &dbusHandler, HOST_JSONS_DIR, &reqHandler);
         dbusToPLDMEventHandler = std::make_unique<DbusToPLDMEvent>(
-            sockfd, hostEID, instanceIdDb, &reqHandler);
+            pldmTransport.getEventSource(), hostEID, instanceIdDb, &reqHandler);
     }
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     std::unique_ptr<oem_bios::Handler> oemBiosHandler{};
@@ -266,17 +250,19 @@
         std::make_unique<pldm::responder::CodeUpdate>(&dbusHandler);
     codeUpdate->clearDirPath(LID_STAGING_DIR);
     oemPlatformHandler = std::make_unique<oem_ibm_platform::Handler>(
-        &dbusHandler, codeUpdate.get(), sockfd, hostEID, instanceIdDb, event,
-        &reqHandler);
+        &dbusHandler, codeUpdate.get(), pldmTransport.getEventSource(), hostEID,
+        instanceIdDb, event, &reqHandler);
     codeUpdate->setOemPlatformHandler(oemPlatformHandler.get());
     invoker.registerHandler(PLDM_OEM, std::make_unique<oem_ibm::Handler>(
-                                          oemPlatformHandler.get(), sockfd,
+                                          oemPlatformHandler.get(),
+                                          pldmTransport.getEventSource(),
                                           hostEID, &instanceIdDb, &reqHandler));
     oemBiosHandler = std::make_unique<oem::ibm::bios::Handler>(&dbusHandler);
 #endif
 
     auto biosHandler = std::make_unique<bios::Handler>(
-        sockfd, hostEID, &instanceIdDb, &reqHandler, oemBiosHandler.get());
+        pldmTransport.getEventSource(), hostEID, &instanceIdDb, &reqHandler,
+        oemBiosHandler.get());
     auto fruHandler = std::make_unique<fru::Handler>(
         FRU_JSONS_DIR, FRU_MASTER_JSON, pdrRepo.get(), entityTree.get(),
         bmcEntityTree.get());
@@ -292,7 +278,6 @@
         dynamic_cast<pldm::responder::oem_ibm_platform::Handler*>(
             oemPlatformHandler.get());
     oemIbmPlatformHandler->setPlatformHandler(platformHandler.get());
-
 #endif
 
     invoker.registerHandler(PLDM_BIOS, std::move(biosHandler));
@@ -308,149 +293,77 @@
 
 #endif
 
-    pldm::utils::CustomFD socketFd(sockfd);
-
-    struct sockaddr_un addr
-    {};
-    addr.sun_family = AF_UNIX;
-    const char path[] = "\0mctp-mux";
-    memcpy(addr.sun_path, path, sizeof(path) - 1);
-    int result = connect(socketFd(), reinterpret_cast<struct sockaddr*>(&addr),
-                         sizeof(path) + sizeof(addr.sun_family) - 1);
-    if (-1 == result)
-    {
-        returnCode = -errno;
-        error("Failed to connect to the socket, RC= {RC}", "RC", returnCode);
-        exit(EXIT_FAILURE);
-    }
-
-    result = write(socketFd(), &MCTP_MSG_TYPE_PLDM, sizeof(MCTP_MSG_TYPE_PLDM));
-    if (-1 == result)
-    {
-        returnCode = -errno;
-        error("Failed to send message type as pldm to mctp, RC= {RC}", "RC",
-              returnCode);
-        exit(EXIT_FAILURE);
-    }
-
     std::unique_ptr<fw_update::Manager> fwManager =
         std::make_unique<fw_update::Manager>(event, reqHandler, instanceIdDb);
     std::unique_ptr<MctpDiscovery> mctpDiscoveryHandler =
         std::make_unique<MctpDiscovery>(bus, fwManager.get());
-
-    auto callback = [verbose, &invoker, &reqHandler, currentSendbuffSize,
-                     &fwManager](IO& io, int fd, uint32_t revents) mutable {
+    auto callback = [verbose, &invoker, &reqHandler, &fwManager, &pldmTransport,
+                     TID](IO& io, int fd, uint32_t revents) mutable {
         if (!(revents & EPOLLIN))
         {
             return;
         }
-
-        // Outgoing message.
-        struct iovec iov[2]{};
-
-        // This structure contains the parameter information for the response
-        // message.
-        struct msghdr msg
-        {};
+        if (fd < 0)
+        {
+            return;
+        }
 
         int returnCode = 0;
-        ssize_t peekedLength = recv(fd, nullptr, 0, MSG_PEEK | MSG_TRUNC);
-        if (0 == peekedLength)
+        void* requestMsg;
+        size_t recvDataLength;
+        returnCode = pldmTransport.recvMsg(TID, requestMsg, recvDataLength);
+
+        if (returnCode == PLDM_REQUESTER_SUCCESS)
+        {
+            std::vector<uint8_t> requestMsgVec(
+                static_cast<uint8_t*>(requestMsg),
+                static_cast<uint8_t*>(requestMsg) + recvDataLength);
+            FlightRecorder::GetInstance().saveRecord(requestMsgVec, false);
+            if (verbose)
+            {
+                printBuffer(Rx, requestMsgVec);
+            }
+            // process message and send response
+            auto response = processRxMsg(requestMsgVec, invoker, reqHandler,
+                                         fwManager.get(), TID);
+            if (response.has_value())
+            {
+                FlightRecorder::GetInstance().saveRecord(*response, true);
+                if (verbose)
+                {
+                    printBuffer(Tx, *response);
+                }
+
+                returnCode = pldmTransport.sendMsg(TID, (*response).data(),
+                                                   (*response).size());
+                if (returnCode != PLDM_REQUESTER_SUCCESS)
+                {
+                    warning("Failed to send PLDM response: {RETURN_CODE}",
+                            "RETURN_CODE", returnCode);
+                }
+            }
+        }
+        // TODO check that we get here if mctp-demux dies?
+        else if (returnCode == PLDM_REQUESTER_RECV_FAIL)
         {
             // MCTP daemon has closed the socket this daemon is connected to.
             // This may or may not be an error scenario, in either case the
             // recovery mechanism for this daemon is to restart, and hence exit
             // the event loop, that will cause this daemon to exit with a
             // failure code.
+            error("io exiting");
             io.get_event().exit(0);
         }
-        else if (peekedLength <= -1)
-        {
-            returnCode = -errno;
-            error("recv system call failed, RC= {RC}", "RC", returnCode);
-        }
         else
         {
-            std::vector<uint8_t> requestMsg(peekedLength);
-            auto recvDataLength = recv(
-                fd, static_cast<void*>(requestMsg.data()), peekedLength, 0);
-            if (recvDataLength == peekedLength)
-            {
-                FlightRecorder::GetInstance().saveRecord(requestMsg, false);
-                if (verbose)
-                {
-                    printBuffer(Rx, requestMsg);
-                }
-
-                if (MCTP_MSG_TYPE_PLDM != requestMsg[1])
-                {
-                    // Skip this message and continue.
-                }
-                else
-                {
-                    // process message and send response
-                    auto response = processRxMsg(requestMsg, invoker,
-                                                 reqHandler, fwManager.get());
-                    if (response.has_value())
-                    {
-                        FlightRecorder::GetInstance().saveRecord(*response,
-                                                                 true);
-                        if (verbose)
-                        {
-                            printBuffer(Tx, *response);
-                        }
-
-                        iov[0].iov_base = &requestMsg[0];
-                        iov[0].iov_len = sizeof(requestMsg[0]) +
-                                         sizeof(requestMsg[1]);
-                        iov[1].iov_base = (*response).data();
-                        iov[1].iov_len = (*response).size();
-
-                        msg.msg_iov = iov;
-                        msg.msg_iovlen = sizeof(iov) / sizeof(iov[0]);
-                        if (currentSendbuffSize >= 0 &&
-                            (size_t)currentSendbuffSize < (*response).size())
-                        {
-                            int oldBuffSize = currentSendbuffSize;
-                            currentSendbuffSize = (*response).size();
-                            int res = setsockopt(fd, SOL_SOCKET, SO_SNDBUF,
-                                                 &currentSendbuffSize,
-                                                 sizeof(currentSendbuffSize));
-                            if (res == -1)
-                            {
-                                error(
-                                    "Responder : Failed to set the new send buffer size [bytes] : {CURR_SND_BUF_SIZE}",
-                                    "CURR_SND_BUF_SIZE", currentSendbuffSize);
-                                error(
-                                    "from current size [bytes] : {OLD_BUF_SIZE}, Error : {ERR}",
-                                    "OLD_BUF_SIZE", oldBuffSize, "ERR",
-                                    strerror(errno));
-                                return;
-                            }
-                        }
-
-                        int result = sendmsg(fd, &msg, 0);
-                        if (-1 == result)
-                        {
-                            returnCode = -errno;
-                            error("sendto system call failed, RC= {RC}", "RC",
-                                  returnCode);
-                        }
-                    }
-                }
-            }
-            else
-            {
-                error(
-                    "Failure to read peeked length packet. peekedLength = {PEEK_LEN}, recvDataLength= {RECV_LEN}",
-                    "PEEK_LEN", peekedLength, "RECV_LEN", recvDataLength);
-            }
+            warning("Failed to receive PLDM request: {RETURN_CODE}",
+                    "RETURN_CODE", returnCode);
         }
     };
 
     bus.attach_event(event.get(), SD_EVENT_PRIORITY_NORMAL);
     bus.request_name("xyz.openbmc_project.PLDM");
-    IO io(event, socketFd(), EPOLLIN, std::move(callback));
+    IO io(event, pldmTransport.getEventSource(), EPOLLIN, std::move(callback));
 #ifdef LIBPLDMRESPONDER
     if (hostPDRHandler)
     {
@@ -460,12 +373,7 @@
     stdplus::signal::block(SIGUSR1);
     sdeventplus::source::Signal sigUsr1(
         event, SIGUSR1, std::bind_front(&interruptFlightRecorderCallBack));
-    returnCode = event.loop();
-
-    if (shutdown(sockfd, SHUT_RDWR))
-    {
-        error("Failed to shutdown the socket");
-    }
+    int returnCode = event.loop();
     if (returnCode)
     {
         exit(EXIT_FAILURE);
diff --git a/pldmtool/pldm_cmd_helper.cpp b/pldmtool/pldm_cmd_helper.cpp
index db44c5a..9c7f94a 100644
--- a/pldmtool/pldm_cmd_helper.cpp
+++ b/pldmtool/pldm_cmd_helper.cpp
@@ -1,8 +1,12 @@
 #include "pldm_cmd_helper.hpp"
 
+#include "common/transport.hpp"
 #include "xyz/openbmc_project/Common/error.hpp"
 
-#include <libpldm/pldm.h>
+#include <libpldm/transport.h>
+#include <libpldm/transport/af-mctp.h>
+#include <libpldm/transport/mctp-demux.h>
+#include <poll.h>
 #include <systemd/sd-bus.h>
 
 #include <sdbusplus/server.hpp>
@@ -16,120 +20,6 @@
 {
 namespace helper
 {
-/*
- * Initialize the socket, send pldm command & recieve response from socket
- *
- */
-int mctpSockSendRecv(const std::vector<uint8_t>& requestMsg,
-                     std::vector<uint8_t>& responseMsg, bool pldmVerbose)
-{
-    const char devPath[] = "\0mctp-mux";
-    int returnCode = 0;
-
-    int sockFd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
-    if (-1 == sockFd)
-    {
-        returnCode = -errno;
-        std::cerr << "Failed to create the socket : RC = " << sockFd << "\n";
-        return returnCode;
-    }
-    Logger(pldmVerbose, "Success in creating the socket : RC = ", sockFd);
-
-    struct sockaddr_un addr
-    {};
-    addr.sun_family = AF_UNIX;
-
-    memcpy(addr.sun_path, devPath, sizeof(devPath) - 1);
-
-    CustomFD socketFd(sockFd);
-    int result = connect(socketFd(), reinterpret_cast<struct sockaddr*>(&addr),
-                         sizeof(devPath) + sizeof(addr.sun_family) - 1);
-    if (-1 == result)
-    {
-        returnCode = -errno;
-        std::cerr << "Failed to connect to socket : RC = " << returnCode
-                  << "\n";
-        return returnCode;
-    }
-    Logger(pldmVerbose, "Success in connecting to socket : RC = ", returnCode);
-
-    auto pldmType = MCTP_MSG_TYPE_PLDM;
-    result = write(socketFd(), &pldmType, sizeof(pldmType));
-    if (-1 == result)
-    {
-        returnCode = -errno;
-        std::cerr << "Failed to send message type as pldm to mctp : RC = "
-                  << returnCode << "\n";
-        return returnCode;
-    }
-    Logger(
-        pldmVerbose,
-        "Success in sending message type as pldm to mctp : RC = ", returnCode);
-
-    result = send(socketFd(), requestMsg.data(), requestMsg.size(), 0);
-    if (-1 == result)
-    {
-        returnCode = -errno;
-        std::cerr << "Write to socket failure : RC = " << returnCode << "\n";
-        return returnCode;
-    }
-    Logger(pldmVerbose, "Write to socket successful : RC = ", result);
-
-    // Read the response from socket
-    ssize_t peekedLength = recv(socketFd(), nullptr, 0, MSG_TRUNC | MSG_PEEK);
-    if (0 == peekedLength)
-    {
-        std::cerr << "Socket is closed : peekedLength = " << peekedLength
-                  << "\n";
-        return returnCode;
-    }
-    else if (peekedLength <= -1)
-    {
-        returnCode = -errno;
-        std::cerr << "recv() system call failed : RC = " << returnCode << "\n";
-        return returnCode;
-    }
-    else
-    {
-        auto reqhdr = reinterpret_cast<const pldm_msg_hdr*>(&requestMsg[2]);
-        do
-        {
-            ssize_t peekedLength = recv(socketFd(), nullptr, 0,
-                                        MSG_PEEK | MSG_TRUNC);
-            responseMsg.resize(peekedLength);
-            auto recvDataLength =
-                recv(socketFd(), reinterpret_cast<void*>(responseMsg.data()),
-                     peekedLength, 0);
-            auto resphdr =
-                reinterpret_cast<const pldm_msg_hdr*>(&responseMsg[2]);
-            if (recvDataLength == peekedLength &&
-                resphdr->instance_id == reqhdr->instance_id &&
-                resphdr->request != PLDM_REQUEST)
-            {
-                Logger(pldmVerbose, "Total length:", recvDataLength);
-                break;
-            }
-            else if (recvDataLength != peekedLength)
-            {
-                std::cerr << "Failure to read response length packet: length = "
-                          << recvDataLength << "\n";
-                return returnCode;
-            }
-        } while (1);
-    }
-
-    returnCode = shutdown(socketFd(), SHUT_RDWR);
-    if (-1 == returnCode)
-    {
-        returnCode = -errno;
-        std::cerr << "Failed to shutdown the socket : RC = " << returnCode
-                  << "\n";
-        return returnCode;
-    }
-
-    Logger(pldmVerbose, "Shutdown Socket successful :  RC = ", returnCode);
-    return PLDM_SUCCESS;
-}
 
 void CommandInterface::exec()
 {
@@ -161,13 +51,6 @@
 int CommandInterface::pldmSendRecv(std::vector<uint8_t>& requestMsg,
                                    std::vector<uint8_t>& responseMsg)
 {
-    // Insert the PLDM message type and EID at the beginning of the
-    // msg.
-    requestMsg.insert(requestMsg.begin(), MCTP_MSG_TYPE_PLDM);
-    requestMsg.insert(requestMsg.begin(), mctp_eid);
-
-    bool mctpVerbose = pldmVerbose;
-
     // By default enable request/response msgs for pldmtool raw commands.
     if (CommandInterface::pldmType == "raw")
     {
@@ -180,43 +63,29 @@
         printBuffer(Tx, requestMsg);
     }
 
-    if (mctp_eid != PLDM_ENTITY_ID)
+    void* responseMessage = nullptr;
+    size_t responseMessageSize{};
+    auto tid = mctp_eid;
+    PldmTransport pldmTransport{};
+
+    int rc = pldmTransport.sendRecvMsg(tid, requestMsg.data(),
+                                       requestMsg.size(), responseMessage,
+                                       responseMessageSize);
+    if (rc)
     {
-        int fd = pldm_open();
-        if (-1 == fd)
-        {
-            std::cerr << "failed to init mctp "
-                      << "\n";
-            return -1;
-        }
-        uint8_t* responseMessage = nullptr;
-        size_t responseMessageSize{};
-        pldm_send_recv(mctp_eid, fd, requestMsg.data() + 2,
-                       requestMsg.size() - 2, &responseMessage,
-                       &responseMessageSize);
-
-        responseMsg.resize(responseMessageSize);
-        memcpy(responseMsg.data(), responseMessage, responseMsg.size());
-
-        shutdown(fd, SHUT_RDWR);
-        free(responseMessage);
-
-        if (pldmVerbose)
-        {
-            std::cout << "pldmtool: ";
-            printBuffer(Rx, responseMsg);
-        }
+        std::cerr << "failed to pldm send recv\n";
+        return rc;
     }
-    else
+
+    responseMsg.resize(responseMessageSize);
+    memcpy(responseMsg.data(), responseMessage, responseMsg.size());
+
+    free(responseMessage);
+
+    if (pldmVerbose)
     {
-        mctpSockSendRecv(requestMsg, responseMsg, mctpVerbose);
-        if (pldmVerbose)
-        {
-            std::cout << "pldmtool: ";
-            printBuffer(Rx, responseMsg);
-        }
-        responseMsg.erase(responseMsg.begin(),
-                          responseMsg.begin() + 2 /* skip the mctp header */);
+        std::cout << "pldmtool: ";
+        printBuffer(Rx, responseMsg);
     }
     return PLDM_SUCCESS;
 }
diff --git a/requester/handler.hpp b/requester/handler.hpp
index 9e5d8d1..6987b16 100644
--- a/requester/handler.hpp
+++ b/requester/handler.hpp
@@ -1,11 +1,11 @@
 #pragma once
 
 #include "common/instance_id.hpp"
+#include "common/transport.hpp"
 #include "common/types.hpp"
 #include "request.hpp"
 
 #include <libpldm/base.h>
-#include <libpldm/pldm.h>
 #include <sys/socket.h>
 
 #include <phosphor-logging/lg2.hpp>
@@ -87,26 +87,24 @@
 
     /** @brief Constructor
      *
-     *  @param[in] fd - fd of MCTP communications socket
+     *  @param[in] pldm_transport - PLDM requester
      *  @param[in] event - reference to PLDM daemon's main event loop
      *  @param[in] instanceIdDb - reference to an InstanceIdDb
-     *  @param[in] currentSendbuffSize - current send buffer size
      *  @param[in] verbose - verbose tracing flag
      *  @param[in] instanceIdExpiryInterval - instance ID expiration interval
      *  @param[in] numRetries - number of request retries
      *  @param[in] responseTimeOut - time to wait between each retry
      */
     explicit Handler(
-        int fd, sdeventplus::Event& event, pldm::InstanceIdDb& instanceIdDb,
-        int currentSendbuffSize, bool verbose,
+        PldmTransport* pldmTransport, sdeventplus::Event& event,
+        pldm::InstanceIdDb& instanceIdDb, bool verbose,
         std::chrono::seconds instanceIdExpiryInterval =
             std::chrono::seconds(INSTANCE_ID_EXPIRATION_INTERVAL),
         uint8_t numRetries = static_cast<uint8_t>(NUMBER_OF_REQUEST_RETRIES),
         std::chrono::milliseconds responseTimeOut =
             std::chrono::milliseconds(RESPONSE_TIME_OUT)) :
-        fd(fd),
-        event(event), instanceIdDb(instanceIdDb),
-        currentSendbuffSize(currentSendbuffSize), verbose(verbose),
+        pldmTransport(pldmTransport),
+        event(event), instanceIdDb(instanceIdDb), verbose(verbose),
         instanceIdExpiryInterval(instanceIdExpiryInterval),
         numRetries(numRetries), responseTimeOut(responseTimeOut)
     {}
@@ -171,8 +169,8 @@
         }
 
         auto request = std::make_unique<RequestInterface>(
-            fd, eid, event, std::move(requestMsg), numRetries, responseTimeOut,
-            currentSendbuffSize, verbose);
+            pldmTransport, eid, event, std::move(requestMsg), numRetries,
+            responseTimeOut, verbose);
         auto timer = std::make_unique<phosphor::Timer>(
             event.get(), instanceIdExpiryCallBack);
 
@@ -243,10 +241,9 @@
     }
 
   private:
-    int fd; //!< file descriptor of MCTP communications socket
+    PldmTransport* pldmTransport; //!< PLDM transport object
     sdeventplus::Event& event; //!< reference to PLDM daemon's main event loop
     pldm::InstanceIdDb& instanceIdDb; //!< reference to an InstanceIdDb
-    int currentSendbuffSize;          //!< current Send Buffer size
     bool verbose;                     //!< verbose tracing flag
     std::chrono::seconds
         instanceIdExpiryInterval;     //!< Instance ID expiration interval
diff --git a/requester/mctp_endpoint_discovery.cpp b/requester/mctp_endpoint_discovery.cpp
index bc50ee5..5f3451a 100644
--- a/requester/mctp_endpoint_discovery.cpp
+++ b/requester/mctp_endpoint_discovery.cpp
@@ -3,8 +3,6 @@
 #include "common/types.hpp"
 #include "common/utils.hpp"
 
-#include <libpldm/pldm.h>
-
 #include <algorithm>
 #include <map>
 #include <string>
diff --git a/requester/request.hpp b/requester/request.hpp
index 62615f8..27d94fc 100644
--- a/requester/request.hpp
+++ b/requester/request.hpp
@@ -1,11 +1,11 @@
 #pragma once
 
 #include "common/flight_recorder.hpp"
+#include "common/transport.hpp"
 #include "common/types.hpp"
 #include "common/utils.hpp"
 
 #include <libpldm/base.h>
-#include <libpldm/pldm.h>
 #include <sys/socket.h>
 
 #include <phosphor-logging/lg2.hpp>
@@ -142,7 +142,7 @@
 
     /** @brief Constructor
      *
-     *  @param[in] fd - fd of the MCTP communication socket
+     *  @param[in] pldm_transport - PLDM transport object
      *  @param[in] eid - endpoint ID of the remote MCTP endpoint
      *  @param[in] currrentSendbuffSize - the current send buffer size
      *  @param[in] event - reference to PLDM daemon's main event loop
@@ -151,21 +151,20 @@
      *  @param[in] timeout - time to wait between each retry in milliseconds
      *  @param[in] verbose - verbose tracing flag
      */
-    explicit Request(int fd, mctp_eid_t eid, sdeventplus::Event& event,
-                     pldm::Request&& requestMsg, uint8_t numRetries,
-                     std::chrono::milliseconds timeout, int currentSendbuffSize,
+    explicit Request(PldmTransport* pldmTransport, mctp_eid_t eid,
+                     sdeventplus::Event& event, pldm::Request&& requestMsg,
+                     uint8_t numRetries, std::chrono::milliseconds timeout,
                      bool verbose) :
         RequestRetryTimer(event, numRetries, timeout),
-        fd(fd), eid(eid), requestMsg(std::move(requestMsg)),
-        currentSendbuffSize(currentSendbuffSize), verbose(verbose)
+        pldmTransport(pldmTransport), eid(eid),
+        requestMsg(std::move(requestMsg)), verbose(verbose)
     {}
 
   private:
-    int fd;                   //!< file descriptor of MCTP communications socket
-    mctp_eid_t eid;           //!< endpoint ID of the remote MCTP endpoint
-    pldm::Request requestMsg; //!< PLDM request message
-    mutable int currentSendbuffSize; //!< current Send Buffer size
-    bool verbose;                    //!< verbose tracing flag
+    PldmTransport* pldmTransport; //!< PLDM transport
+    mctp_eid_t eid;               //!< endpoint ID of the remote MCTP endpoint
+    pldm::Request requestMsg;     //!< PLDM request message
+    bool verbose;                 //!< verbose tracing flag
 
     /** @brief Sends the PLDM request message on the socket
      *
@@ -177,26 +176,23 @@
         {
             pldm::utils::printBuffer(pldm::utils::Tx, requestMsg);
         }
-        if (currentSendbuffSize >= 0 &&
-            (size_t)currentSendbuffSize < requestMsg.size())
-        {
-            int oldSendbuffSize = currentSendbuffSize;
-            currentSendbuffSize = requestMsg.size();
-            int res = setsockopt(fd, SOL_SOCKET, SO_SNDBUF,
-                                 &currentSendbuffSize,
-                                 sizeof(currentSendbuffSize));
-            if (res == -1)
-            {
-                error(
-                    "Requester : Failed to set the new send buffer size [bytes] : {CURR_SND_BUF_SIZE} from current size [bytes]: {OLD_BUF_SIZE} , Error : {ERR}",
-                    "CURR_SND_BUF_SIZE", currentSendbuffSize, "OLD_BUF_SIZE",
-                    oldSendbuffSize, "ERR", strerror(errno));
-                return PLDM_ERROR;
-            }
-        }
         pldm::flightrecorder::FlightRecorder::GetInstance().saveRecord(
             requestMsg, true);
-        auto rc = pldm_send(eid, fd, requestMsg.data(), requestMsg.size());
+        const struct pldm_msg_hdr* hdr =
+            (struct pldm_msg_hdr*)(requestMsg.data());
+        if (!hdr->request)
+        {
+            return PLDM_REQUESTER_NOT_REQ_MSG;
+        }
+
+        if (pldmTransport == nullptr)
+        {
+            error("Invalid transport: Unable to send PLDM request");
+            return PLDM_ERROR;
+        }
+
+        auto rc = pldmTransport->sendMsg(static_cast<pldm_tid_t>(eid),
+                                         requestMsg.data(), requestMsg.size());
         if (rc < 0)
         {
             error("Failed to send PLDM message. RC = {RC}, errno = {ERR}", "RC",
diff --git a/requester/test/handler_test.cpp b/requester/test/handler_test.cpp
index 17a40fe..b656c1a 100644
--- a/requester/test/handler_test.cpp
+++ b/requester/test/handler_test.cpp
@@ -6,6 +6,7 @@
 #include "test/test_instance_id.hpp"
 
 #include <libpldm/base.h>
+#include <libpldm/transport.h>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -26,6 +27,7 @@
 
     int fd = 0;
     mctp_eid_t eid = 0;
+    PldmTransport* pldmTransport = nullptr;
     sdeventplus::Event event;
     TestInstanceIdDb instanceIdDb;
 
@@ -71,9 +73,9 @@
 
 TEST_F(HandlerTest, singleRequestResponseScenario)
 {
-    Handler<NiceMock<MockRequest>> reqHandler(fd, event, instanceIdDb, false,
-                                              90000, seconds(1), 2,
-                                              milliseconds(100));
+    Handler<NiceMock<MockRequest>> reqHandler(pldmTransport, event,
+                                              instanceIdDb, false, seconds(1),
+                                              2, milliseconds(100));
     pldm::Request request{};
     auto instanceId = instanceIdDb.next(eid);
     EXPECT_EQ(instanceId, 0);
@@ -92,9 +94,9 @@
 
 TEST_F(HandlerTest, singleRequestInstanceIdTimerExpired)
 {
-    Handler<NiceMock<MockRequest>> reqHandler(fd, event, instanceIdDb, false,
-                                              90000, seconds(1), 2,
-                                              milliseconds(100));
+    Handler<NiceMock<MockRequest>> reqHandler(pldmTransport, event,
+                                              instanceIdDb, false, seconds(1),
+                                              2, milliseconds(100));
     pldm::Request request{};
     auto instanceId = instanceIdDb.next(eid);
     EXPECT_EQ(instanceId, 0);
@@ -111,9 +113,9 @@
 
 TEST_F(HandlerTest, multipleRequestResponseScenario)
 {
-    Handler<NiceMock<MockRequest>> reqHandler(fd, event, instanceIdDb, false,
-                                              90000, seconds(2), 2,
-                                              milliseconds(100));
+    Handler<NiceMock<MockRequest>> reqHandler(pldmTransport, event,
+                                              instanceIdDb, false, seconds(2),
+                                              2, milliseconds(100));
     pldm::Request request{};
     auto instanceId = instanceIdDb.next(eid);
     EXPECT_EQ(instanceId, 0);
diff --git a/requester/test/mock_request.hpp b/requester/test/mock_request.hpp
index 7e6fc41..e77a3cb 100644
--- a/requester/test/mock_request.hpp
+++ b/requester/test/mock_request.hpp
@@ -1,7 +1,10 @@
 #pragma once
 
+#include "common/transport.hpp"
 #include "requester/request.hpp"
 
+#include <libpldm/transport.h>
+
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -14,10 +17,10 @@
 class MockRequest : public RequestRetryTimer
 {
   public:
-    MockRequest(int /*fd*/, mctp_eid_t /*eid*/, sdeventplus::Event& event,
-                pldm::Request&& /*requestMsg*/, uint8_t numRetries,
-                std::chrono::milliseconds responseTimeOut,
-                int /*currentSendbuffSize*/, bool /*verbose*/) :
+    MockRequest(PldmTransport* /*pldmTransport*/, mctp_eid_t /*eid*/,
+                sdeventplus::Event& event, pldm::Request&& /*requestMsg*/,
+                uint8_t numRetries, std::chrono::milliseconds responseTimeOut,
+                bool /*verbose*/) :
         RequestRetryTimer(event, numRetries, responseTimeOut)
     {}
 
diff --git a/requester/test/request_test.cpp b/requester/test/request_test.cpp
index 2e3060d..51b337d 100644
--- a/requester/test/request_test.cpp
+++ b/requester/test/request_test.cpp
@@ -1,3 +1,4 @@
+#include "common/transport.hpp"
 #include "mock_request.hpp"
 
 #include <libpldm/base.h>
@@ -41,14 +42,15 @@
 
     int fd = 0;
     mctp_eid_t eid = 0;
+    PldmTransport* pldmTransport = nullptr;
     sdeventplus::Event event;
-    std::vector<uint8_t> requestMsg;
 };
 
 TEST_F(RequestIntfTest, 0Retries100msTimeout)
 {
-    MockRequest request(fd, eid, event, std::move(requestMsg), 0,
-                        milliseconds(100), 90000, false);
+    std::vector<uint8_t> requestMsg;
+    MockRequest request(pldmTransport, eid, event, std::move(requestMsg), 0,
+                        milliseconds(100), false);
     EXPECT_CALL(request, send())
         .Times(Exactly(1))
         .WillOnce(Return(PLDM_SUCCESS));
@@ -58,8 +60,9 @@
 
 TEST_F(RequestIntfTest, 2Retries100msTimeout)
 {
-    MockRequest request(fd, eid, event, std::move(requestMsg), 2,
-                        milliseconds(100), 90000, false);
+    std::vector<uint8_t> requestMsg;
+    MockRequest request(pldmTransport, eid, event, std::move(requestMsg), 2,
+                        milliseconds(100), false);
     // send() is called a total of 3 times, the original plus two retries
     EXPECT_CALL(request, send()).Times(3).WillRepeatedly(Return(PLDM_SUCCESS));
     auto rc = request.start();
@@ -69,8 +72,9 @@
 
 TEST_F(RequestIntfTest, 9Retries100msTimeoutRequestStoppedAfter1sec)
 {
-    MockRequest request(fd, eid, event, std::move(requestMsg), 9,
-                        milliseconds(100), 90000, false);
+    std::vector<uint8_t> requestMsg;
+    MockRequest request(pldmTransport, eid, event, std::move(requestMsg), 9,
+                        milliseconds(100), false);
     // send() will be called a total of 10 times, the original plus 9 retries.
     // In a ideal scenario send() would have been called 10 times in 1 sec (when
     // the timer is stopped) with a timeout of 100ms. Because there are delays
@@ -92,8 +96,9 @@
 
 TEST_F(RequestIntfTest, 2Retries100msTimeoutsendReturnsError)
 {
-    MockRequest request(fd, eid, event, std::move(requestMsg), 2,
-                        milliseconds(100), 90000, false);
+    std::vector<uint8_t> requestMsg;
+    MockRequest request(pldmTransport, eid, event, std::move(requestMsg), 2,
+                        milliseconds(100), false);
     EXPECT_CALL(request, send()).Times(Exactly(1)).WillOnce(Return(PLDM_ERROR));
     auto rc = request.start();
     EXPECT_EQ(rc, PLDM_ERROR);
diff --git a/softoff/softoff.cpp b/softoff/softoff.cpp
index f80e048..3135b3d 100644
--- a/softoff/softoff.cpp
+++ b/softoff/softoff.cpp
@@ -1,11 +1,11 @@
 #include "softoff.hpp"
 
 #include "common/instance_id.hpp"
+#include "common/transport.hpp"
 #include "common/utils.hpp"
 
 #include <libpldm/entity.h>
 #include <libpldm/platform.h>
-#include <libpldm/pldm.h>
 #include <libpldm/state_set.h>
 
 #include <phosphor-logging/lg2.hpp>
@@ -291,8 +291,9 @@
 int SoftPowerOff::hostSoftOff(sdeventplus::Event& event)
 {
     constexpr uint8_t effecterCount = 1;
-    uint8_t mctpEID;
+    PldmTransport pldmTransport{};
     uint8_t instanceID;
+    uint8_t mctpEID;
 
     mctpEID = pldm::utils::readHostEID();
     // TODO: fix mapping to work around OpenBMC ecosystem deficiencies
@@ -317,14 +318,6 @@
         return PLDM_ERROR;
     }
 
-    // Open connection to MCTP socket
-    int fd = pldm_open();
-    if (-1 == fd)
-    {
-        error("Failed to connect to mctp demux daemon");
-        return PLDM_ERROR;
-    }
-
     // Add a timer to the event loop, default 30s.
     auto timerCallback =
         [=, this](Timer& /*source*/, Timer::TimePoint /*time*/) mutable {
@@ -341,18 +334,23 @@
                std::chrono::seconds{1}, std::move(timerCallback));
 
     // Add a callback to handle EPOLLIN on fd
-    auto callback = [=, this](IO& io, int fd, uint32_t revents) mutable {
+    auto callback =
+        [=, &pldmTransport, this](IO& io, int fd, uint32_t revents) mutable {
+        if (fd != pldmTransport.getEventSource())
+        {
+            return;
+        }
+
         if (!(revents & EPOLLIN))
         {
             return;
         }
 
-        uint8_t* responseMsg = nullptr;
+        void* responseMsg = nullptr;
         size_t responseMsgSize{};
         pldm_tid_t srcTID = pldmTID;
 
-        auto rc = pldm_recv(mctpEID, fd, request->hdr.instance_id, &responseMsg,
-                            &responseMsgSize);
+        auto rc = pldmTransport.recvMsg(pldmTID, responseMsg, responseMsgSize);
         if (rc)
         {
             error("Soft off: failed to recv pldm data. PLDM RC = {RC}", "RC",
@@ -360,8 +358,8 @@
             return;
         }
 
-        std::unique_ptr<uint8_t, decltype(std::free)*> responseMsgPtr{
-            responseMsg, std::free};
+        std::unique_ptr<void, decltype(std::free)*> responseMsgPtr{responseMsg,
+                                                                   std::free};
 
         // We've got the response meant for the PLDM request msg that was
         // sent out
@@ -409,10 +407,10 @@
         }
         return;
     };
-    IO io(event, fd, EPOLLIN, std::move(callback));
+    IO io(event, pldmTransport.getEventSource(), EPOLLIN, std::move(callback));
 
-    // Send PLDM Request message - pldm_send doesn't wait for response
-    rc = pldm_send(mctpEID, fd, requestMsg.data(), requestMsg.size());
+    // Asynchronously send the PLDM request
+    rc = pldmTransport.sendMsg(pldmTID, requestMsg.data(), requestMsg.size());
     if (0 > rc)
     {
         instanceIdDb.free(pldmTID, instanceID);
diff --git a/softoff/softoff.hpp b/softoff/softoff.hpp
index 85a4010..fce0a52 100644
--- a/softoff/softoff.hpp
+++ b/softoff/softoff.hpp
@@ -1,9 +1,8 @@
 #pragma once
 
+#include "common/transport.hpp"
 #include "common/types.hpp"
 
-#include <libpldm/pldm.h>
-
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/server.hpp>
 #include <sdbusplus/server/object.hpp>
diff --git a/utilities/meson.build b/utilities/meson.build
index 1977aa4..383cf29 100644
--- a/utilities/meson.build
+++ b/utilities/meson.build
@@ -1,14 +1,16 @@
 deps = [ CLI11_dep, libpldm_dep, sdeventplus, phosphor_logging_dep ]
 
-executable('set-state-effecter', 'requester/set_state_effecter.cpp',
+executable('set-state-effecter', 'requester/set_state_effecter.cpp', '../common/transport.cpp',
            implicit_include_directories: false,
+           include_directories: [ '..' ],
            dependencies: deps,
            install: true,
            install_dir: get_option('bindir'))
 
 executable('set-state-effecter-async',
-           'requester/set_state_effecter_async.cpp',
+           'requester/set_state_effecter_async.cpp', '../common/transport.cpp',
            implicit_include_directories: false,
+           include_directories: [ '..' ],
            dependencies: deps,
            install: true,
            install_dir: get_option('bindir'))
diff --git a/utilities/requester/set_state_effecter.cpp b/utilities/requester/set_state_effecter.cpp
index c71f079..4243f4c 100644
--- a/utilities/requester/set_state_effecter.cpp
+++ b/utilities/requester/set_state_effecter.cpp
@@ -1,5 +1,6 @@
+#include "common/transport.hpp"
+
 #include <libpldm/platform.h>
-#include <libpldm/pldm.h>
 
 #include <CLI/CLI.hpp>
 #include <phosphor-logging/lg2.hpp>
@@ -37,19 +38,14 @@
         return -1;
     }
 
-    // Open connection to MCTP socket
-    int fd = pldm_open();
-    if (-1 == fd)
-    {
-        error("Failed to init mctp");
-        return -1;
-    }
+    PldmTransport pldmTransport{};
 
-    uint8_t* responseMsg = nullptr;
+    void* responseMsg = nullptr;
     size_t responseMsgSize{};
     // Send PLDM request msg and wait for response
-    rc = pldm_send_recv(mctpEid, fd, requestMsg.data(), requestMsg.size(),
-                        &responseMsg, &responseMsgSize);
+    rc = pldmTransport.sendRecvMsg(static_cast<pldm_tid_t>(mctpEid),
+                                   requestMsg.data(), requestMsg.size(),
+                                   responseMsg, responseMsgSize);
     if (0 > rc)
     {
         error(
diff --git a/utilities/requester/set_state_effecter_async.cpp b/utilities/requester/set_state_effecter_async.cpp
index 8a7a041..bf905e3 100644
--- a/utilities/requester/set_state_effecter_async.cpp
+++ b/utilities/requester/set_state_effecter_async.cpp
@@ -1,6 +1,7 @@
+#include "common/transport.hpp"
+
 #include <libpldm/base.h>
 #include <libpldm/platform.h>
-#include <libpldm/pldm.h>
 
 #include <CLI/CLI.hpp>
 #include <phosphor-logging/lg2.hpp>
@@ -25,6 +26,8 @@
     app.add_option("-s,--state", state, "New state value")->required();
     CLI11_PARSE(app, argc, argv);
 
+    pldm_tid_t dstTid = static_cast<pldm_tid_t>(mctpEid);
+
     // Encode PLDM Request message
     uint8_t effecterCount = 1;
     std::array<uint8_t, sizeof(pldm_msg_hdr) + sizeof(effecterId) +
@@ -42,42 +45,44 @@
         return -1;
     }
 
-    // Get fd of MCTP socket
-    int fd = pldm_open();
-    if (-1 == fd)
-    {
-        error("Failed to init mctp");
-        return -1;
-    }
+    PldmTransport pldmTransport{};
 
     // Create event loop and add a callback to handle EPOLLIN on fd
     auto event = Event::get_default();
-    auto callback = [=](IO& io, int fd, uint32_t revents) {
+    auto callback =
+        [=, &pldmTransport](IO& io, int fd, uint32_t revents) mutable {
         if (!(revents & EPOLLIN))
         {
             return;
         }
 
-        uint8_t* responseMsg = nullptr;
-        size_t responseMsgSize{};
-        auto rc = pldm_recv(mctpEid, fd, request->hdr.instance_id, &responseMsg,
-                            &responseMsgSize);
-        if (!rc)
+        if (pldmTransport.getEventSource() != fd)
         {
-            // We've got the response meant for the PLDM request msg that was
-            // sent out
-            io.set_enabled(Enabled::Off);
-            pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg);
-            info("Done. PLDM RC = {RC}", "RC", lg2::hex,
-                 static_cast<uint16_t>(response->payload[0]));
-            free(responseMsg);
-            exit(EXIT_SUCCESS);
+            return;
         }
-    };
-    IO io(event, fd, EPOLLIN, std::move(callback));
 
-    // Send PLDM Request message - pldm_send doesn't wait for response
-    rc = pldm_send(mctpEid, fd, requestMsg.data(), requestMsg.size());
+        void* responseMsg = nullptr;
+        size_t responseMsgSize{};
+        pldm_tid_t srcTid;
+        auto rc = pldmTransport.recvMsg(srcTid, responseMsg, responseMsgSize);
+        pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg);
+        if (rc || dstTid != srcTid ||
+            !pldm_msg_hdr_correlate_response(&request->hdr, &response->hdr))
+        {
+            return;
+        }
+
+        // We've got the response meant for the PLDM request msg that was sent
+        // out
+        io.set_enabled(Enabled::Off);
+        info("Done. PLDM RC = {RC}", "RC", lg2::hex,
+             static_cast<uint16_t>(response->payload[0]));
+        free(responseMsg);
+        exit(EXIT_SUCCESS);
+    };
+    IO io(event, pldmTransport.getEventSource(), EPOLLIN, std::move(callback));
+
+    rc = pldmTransport.sendMsg(dstTid, requestMsg.data(), requestMsg.size());
     if (0 > rc)
     {
         error(