diff --git a/src/nvidia-gpu/MctpRequester.hpp b/src/nvidia-gpu/MctpRequester.hpp
index 289e800..5b5a270 100644
--- a/src/nvidia-gpu/MctpRequester.hpp
+++ b/src/nvidia-gpu/MctpRequester.hpp
@@ -14,24 +14,28 @@
 #include <cstddef>
 #include <cstdint>
 #include <functional>
+#include <memory>
+#include <queue>
 #include <span>
+#include <unordered_map>
+#include <utility>
 
 namespace mctp
 {
-class MctpRequester
+class Requester
 {
   public:
-    MctpRequester() = delete;
+    Requester() = delete;
 
-    MctpRequester(const MctpRequester&) = delete;
+    Requester(const Requester&) = delete;
 
-    MctpRequester(MctpRequester&&) = delete;
+    Requester(Requester&&) = delete;
 
-    MctpRequester& operator=(const MctpRequester&) = delete;
+    Requester& operator=(const Requester&) = delete;
 
-    MctpRequester& operator=(MctpRequester&&) = delete;
+    Requester& operator=(Requester&&) = delete;
 
-    explicit MctpRequester(boost::asio::io_context& ctx);
+    explicit Requester(boost::asio::io_context& ctx);
 
     void sendRecvMsg(uint8_t eid, std::span<const uint8_t> reqMsg,
                      std::span<uint8_t> respMsg,
@@ -57,8 +61,56 @@
 
     boost::asio::steady_timer expiryTimer;
 
-    std::move_only_function<void(int)> completionCallback;
+    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;
+
+        RequestContext(const RequestContext&) = delete;
+        RequestContext& operator=(const RequestContext&) = delete;
+
+        RequestContext(RequestContext&&) = default;
+        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))
+        {}
+    };
+
+    void processQueue(uint8_t eid);
+
+    Requester requester;
+    std::unordered_map<uint8_t, std::queue<std::unique_ptr<RequestContext>>>
+        requestContextQueues;
+    std::unordered_map<uint8_t, std::unique_ptr<RequestContext>>
+        activeRequestContexts;
+};
+
+using MctpRequester = QueuingRequester;
 } // namespace mctp