diff --git a/src/nvidia-gpu/Inventory.cpp b/src/nvidia-gpu/Inventory.cpp
index 7a1c3cc..0541d81 100644
--- a/src/nvidia-gpu/Inventory.cpp
+++ b/src/nvidia-gpu/Inventory.cpp
@@ -16,7 +16,9 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <span>
 #include <string>
+#include <system_error>
 #include <unordered_map>
 #include <variant>
 #include <vector>
@@ -39,9 +41,6 @@
     name(escapeName(inventoryName)), mctpRequester(mctpRequester),
     deviceType(deviceTypeIn), eid(eid), retryTimer(io)
 {
-    requestBuffer = std::make_shared<InventoryRequestBuffer>();
-    responseBuffer = std::make_shared<InventoryResponseBuffer>();
-
     std::string path = inventoryPrefix + name;
 
     assetIface = objectServer.add_interface(path, assetIfaceName);
@@ -134,7 +133,7 @@
     gpu::InventoryPropertyId propertyId)
 {
     int rc = gpu::encodeGetInventoryInformationRequest(
-        0, static_cast<uint8_t>(propertyId), *requestBuffer);
+        0, static_cast<uint8_t>(propertyId), requestBuffer);
     if (rc != 0)
     {
         lg2::error(
@@ -148,15 +147,17 @@
         "Sending inventory request for property ID {PROP_ID} to EID {EID} for {NAME}",
         "PROP_ID", static_cast<uint8_t>(propertyId), "EID", eid, "NAME", name);
 
-    mctpRequester.sendRecvMsg(eid, *requestBuffer, *responseBuffer,
-                              [this, propertyId](int sendRecvMsgResult) {
-                                  this->handleInventoryPropertyResponse(
-                                      propertyId, sendRecvMsgResult);
-                              });
+    mctpRequester.sendRecvMsg(
+        eid, requestBuffer,
+        [this, propertyId](const std::error_code& result,
+                           std::span<const uint8_t> buffer) {
+            this->handleInventoryPropertyResponse(propertyId, result, buffer);
+        });
 }
 
 void Inventory::handleInventoryPropertyResponse(
-    gpu::InventoryPropertyId propertyId, int sendRecvMsgResult)
+    gpu::InventoryPropertyId propertyId, const std::error_code& ec,
+    std::span<const uint8_t> buffer)
 {
     auto it = properties.find(propertyId);
     if (it == properties.end())
@@ -168,19 +169,19 @@
     }
 
     bool success = false;
-    if (sendRecvMsgResult == 0)
+    if (!ec)
     {
         ocp::accelerator_management::CompletionCode cc{};
         uint16_t reasonCode = 0;
         gpu::InventoryValue info;
         int rc = gpu::decodeGetInventoryInformationResponse(
-            *responseBuffer, cc, reasonCode, propertyId, info);
+            buffer, cc, reasonCode, propertyId, info);
 
         lg2::info(
             "Response for property ID {PROP_ID} from {NAME}, sendRecvMsgResult: {RESULT}, decode_rc: {RC}, completion_code: {CC}, reason_code: {REASON}",
             "PROP_ID", static_cast<uint8_t>(propertyId), "NAME", name, "RESULT",
-            sendRecvMsgResult, "RC", rc, "CC", static_cast<uint8_t>(cc),
-            "REASON", reasonCode);
+            ec.message(), "RC", rc, "CC", static_cast<uint8_t>(cc), "REASON",
+            reasonCode);
 
         if (rc == 0 &&
             cc == ocp::accelerator_management::CompletionCode::SUCCESS)
diff --git a/src/nvidia-gpu/Inventory.hpp b/src/nvidia-gpu/Inventory.hpp
index ea38f6f..5a24e56 100644
--- a/src/nvidia-gpu/Inventory.hpp
+++ b/src/nvidia-gpu/Inventory.hpp
@@ -16,11 +16,6 @@
 #include <string>
 #include <unordered_map>
 
-using InventoryRequestBuffer =
-    std::array<uint8_t, sizeof(gpu::GetInventoryInformationRequest)>;
-using InventoryResponseBuffer =
-    std::array<uint8_t, sizeof(gpu::GetInventoryInformationResponse)>;
-
 class Inventory : public std::enable_shared_from_this<Inventory>
 {
   public:
@@ -41,7 +36,8 @@
     };
     void sendInventoryPropertyRequest(gpu::InventoryPropertyId propertyId);
     void handleInventoryPropertyResponse(gpu::InventoryPropertyId propertyId,
-                                         int sendRecvMsgResult);
+                                         const std::error_code& ec,
+                                         std::span<const uint8_t> buffer);
     void processNextProperty();
     void processInventoryProperty(gpu::InventoryPropertyId propertyId);
     void registerProperty(
@@ -67,8 +63,8 @@
     uint8_t eid;
     boost::asio::steady_timer retryTimer;
     std::unordered_map<gpu::InventoryPropertyId, PropertyInfo> properties;
-    std::shared_ptr<InventoryRequestBuffer> requestBuffer;
-    std::shared_ptr<InventoryResponseBuffer> responseBuffer;
+    std::array<uint8_t, sizeof(gpu::GetInventoryInformationRequest)>
+        requestBuffer{};
     static constexpr std::chrono::seconds retryDelay{5};
     static constexpr int maxRetryAttempts = 3;
 };
diff --git a/src/nvidia-gpu/MctpRequester.cpp b/src/nvidia-gpu/MctpRequester.cpp
index 765859e..f28371f 100644
--- a/src/nvidia-gpu/MctpRequester.cpp
+++ b/src/nvidia-gpu/MctpRequester.cpp
@@ -18,13 +18,17 @@
 #include <boost/container/devector.hpp>
 #include <phosphor-logging/lg2.hpp>
 
-#include <cerrno>
+#include <bit>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
+#include <expected>
+#include <format>
 #include <functional>
-#include <memory>
+#include <optional>
 #include <span>
+#include <stdexcept>
+#include <system_error>
 #include <utility>
 
 using namespace std::literals;
@@ -32,131 +36,314 @@
 namespace mctp
 {
 
-Requester::Requester(boost::asio::io_context& ctx) :
-    mctpSocket(ctx, boost::asio::generic::datagram_protocol{AF_MCTP, 0}),
-    expiryTimer(ctx)
-{}
-
-void Requester::processRecvMsg(
-    const std::span<const uint8_t> reqMsg, const std::span<uint8_t> respMsg,
-    const boost::system::error_code& ec, const size_t /*length*/)
+static const ocp::accelerator_management::BindingPciVid* getHeaderFromBuffer(
+    std::span<const uint8_t> buffer)
 {
-    const auto* respAddr =
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        reinterpret_cast<const struct sockaddr_mctp*>(recvEndPoint.data());
-
-    uint8_t eid = respAddr->smctp_addr.s_addr;
-
-    if (!completionCallbacks.contains(eid))
+    if (buffer.size() < sizeof(ocp::accelerator_management::BindingPciVid))
     {
-        lg2::error(
-            "MctpRequester failed to get the callback for the EID: {EID}",
-            "EID", static_cast<int>(eid));
+        return nullptr;
+    }
+
+    return std::bit_cast<const ocp::accelerator_management::BindingPciVid*>(
+        buffer.data());
+}
+
+static std::optional<uint8_t> getIid(std::span<const uint8_t> buffer)
+{
+    const ocp::accelerator_management::BindingPciVid* header =
+        getHeaderFromBuffer(buffer);
+    if (header == nullptr)
+    {
+        return std::nullopt;
+    }
+    return header->instance_id & ocp::accelerator_management::instanceIdBitMask;
+}
+
+static std::optional<bool> getRequestBit(std::span<const uint8_t> buffer)
+{
+    const ocp::accelerator_management::BindingPciVid* header =
+        getHeaderFromBuffer(buffer);
+    if (header == nullptr)
+    {
+        return std::nullopt;
+    }
+    return header->instance_id & ocp::accelerator_management::requestBitMask;
+}
+
+MctpRequester::MctpRequester(boost::asio::io_context& ctx) :
+    io{ctx},
+    mctpSocket(ctx, boost::asio::generic::datagram_protocol{AF_MCTP, 0})
+{
+    startReceive();
+}
+
+void MctpRequester::startReceive()
+{
+    mctpSocket.async_receive_from(
+        boost::asio::buffer(buffer), recvEndPoint.endpoint,
+        std::bind_front(&MctpRequester::processRecvMsg, this));
+}
+
+void MctpRequester::processRecvMsg(const boost::system::error_code& ec,
+                                   const size_t length)
+{
+    std::optional<uint8_t> expectedEid = recvEndPoint.eid();
+    std::optional<uint8_t> receivedMsgType = recvEndPoint.type();
+
+    if (!expectedEid || !receivedMsgType)
+    {
+        // we were handed an endpoint that can't be treated as an MCTP endpoint
+        // This is probably a kernel bug...yell about it and rebind.
+        lg2::error("MctpRequester: invalid endpoint");
         return;
     }
 
-    auto& callback = completionCallbacks.at(eid);
-
-    if (respAddr->smctp_type != msgType)
+    if (*receivedMsgType != msgType)
     {
-        lg2::error("MctpRequester: Message type mismatch");
-        callback(EPROTO);
+        // we received a message that this handler doesn't support
+        // drop it on the floor and rebind receive_from
+        lg2::error("MctpRequester: Message type mismatch. We received {MSG}",
+                   "MSG", *receivedMsgType);
         return;
     }
 
-    expiryTimer.cancel();
+    uint8_t eid = *expectedEid;
 
     if (ec)
     {
         lg2::error(
             "MctpRequester failed to receive data from the MCTP socket - ErrorCode={EC}, Error={ER}.",
             "EC", ec.value(), "ER", ec.message());
-        callback(EIO);
+        handleResult(eid, static_cast<std::error_code>(ec), {});
         return;
     }
 
-    if (respMsg.size() > sizeof(ocp::accelerator_management::BindingPciVid))
+    // if the received length was greater than our buffer, we would've truncated
+    // and gotten an error code in asio
+    std::span<const uint8_t> responseBuffer{buffer.data(), length};
+
+    std::optional<uint8_t> optionalIid = getIid(responseBuffer);
+    std::optional<bool> isRq = getRequestBit(responseBuffer);
+    if (!optionalIid || !isRq)
     {
-        const auto* reqHdr =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            reinterpret_cast<const ocp::accelerator_management::BindingPciVid*>(
-                reqMsg.data());
-
-        uint8_t reqInstanceId = reqHdr->instance_id &
-                                ocp::accelerator_management::instanceIdBitMask;
-        const auto* respHdr =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            reinterpret_cast<const ocp::accelerator_management::BindingPciVid*>(
-                respMsg.data());
-
-        uint8_t respInstanceId = respHdr->instance_id &
-                                 ocp::accelerator_management::instanceIdBitMask;
-
-        if (reqInstanceId != respInstanceId)
-        {
-            lg2::error(
-                "MctpRequester: Instance ID mismatch - request={REQ}, response={RESP}",
-                "REQ", static_cast<int>(reqInstanceId), "RESP",
-                static_cast<int>(respInstanceId));
-            callback(EPROTO);
-            return;
-        }
+        // we received something from the device,
+        // but we aren't able to parse iid byte
+        // drop this packet on the floor
+        // and rely on the timer to notify the client
+        lg2::error("MctpRequester: Unable to decode message from eid {EID}",
+                   "EID", eid);
+        return;
     }
 
-    callback(0);
+    if (isRq.value())
+    {
+        // we received a request from a downstream device.
+        // We don't currently support this, drop the packet
+        // on the floor and rebind receive, keep the timer running
+        return;
+    }
+
+    uint8_t iid = *optionalIid;
+
+    auto it = requestContextQueues.find(eid);
+    if (it == requestContextQueues.end())
+    {
+        // something very bad has happened here
+        // we've received a packet that is a response
+        // from a device we've never talked to
+        // do our best and rebind receive and keep the timer running
+        lg2::error("Unable to match request to response");
+        return;
+    }
+
+    if (iid != it->second.iid)
+    {
+        // we received an iid that doesn't match the one we sent
+        // rebind async_receive_from and drop this packet on the floor
+        lg2::error("Invalid iid {IID} from eid {EID}, expected {E_IID}", "IID",
+                   iid, "EID", eid, "E_IID", it->second.iid);
+        return;
+    }
+
+    handleResult(eid, std::error_code{}, responseBuffer);
 }
 
-void Requester::handleSendMsgCompletion(
-    uint8_t eid, const std::span<const uint8_t> reqMsg,
-    std::span<uint8_t> respMsg, const boost::system::error_code& ec,
-    size_t /* length */)
+void MctpRequester::handleSendMsgCompletion(
+    uint8_t eid, const boost::system::error_code& ec, size_t /* length */)
 {
-    if (!completionCallbacks.contains(eid))
-    {
-        lg2::error(
-            "MctpRequester failed to get the callback for the EID: {EID}",
-            "EID", static_cast<int>(eid));
-        return;
-    }
-
-    auto& callback = completionCallbacks.at(eid);
-
     if (ec)
     {
         lg2::error(
             "MctpRequester failed to send data from the MCTP socket - ErrorCode={EC}, Error={ER}.",
             "EC", ec.value(), "ER", ec.message());
-        callback(EIO);
+        handleResult(eid, static_cast<std::error_code>(ec), {});
         return;
     }
 
+    auto it = requestContextQueues.find(eid);
+    if (it == requestContextQueues.end())
+    {
+        // something very bad has happened here,
+        // we've sent something to a device that we have
+        // no record of. yell loudly and bail
+        lg2::error(
+            "MctpRequester completed send for an EID that we have no record of");
+        return;
+    }
+
+    boost::asio::steady_timer& expiryTimer = it->second.timer;
     expiryTimer.expires_after(2s);
 
     expiryTimer.async_wait([this, eid](const boost::system::error_code& ec) {
         if (ec != boost::asio::error::operation_aborted)
         {
-            auto& callback = completionCallbacks.at(eid);
-            callback(ETIME);
+            lg2::error("Operation timed out on eid {EID}", "EID", eid);
+            handleResult(eid, std::make_error_code(std::errc::timed_out), {});
         }
     });
-
-    mctpSocket.async_receive_from(
-        boost::asio::mutable_buffer(respMsg), recvEndPoint,
-        std::bind_front(&Requester::processRecvMsg, this, reqMsg, respMsg));
 }
 
-void Requester::sendRecvMsg(uint8_t eid, const std::span<const uint8_t> reqMsg,
-                            std::span<uint8_t> respMsg,
-                            std::move_only_function<void(int)> callback)
+void MctpRequester::sendRecvMsg(
+    uint8_t eid, std::span<const uint8_t> reqMsg,
+    std::move_only_function<void(const std::error_code&,
+                                 std::span<const uint8_t>)>
+        callback)
 {
-    if (reqMsg.size() < sizeof(ocp::accelerator_management::BindingPciVid))
+    RequestContext reqCtx{reqMsg, std::move(callback)};
+
+    // try_emplace only affects the result if the key does not already exist
+    auto [it, inserted] = requestContextQueues.try_emplace(eid, io);
+    (void)inserted;
+
+    auto& queue = it->second.queue;
+    queue.push_back(std::move(reqCtx));
+
+    if (queue.size() == 1)
     {
-        lg2::error("MctpRequester: Message too small");
-        callback(EPROTO);
+        processQueue(eid);
+    }
+}
+
+static bool isFatalError(const std::error_code& ec)
+{
+    return ec &&
+           (ec != std::errc::timed_out && ec != std::errc::host_unreachable);
+}
+
+void MctpRequester::handleResult(uint8_t eid, const std::error_code& ec,
+                                 std::span<const uint8_t> buffer)
+{
+    auto it = requestContextQueues.find(eid);
+    if (it == requestContextQueues.end())
+    {
+        lg2::error("We tried to a handle a result for an eid we don't have");
+
+        startReceive();
         return;
     }
 
-    completionCallbacks[eid] = std::move(callback);
+    auto& queue = it->second.queue;
+    auto& reqCtx = queue.front();
+
+    it->second.timer.cancel();
+
+    reqCtx.callback(ec, buffer); // Call the original callback
+
+    if (isFatalError(ec))
+    {
+        // some errors are fatal, since these are datagrams,
+        // we won't get a receive path error message.
+        // and since this daemon services all nvidia iana commands
+        // for a given system, we should only restart the service if its
+        // unrecoverable, i.e. if we get error codes that the client
+        // can't reasonably deal with. If thats the cause, restart
+        // and hope that we can deal with it then.
+        // since we're fully async, the only reasonable way to bubble
+        // this issue up is to chuck an exception and let main deal with it.
+        // alternatively we could call cancel on the io_context, but there's
+        // not a great way to figure *what* happened.
+        throw std::runtime_error(std::format(
+            "eid {} encountered a fatal error: {}", eid, ec.message()));
+    }
+
+    startReceive();
+
+    queue.pop_front();
+
+    processQueue(eid);
+}
+
+std::optional<uint8_t> MctpRequester::getNextIid(uint8_t eid)
+{
+    auto it = requestContextQueues.find(eid);
+    if (it == requestContextQueues.end())
+    {
+        return std::nullopt;
+    }
+
+    uint8_t& iid = it->second.iid;
+    ++iid;
+    iid &= ocp::accelerator_management::instanceIdBitMask;
+    return iid;
+}
+
+static std::expected<void, std::error_code> injectIid(std::span<uint8_t> buffer,
+                                                      uint8_t iid)
+{
+    if (buffer.size() < sizeof(ocp::accelerator_management::BindingPciVid))
+    {
+        return std::unexpected(
+            std::make_error_code(std::errc::invalid_argument));
+    }
+
+    if (iid > ocp::accelerator_management::instanceIdBitMask)
+    {
+        return std::unexpected(
+            std::make_error_code(std::errc::invalid_argument));
+    }
+
+    auto* header = std::bit_cast<ocp::accelerator_management::BindingPciVid*>(
+        buffer.data());
+
+    header->instance_id &= ~ocp::accelerator_management::instanceIdBitMask;
+    header->instance_id |= iid;
+    return {};
+}
+
+void MctpRequester::processQueue(uint8_t eid)
+{
+    auto it = requestContextQueues.find(eid);
+    if (it == requestContextQueues.end())
+    {
+        lg2::error("We are attempting to process a queue that doesn't exist");
+        return;
+    }
+
+    auto& queue = it->second.queue;
+
+    if (queue.empty())
+    {
+        return;
+    }
+    auto& reqCtx = queue.front();
+
+    std::span<uint8_t> req{reqCtx.reqMsg.data(), reqCtx.reqMsg.size()};
+
+    std::optional<uint8_t> iid = getNextIid(eid);
+    if (!iid)
+    {
+        lg2::error("MctpRequester: Unable to get next iid");
+        handleResult(eid, std::make_error_code(std::errc::no_such_device), {});
+        return;
+    }
+
+    std::expected<void, std::error_code> success = injectIid(req, *iid);
+    if (!success)
+    {
+        lg2::error("MctpRequester: unable to set iid");
+        handleResult(eid, success.error(), {});
+        return;
+    }
 
     struct sockaddr_mctp addr{};
     addr.smctp_family = AF_MCTP;
@@ -167,54 +354,8 @@
     sendEndPoint = {&addr, sizeof(addr)};
 
     mctpSocket.async_send_to(
-        boost::asio::const_buffer(reqMsg), sendEndPoint,
-        std::bind_front(&Requester::handleSendMsgCompletion, this, eid, reqMsg,
-                        respMsg));
-}
-
-void QueuingRequester::sendRecvMsg(uint8_t eid, std::span<const uint8_t> reqMsg,
-                                   std::span<uint8_t> respMsg,
-                                   std::move_only_function<void(int)> callback)
-{
-    auto reqCtx =
-        std::make_unique<RequestContext>(reqMsg, respMsg, std::move(callback));
-
-    // Add request to queue
-    auto& queue = requestContextQueues[eid];
-    queue.push_back(std::move(reqCtx));
-
-    if (queue.size() == 1)
-    {
-        processQueue(eid);
-    }
-}
-
-void QueuingRequester::handleResult(uint8_t eid, int result)
-{
-    auto& queue = requestContextQueues[eid];
-    const auto& reqCtx = queue.front();
-
-    reqCtx->callback(result); // Call the original callback
-
-    queue.pop_front();
-
-    processQueue(eid);
-}
-
-void QueuingRequester::processQueue(uint8_t eid)
-{
-    auto& queue = requestContextQueues[eid];
-
-    if (queue.empty())
-    {
-        return;
-    }
-
-    const auto& reqCtx = queue.front();
-
-    requester.sendRecvMsg(
-        eid, reqCtx->reqMsg, reqCtx->respMsg,
-        std::bind_front(&QueuingRequester::handleResult, this, eid));
+        boost::asio::const_buffer(req.data(), req.size()), sendEndPoint,
+        std::bind_front(&MctpRequester::handleSendMsgCompletion, this, eid));
 }
 
 } // namespace mctp
diff --git a/src/nvidia-gpu/MctpRequester.hpp b/src/nvidia-gpu/MctpRequester.hpp
index 9d05ebd..0fd4683 100644
--- a/src/nvidia-gpu/MctpRequester.hpp
+++ b/src/nvidia-gpu/MctpRequester.hpp
@@ -6,88 +6,61 @@
 
 #pragma once
 
+#include <MctpAsioEndpoint.hpp>
 #include <OcpMctpVdm.hpp>
 #include <boost/asio/generic/datagram_protocol.hpp>
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/steady_timer.hpp>
+#include <boost/circular_buffer.hpp>
 #include <boost/container/devector.hpp>
+#include <boost/container/flat_map.hpp>
+#include <boost/container/small_vector.hpp>
 
 #include <cstddef>
 #include <cstdint>
+#include <expected>
 #include <functional>
+#include <iostream>
 #include <memory>
+#include <queue>
 #include <span>
+#include <system_error>
 #include <unordered_map>
 #include <utility>
 
 namespace mctp
 {
-class Requester
+class MctpRequester
 {
   public:
-    Requester() = delete;
+    MctpRequester() = delete;
 
-    Requester(const Requester&) = delete;
+    MctpRequester(const MctpRequester&) = delete;
 
-    Requester(Requester&&) = delete;
+    MctpRequester(MctpRequester&&) = delete;
 
-    Requester& operator=(const Requester&) = delete;
+    MctpRequester& operator=(const MctpRequester&) = delete;
 
-    Requester& operator=(Requester&&) = delete;
+    MctpRequester& operator=(MctpRequester&&) = delete;
 
-    explicit Requester(boost::asio::io_context& ctx);
+    explicit MctpRequester(boost::asio::io_context& ctx);
 
     void sendRecvMsg(uint8_t eid, std::span<const uint8_t> reqMsg,
-                     std::span<uint8_t> respMsg,
-                     std::move_only_function<void(int)> callback);
+                     std::move_only_function<void(const std::error_code&,
+                                                  std::span<const uint8_t>)>
+                         callback);
 
   private:
-    void processRecvMsg(std::span<const uint8_t> reqMsg,
-                        std::span<uint8_t> respMsg,
-                        const boost::system::error_code& ec, size_t length);
-
-    void handleSendMsgCompletion(uint8_t eid, std::span<const uint8_t> reqMsg,
-                                 std::span<uint8_t> respMsg,
-                                 const boost::system::error_code& ec,
-                                 size_t length);
-
-    boost::asio::generic::datagram_protocol::socket mctpSocket;
+    using cb_t = std::move_only_function<void(const std::error_code&,
+                                              std::span<const uint8_t>)>;
 
     static constexpr size_t maxMessageSize = 65536 + 256;
-
-    boost::asio::generic::datagram_protocol::endpoint sendEndPoint;
-
-    boost::asio::generic::datagram_protocol::endpoint recvEndPoint;
-
-    boost::asio::steady_timer expiryTimer;
-
-    std::unordered_map<uint8_t, std::move_only_function<void(int)>>
-        completionCallbacks;
-
     static constexpr uint8_t msgType = ocp::accelerator_management::messageType;
-};
 
-class QueuingRequester
-{
-  public:
-    QueuingRequester() = delete;
-    QueuingRequester(const QueuingRequester&) = delete;
-    QueuingRequester(QueuingRequester&&) = delete;
-    QueuingRequester& operator=(const QueuingRequester&) = delete;
-    QueuingRequester& operator=(QueuingRequester&&) = delete;
-
-    explicit QueuingRequester(boost::asio::io_context& ctx) : requester(ctx) {}
-
-    void sendRecvMsg(uint8_t eid, std::span<const uint8_t> reqMsg,
-                     std::span<uint8_t> respMsg,
-                     std::move_only_function<void(int)> callback);
-
-  private:
     struct RequestContext
     {
-        std::span<const uint8_t> reqMsg;
-        std::span<uint8_t> respMsg;
-        std::move_only_function<void(int)> callback;
+        std::vector<uint8_t> reqMsg;
+        cb_t callback;
 
         RequestContext(const RequestContext&) = delete;
         RequestContext& operator=(const RequestContext&) = delete;
@@ -96,21 +69,42 @@
         RequestContext& operator=(RequestContext&&) = default;
         ~RequestContext() = default;
 
-        explicit RequestContext(std::span<const uint8_t> req,
-                                std::span<uint8_t> resp,
-                                std::move_only_function<void(int)>&& cb) :
-            reqMsg(req), respMsg(resp), callback(std::move(cb))
+        explicit RequestContext(std::span<const uint8_t> req, cb_t&& cb) :
+            reqMsg(req.begin(), req.end()), callback(std::move(cb))
         {}
     };
 
-    void handleResult(uint8_t eid, int result);
+    struct EidContext
+    {
+        boost::asio::steady_timer timer;
+        uint8_t iid{};
+        boost::container::devector<RequestContext> queue;
+        EidContext(boost::asio::io_context& io) : timer{io}, iid{0xFF} {}
+        EidContext(EidContext&&) noexcept = default;
+        EidContext& operator=(EidContext&&) noexcept = default;
+        EidContext& operator=(const EidContext&) = delete;
+        EidContext(const EidContext&) = delete;
+        ~EidContext() = default;
+    };
+
+    std::optional<uint8_t> getNextIid(uint8_t eid);
+    void startReceive();
+    void processRecvMsg(const boost::system::error_code& ec, size_t length);
+    void handleSendMsgCompletion(uint8_t eid,
+                                 const boost::system::error_code& ec,
+                                 size_t length);
+
+    void handleResult(uint8_t eid, const std::error_code& ec,
+                      std::span<const uint8_t> buffer);
     void processQueue(uint8_t eid);
 
-    Requester requester;
-    std::unordered_map<
-        uint8_t, boost::container::devector<std::unique_ptr<RequestContext>>>
-        requestContextQueues;
+    boost::asio::io_context& io;
+    boost::asio::generic::datagram_protocol::endpoint sendEndPoint;
+
+    boost::asio::generic::datagram_protocol::socket mctpSocket;
+    std::array<uint8_t, maxMessageSize> buffer{};
+    MctpAsioEndpoint recvEndPoint;
+    std::unordered_map<uint8_t, EidContext> requestContextQueues;
 };
 
-using MctpRequester = QueuingRequester;
 } // namespace mctp
diff --git a/src/nvidia-gpu/NvidiaDeviceDiscovery.cpp b/src/nvidia-gpu/NvidiaDeviceDiscovery.cpp
index dd682cf..47ec061 100644
--- a/src/nvidia-gpu/NvidiaDeviceDiscovery.cpp
+++ b/src/nvidia-gpu/NvidiaDeviceDiscovery.cpp
@@ -30,6 +30,7 @@
 #include <span>
 #include <stdexcept>
 #include <string>
+#include <system_error>
 #include <utility>
 #include <variant>
 #include <vector>
@@ -44,14 +45,15 @@
         smaDevices,
     const std::shared_ptr<sdbusplus::asio::connection>& conn,
     mctp::MctpRequester& mctpRequester, const SensorConfigs& configs,
-    const std::string& path, uint8_t eid, int sendRecvMsgResult,
-    std::span<uint8_t> queryDeviceIdentificationResponse)
+    const std::string& path, uint8_t eid,
+    const std::error_code& sendRecvMsgResult,
+    std::span<const uint8_t> queryDeviceIdentificationResponse)
 {
-    if (sendRecvMsgResult != 0)
+    if (sendRecvMsgResult)
     {
         lg2::error(
             "Error processing MCTP endpoint with eid {EID} : sending message over MCTP failed, rc={RC}",
-            "EID", eid, "RC", sendRecvMsgResult);
+            "EID", eid, "RC", sendRecvMsgResult.message());
         return;
     }
 
@@ -121,9 +123,6 @@
     auto queryDeviceIdentificationRequest = std::make_shared<
         std::array<uint8_t, sizeof(gpu::QueryDeviceIdentificationRequest)>>();
 
-    auto queryDeviceIdentificationResponse = std::make_shared<
-        std::array<uint8_t, sizeof(gpu::QueryDeviceIdentificationResponse)>>();
-
     auto rc = gpu::encodeQueryDeviceIdentificationRequest(
         0, *queryDeviceIdentificationRequest);
     if (rc != 0)
@@ -136,14 +135,12 @@
 
     mctpRequester.sendRecvMsg(
         eid, *queryDeviceIdentificationRequest,
-        *queryDeviceIdentificationResponse,
         [&io, &objectServer, &gpuDevices, &smaDevices, conn, &mctpRequester,
-         configs, path, eid, queryDeviceIdentificationRequest,
-         queryDeviceIdentificationResponse](int sendRecvMsgResult) {
-            processQueryDeviceIdResponse(
-                io, objectServer, gpuDevices, smaDevices, conn, mctpRequester,
-                configs, path, eid, sendRecvMsgResult,
-                *queryDeviceIdentificationResponse);
+         configs, path, eid, queryDeviceIdentificationRequest](
+            const std::error_code& ec, std::span<const uint8_t> response) {
+            processQueryDeviceIdResponse(io, objectServer, gpuDevices,
+                                         smaDevices, conn, mctpRequester,
+                                         configs, path, eid, ec, response);
         });
 }
 
diff --git a/src/nvidia-gpu/NvidiaGpuDevice.cpp b/src/nvidia-gpu/NvidiaGpuDevice.cpp
index 9560220..4bba49c 100644
--- a/src/nvidia-gpu/NvidiaGpuDevice.cpp
+++ b/src/nvidia-gpu/NvidiaGpuDevice.cpp
@@ -6,20 +6,18 @@
 
 #include "NvidiaGpuDevice.hpp"
 
-#include "Inventory.hpp"
-#include "NvidiaDeviceDiscovery.hpp"
-#include "NvidiaGpuSensor.hpp"
+#include "NvidiaGpuThresholds.hpp"
 #include "Thresholds.hpp"
 #include "Utils.hpp"
 
-#include <bits/basic_string.h>
-
+#include <Inventory.hpp>
 #include <MctpRequester.hpp>
+#include <NvidiaDeviceDiscovery.hpp>
 #include <NvidiaGpuEnergySensor.hpp>
 #include <NvidiaGpuMctpVdm.hpp>
 #include <NvidiaGpuPowerPeakReading.hpp>
 #include <NvidiaGpuPowerSensor.hpp>
-#include <NvidiaGpuThresholds.hpp>
+#include <NvidiaGpuSensor.hpp>
 #include <NvidiaGpuVoltageSensor.hpp>
 #include <boost/asio/io_context.hpp>
 #include <phosphor-logging/lg2.hpp>
@@ -137,4 +135,4 @@
         }
         read();
     });
-}
+};
diff --git a/src/nvidia-gpu/NvidiaGpuEnergySensor.cpp b/src/nvidia-gpu/NvidiaGpuEnergySensor.cpp
index 6d0fcd8..5d2b9af 100644
--- a/src/nvidia-gpu/NvidiaGpuEnergySensor.cpp
+++ b/src/nvidia-gpu/NvidiaGpuEnergySensor.cpp
@@ -25,7 +25,9 @@
 #include <cstdint>
 #include <limits>
 #include <memory>
+#include <span>
 #include <string>
+#include <system_error>
 #include <utility>
 #include <vector>
 
@@ -80,13 +82,14 @@
     thresholds::checkThresholds(this);
 }
 
-void NvidiaGpuEnergySensor::processResponse(int sendRecvMsgResult)
+void NvidiaGpuEnergySensor::processResponse(const std::error_code& ec,
+                                            std::span<const uint8_t> buffer)
 {
-    if (sendRecvMsgResult != 0)
+    if (ec)
     {
         lg2::error(
             "Error updating Energy Sensor for eid {EID} and sensor id {SID} : sending message over MCTP failed, rc={RC}",
-            "EID", eid, "SID", sensorId, "RC", sendRecvMsgResult);
+            "EID", eid, "SID", sensorId, "RC", ec.message());
         return;
     }
 
@@ -94,8 +97,8 @@
     uint16_t reasonCode = 0;
     uint64_t energyValue = 0;
 
-    auto rc = gpu::decodeGetCurrentEnergyCounterResponse(
-        response, cc, reasonCode, energyValue);
+    auto rc = gpu::decodeGetCurrentEnergyCounterResponse(buffer, cc, reasonCode,
+                                                         energyValue);
 
     if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
     {
@@ -124,6 +127,8 @@
     }
 
     mctpRequester.sendRecvMsg(
-        eid, request, response,
-        [this](int sendRecvMsgResult) { processResponse(sendRecvMsgResult); });
+        eid, request,
+        [this](const std::error_code& ec, std::span<const uint8_t> buffer) {
+            processResponse(ec, buffer);
+        });
 }
diff --git a/src/nvidia-gpu/NvidiaGpuEnergySensor.hpp b/src/nvidia-gpu/NvidiaGpuEnergySensor.hpp
index 19bb982..1d9d1f5 100644
--- a/src/nvidia-gpu/NvidiaGpuEnergySensor.hpp
+++ b/src/nvidia-gpu/NvidiaGpuEnergySensor.hpp
@@ -39,7 +39,8 @@
     void update();
 
   private:
-    void processResponse(int sendRecvMsgResult);
+    void processResponse(const std::error_code& ec,
+                         std::span<const uint8_t> buffer);
 
     uint8_t eid{};
 
@@ -52,7 +53,4 @@
     sdbusplus::asio::object_server& objectServer;
 
     std::array<uint8_t, sizeof(gpu::GetCurrentEnergyCounterRequest)> request{};
-
-    std::array<uint8_t, sizeof(gpu::GetCurrentEnergyCounterResponse)>
-        response{};
 };
diff --git a/src/nvidia-gpu/NvidiaGpuPowerPeakReading.cpp b/src/nvidia-gpu/NvidiaGpuPowerPeakReading.cpp
index 06693e6..839dfe4 100644
--- a/src/nvidia-gpu/NvidiaGpuPowerPeakReading.cpp
+++ b/src/nvidia-gpu/NvidiaGpuPowerPeakReading.cpp
@@ -20,7 +20,9 @@
 #include <cstdint>
 #include <functional>
 #include <memory>
+#include <span>
 #include <string>
+#include <system_error>
 
 using namespace std::literals;
 
@@ -50,13 +52,14 @@
     objectServer.remove_interface(telemetryReportInterface);
 }
 
-void NvidiaGpuPowerPeakReading::processResponse(int sendRecvMsgResult)
+void NvidiaGpuPowerPeakReading::processResponse(const std::error_code& ec,
+                                                std::span<const uint8_t> buffer)
 {
-    if (sendRecvMsgResult != 0)
+    if (ec)
     {
         lg2::error(
             "Error updating Peak Power Sensor for eid {EID} and sensor id {SID} : sending message over MCTP failed, rc={RC}",
-            "EID", eid, "SID", sensorId, "RC", sendRecvMsgResult);
+            "EID", eid, "SID", sensorId, "RC", ec.message());
         return;
     }
 
@@ -65,7 +68,7 @@
     uint32_t peakPower = 0;
 
     const int rc =
-        gpu::decodeGetPowerDrawResponse(response, cc, reasonCode, peakPower);
+        gpu::decodeGetPowerDrawResponse(buffer, cc, reasonCode, peakPower);
 
     if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
     {
@@ -97,6 +100,8 @@
     }
 
     mctpRequester.sendRecvMsg(
-        eid, request, response,
-        [this](int sendRecvMsgResult) { processResponse(sendRecvMsgResult); });
+        eid, request,
+        [this](const std::error_code& ec, std::span<const uint8_t> buffer) {
+            processResponse(ec, buffer);
+        });
 }
diff --git a/src/nvidia-gpu/NvidiaGpuPowerPeakReading.hpp b/src/nvidia-gpu/NvidiaGpuPowerPeakReading.hpp
index 02ba104..cc229d2 100644
--- a/src/nvidia-gpu/NvidiaGpuPowerPeakReading.hpp
+++ b/src/nvidia-gpu/NvidiaGpuPowerPeakReading.hpp
@@ -36,7 +36,8 @@
     void update();
 
   private:
-    void processResponse(int sendRecvMsgResult);
+    void processResponse(const std::error_code& ec,
+                         std::span<const uint8_t> buffer);
 
     uint8_t eid{};
 
@@ -55,7 +56,5 @@
 
     std::array<uint8_t, sizeof(gpu::GetPowerDrawRequest)> request{};
 
-    std::array<uint8_t, sizeof(gpu::GetPowerDrawResponse)> response{};
-
     std::shared_ptr<sdbusplus::asio::dbus_interface> telemetryReportInterface;
 };
diff --git a/src/nvidia-gpu/NvidiaGpuPowerSensor.cpp b/src/nvidia-gpu/NvidiaGpuPowerSensor.cpp
index bac935d..b21ce0e 100644
--- a/src/nvidia-gpu/NvidiaGpuPowerSensor.cpp
+++ b/src/nvidia-gpu/NvidiaGpuPowerSensor.cpp
@@ -26,7 +26,9 @@
 #include <functional>
 #include <limits>
 #include <memory>
+#include <span>
 #include <string>
+#include <system_error>
 #include <utility>
 #include <vector>
 
@@ -82,13 +84,14 @@
     thresholds::checkThresholds(this);
 }
 
-void NvidiaGpuPowerSensor::processResponse(int sendRecvMsgResult)
+void NvidiaGpuPowerSensor::processResponse(const std::error_code& ec,
+                                           std::span<const uint8_t> buffer)
 {
-    if (sendRecvMsgResult != 0)
+    if (ec)
     {
         lg2::error(
             "Error updating Power Sensor for eid {EID} and sensor id {SID} : sending message over MCTP failed, rc={RC}",
-            "EID", eid, "SID", sensorId, "RC", sendRecvMsgResult);
+            "EID", eid, "SID", sensorId, "RC", ec.message());
         return;
     }
 
@@ -97,7 +100,7 @@
     uint32_t power = 0;
 
     const int rc =
-        gpu::decodeGetPowerDrawResponse(response, cc, reasonCode, power);
+        gpu::decodeGetPowerDrawResponse(buffer, cc, reasonCode, power);
 
     if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
     {
@@ -127,6 +130,8 @@
     }
 
     mctpRequester.sendRecvMsg(
-        eid, request, response,
-        [this](int sendRecvMsgResult) { processResponse(sendRecvMsgResult); });
+        eid, request,
+        [this](const std::error_code& ec, std::span<const uint8_t> buffer) {
+            processResponse(ec, buffer);
+        });
 }
diff --git a/src/nvidia-gpu/NvidiaGpuPowerSensor.hpp b/src/nvidia-gpu/NvidiaGpuPowerSensor.hpp
index c217200..8fa967a 100644
--- a/src/nvidia-gpu/NvidiaGpuPowerSensor.hpp
+++ b/src/nvidia-gpu/NvidiaGpuPowerSensor.hpp
@@ -17,7 +17,9 @@
 #include <array>
 #include <cstdint>
 #include <memory>
+#include <span>
 #include <string>
+#include <system_error>
 #include <vector>
 
 constexpr uint8_t gpuPowerSensorId{0};
@@ -39,7 +41,8 @@
     void update();
 
   private:
-    void processResponse(int sendRecvMsgResult);
+    void processResponse(const std::error_code& ec,
+                         std::span<const uint8_t> buffer);
 
     uint8_t eid{};
 
@@ -54,6 +57,4 @@
     sdbusplus::asio::object_server& objectServer;
 
     std::array<uint8_t, sizeof(gpu::GetPowerDrawRequest)> request{};
-
-    std::array<uint8_t, sizeof(gpu::GetPowerDrawResponse)> response{};
 };
diff --git a/src/nvidia-gpu/NvidiaGpuSensor.cpp b/src/nvidia-gpu/NvidiaGpuSensor.cpp
index 3853048..26fb1c4 100644
--- a/src/nvidia-gpu/NvidiaGpuSensor.cpp
+++ b/src/nvidia-gpu/NvidiaGpuSensor.cpp
@@ -25,7 +25,9 @@
 #include <cstdint>
 #include <functional>
 #include <memory>
+#include <span>
 #include <string>
+#include <system_error>
 #include <utility>
 #include <vector>
 
@@ -79,13 +81,14 @@
     thresholds::checkThresholds(this);
 }
 
-void NvidiaGpuTempSensor::processResponse(int sendRecvMsgResult)
+void NvidiaGpuTempSensor::processResponse(const std::error_code& ec,
+                                          std::span<const uint8_t> buffer)
 {
-    if (sendRecvMsgResult != 0)
+    if (ec)
     {
         lg2::error(
             "Error updating Temperature Sensor for eid {EID} and sensor id {SID} : sending message over MCTP failed, rc={RC}",
-            "EID", eid, "SID", sensorId, "RC", sendRecvMsgResult);
+            "EID", eid, "SID", sensorId, "RC", ec.message());
         return;
     }
 
@@ -93,8 +96,8 @@
     uint16_t reasonCode = 0;
     double tempValue = 0;
 
-    auto rc = gpu::decodeGetTemperatureReadingResponse(
-        getTemperatureReadingResponse, cc, reasonCode, tempValue);
+    auto rc = gpu::decodeGetTemperatureReadingResponse(buffer, cc, reasonCode,
+                                                       tempValue);
 
     if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
     {
@@ -122,6 +125,8 @@
     }
 
     mctpRequester.sendRecvMsg(
-        eid, getTemperatureReadingRequest, getTemperatureReadingResponse,
-        [this](int sendRecvMsgResult) { processResponse(sendRecvMsgResult); });
+        eid, getTemperatureReadingRequest,
+        [this](const std::error_code& ec, std::span<const uint8_t> buffer) {
+            processResponse(ec, buffer);
+        });
 }
diff --git a/src/nvidia-gpu/NvidiaGpuSensor.hpp b/src/nvidia-gpu/NvidiaGpuSensor.hpp
index 0e9b7af..2b0c49c 100644
--- a/src/nvidia-gpu/NvidiaGpuSensor.hpp
+++ b/src/nvidia-gpu/NvidiaGpuSensor.hpp
@@ -44,7 +44,8 @@
     void update();
 
   private:
-    void processResponse(int sendRecvMsgResult);
+    void processResponse(const std::error_code& ec,
+                         std::span<const uint8_t> buffer);
 
     uint8_t eid{};
 
@@ -58,7 +59,4 @@
 
     std::array<uint8_t, sizeof(gpu::GetTemperatureReadingRequest)>
         getTemperatureReadingRequest{};
-
-    std::array<uint8_t, sizeof(gpu::GetTemperatureReadingResponse)>
-        getTemperatureReadingResponse{};
 };
diff --git a/src/nvidia-gpu/NvidiaGpuSensorMain.cpp b/src/nvidia-gpu/NvidiaGpuSensorMain.cpp
index 7e0ab9d..9a1caf9 100644
--- a/src/nvidia-gpu/NvidiaGpuSensorMain.cpp
+++ b/src/nvidia-gpu/NvidiaGpuSensorMain.cpp
@@ -14,6 +14,7 @@
 #include <boost/asio/post.hpp>
 #include <boost/asio/steady_timer.hpp>
 #include <boost/container/flat_map.hpp>
+#include <phosphor-logging/lg2.hpp>
 #include <sdbusplus/asio/connection.hpp>
 #include <sdbusplus/asio/object_server.hpp>
 #include <sdbusplus/bus.hpp>
@@ -22,6 +23,8 @@
 
 #include <array>
 #include <chrono>
+#include <cstdlib>
+#include <exception>
 #include <functional>
 #include <memory>
 #include <string>
@@ -85,6 +88,16 @@
             interfaceRemoved(msg, gpuDevices, smaDevices);
         });
 
-    io.run();
+    try
+    {
+        io.run();
+    }
+    catch (const std::exception& e)
+    {
+        lg2::error("fatal error caught during processing: {MSG}", "MSG",
+                   e.what());
+        return EXIT_FAILURE;
+    }
+
     return 0;
 }
diff --git a/src/nvidia-gpu/NvidiaGpuThresholds.cpp b/src/nvidia-gpu/NvidiaGpuThresholds.cpp
index 16141f1..79a14b2 100644
--- a/src/nvidia-gpu/NvidiaGpuThresholds.cpp
+++ b/src/nvidia-gpu/NvidiaGpuThresholds.cpp
@@ -18,17 +18,18 @@
 #include <functional>
 #include <memory>
 #include <span>
+#include <system_error>
 #include <vector>
 
 void processReadThermalParameterResponse(
     const std::function<void(uint8_t, int32_t)>& callback,
-    const std::span<const uint8_t> respMsg, int sendRecvMsgResult)
+    const std::error_code& ec, std::span<const uint8_t> respMsg)
 {
-    if (sendRecvMsgResult != 0)
+    if (ec)
     {
         lg2::error(
             "Error reading thermal parameter: sending message over MCTP failed, rc={RC}",
-            "RC", sendRecvMsgResult);
+            "RC", ec.message());
         callback(EPROTO, 0);
         return;
     }
@@ -59,9 +60,6 @@
     auto reqMsg = std::make_shared<
         std::array<uint8_t, sizeof(gpu::ReadThermalParametersRequest)>>();
 
-    auto respMsg = std::make_shared<
-        std::array<uint8_t, sizeof(gpu::ReadThermalParametersResponse)>>();
-
     auto rc = gpu::encodeReadThermalParametersRequest(0, id, *reqMsg);
     if (rc != 0)
     {
@@ -73,10 +71,10 @@
     }
 
     mctpRequester.sendRecvMsg(
-        eid, *reqMsg, *respMsg,
-        [reqMsg, respMsg, callback](int sendRecvMsgResult) {
-            processReadThermalParameterResponse(callback, *respMsg,
-                                                sendRecvMsgResult);
+        eid, *reqMsg,
+        [reqMsg,
+         callback](const std::error_code& ec, std::span<const uint8_t> buff) {
+            processReadThermalParameterResponse(callback, ec, buff);
         });
 }
 
diff --git a/src/nvidia-gpu/NvidiaGpuThresholds.hpp b/src/nvidia-gpu/NvidiaGpuThresholds.hpp
index 9d1970f..4252c97 100644
--- a/src/nvidia-gpu/NvidiaGpuThresholds.hpp
+++ b/src/nvidia-gpu/NvidiaGpuThresholds.hpp
@@ -14,9 +14,9 @@
 
 using gpuThresholdId = uint8_t;
 
-constexpr gpuThresholdId gpuTLimitCriticalThresholdId{1};
-constexpr gpuThresholdId gpuTLimitWarnringThresholdId{2};
-constexpr gpuThresholdId gpuTLimitHardshutDownThresholdId{4};
+static constexpr gpuThresholdId gpuTLimitCriticalThresholdId{1};
+static constexpr gpuThresholdId gpuTLimitWarnringThresholdId{2};
+static constexpr gpuThresholdId gpuTLimitHardshutDownThresholdId{4};
 
 void readThermalParameters(
     uint8_t eid, const std::vector<gpuThresholdId>& ids,
diff --git a/src/nvidia-gpu/NvidiaGpuVoltageSensor.cpp b/src/nvidia-gpu/NvidiaGpuVoltageSensor.cpp
index 6fe71e6..d32f6b2 100644
--- a/src/nvidia-gpu/NvidiaGpuVoltageSensor.cpp
+++ b/src/nvidia-gpu/NvidiaGpuVoltageSensor.cpp
@@ -26,7 +26,9 @@
 #include <functional>
 #include <limits>
 #include <memory>
+#include <span>
 #include <string>
+#include <system_error>
 #include <utility>
 #include <vector>
 
@@ -80,13 +82,14 @@
     thresholds::checkThresholds(this);
 }
 
-void NvidiaGpuVoltageSensor::processResponse(int sendRecvMsgResult)
+void NvidiaGpuVoltageSensor::processResponse(const std::error_code& ec,
+                                             std::span<const uint8_t> buffer)
 {
-    if (sendRecvMsgResult != 0)
+    if (ec)
     {
         lg2::error(
             "Error updating Voltage Sensor: sending message over MCTP failed, rc={RC}",
-            "RC", sendRecvMsgResult);
+            "RC", ec.message());
         return;
     }
 
@@ -95,7 +98,7 @@
     uint32_t voltageValue = 0;
 
     auto rc =
-        gpu::decodeGetVoltageResponse(response, cc, reasonCode, voltageValue);
+        gpu::decodeGetVoltageResponse(buffer, cc, reasonCode, voltageValue);
 
     if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
     {
@@ -122,6 +125,8 @@
     }
 
     mctpRequester.sendRecvMsg(
-        eid, request, response,
-        [this](int sendRecvMsgResult) { processResponse(sendRecvMsgResult); });
+        eid, request,
+        [this](const std::error_code& ec, std::span<const uint8_t> buffer) {
+            processResponse(ec, buffer);
+        });
 }
diff --git a/src/nvidia-gpu/NvidiaGpuVoltageSensor.hpp b/src/nvidia-gpu/NvidiaGpuVoltageSensor.hpp
index a8c1038..e5e187a 100644
--- a/src/nvidia-gpu/NvidiaGpuVoltageSensor.hpp
+++ b/src/nvidia-gpu/NvidiaGpuVoltageSensor.hpp
@@ -17,7 +17,9 @@
 #include <array>
 #include <cstdint>
 #include <memory>
+#include <span>
 #include <string>
+#include <system_error>
 #include <vector>
 
 constexpr uint8_t gpuVoltageSensorId{0};
@@ -39,7 +41,8 @@
     void update();
 
   private:
-    void processResponse(int sendRecvMsgResult);
+    void processResponse(const std::error_code& ec,
+                         std::span<const uint8_t> buffer);
 
     uint8_t eid{};
 
@@ -52,6 +55,4 @@
     sdbusplus::asio::object_server& objectServer;
 
     std::array<uint8_t, sizeof(gpu::GetVoltageRequest)> request{};
-
-    std::array<uint8_t, sizeof(gpu::GetVoltageResponse)> response{};
 };