diff --git a/src/agent/multitype_queue/include/imultitype_queue.hpp b/src/agent/multitype_queue/include/imultitype_queue.hpp
index f87fa5ecf8..5eb310aeaf 100644
--- a/src/agent/multitype_queue/include/imultitype_queue.hpp
+++ b/src/agent/multitype_queue/include/imultitype_queue.hpp
@@ -66,36 +66,44 @@ class IMultiTypeQueue
     /// @brief Deletes a message from the queue.
     /// @param type The type of the queue from which to pop the message.
     /// @param moduleName The name of the module requesting the pop.
+    /// @param moduleType The type of the module requesting the pop.
     /// @return true If the message was popped successfully.
     /// @return false If the message could not be popped.
-    virtual bool pop(MessageType type, const std::string moduleName = "") = 0;
+    virtual bool pop(MessageType type, const std::string moduleName = "", const std::string moduleType = "") = 0;
 
     /// @brief Deletes N messages from the queue.
     /// @param type The type of the queue from which to pop the messages.
     /// @param messageQuantity The quantity of messages to pop.
     /// @param moduleName The name of the module requesting the pop.
+    /// @param moduleType The type of the module requesting the pop.
     /// @return int The number of messages deleted.
-    virtual int popN(MessageType type, int messageQuantity, const std::string moduleName = "") = 0;
+    virtual int popN(MessageType type,
+                     int messageQuantity,
+                     const std::string moduleName = "",
+                     const std::string moduleType = "") = 0;
 
     /// @brief Checks if a queue is empty.
     /// @param type The type of the queue.
     /// @param moduleName The name of the module requesting the check.
+    /// @param moduleType The type of the module requesting the check.
     /// @return true If the queue is empty.
     /// @return false If the queue is not empty.
-    virtual bool isEmpty(MessageType type, const std::string moduleName = "") = 0;
+    virtual bool isEmpty(MessageType type, const std::string moduleName = "", const std::string moduleType = "") = 0;
 
     /// @brief Checks if a queue is full
     /// @param type The type of the queue.
     /// @param moduleName The name of the module requesting the check.
+    /// @param moduleType The type of the module requesting the check.
     /// @return true If the queue is full.
     /// @return false If the queue is not full.
-    virtual bool isFull(MessageType type, const std::string moduleName = "") = 0;
+    virtual bool isFull(MessageType type, const std::string moduleName = "", const std::string moduleType = "") = 0;
 
     /// @brief Returns the number of items stored in the queue.
     /// @param type The type of the queue.
     /// @param moduleName The name of the module requesting the count.
+    /// @param moduleType The type of the module requesting the count.
     /// @return int The number of items in the queue.
-    virtual int storedItems(MessageType type, const std::string moduleName = "") = 0;
+    virtual int storedItems(MessageType type, const std::string moduleName = "", const std::string moduleType = "") = 0;
 
     /// @brief Returns the size of the queue per type
     /// @param type The type of the queue.
diff --git a/src/agent/multitype_queue/include/multitype_queue.hpp b/src/agent/multitype_queue/include/multitype_queue.hpp
index feda44dfbc..bb65c9fb90 100644
--- a/src/agent/multitype_queue/include/multitype_queue.hpp
+++ b/src/agent/multitype_queue/include/multitype_queue.hpp
@@ -140,20 +140,23 @@ class MultiTypeQueue : public IMultiTypeQueue
                                       const std::string moduleName = "",
                                       const std::string moduleType = "") override;
 
-    /// @copydoc IMultiTypeQueue::pop(MessageType, const std::string)
-    bool pop(MessageType type, const std::string moduleName = "") override;
+    /// @copydoc IMultiTypeQueue::pop(MessageType, const std::string, const std::string)
+    bool pop(MessageType type, const std::string moduleName = "", const std::string moduleType = "") override;
 
-    /// @copydoc IMultiTypeQueue::popN(MessageType, int, const std::string)
-    int popN(MessageType type, int messageQuantity, const std::string moduleName = "") override;
+    /// @copydoc IMultiTypeQueue::popN(MessageType, int, const std::string, const std::string)
+    int popN(MessageType type,
+             int messageQuantity,
+             const std::string moduleName = "",
+             const std::string moduleType = "") override;
 
-    /// @copydoc IMultiTypeQueue::isEmpty(MessageType, const std::string)
-    bool isEmpty(MessageType type, const std::string moduleName = "") override;
+    /// @copydoc IMultiTypeQueue::isEmpty(MessageType, const std::string, const std::string)
+    bool isEmpty(MessageType type, const std::string moduleName = "", const std::string moduleType = "") override;
 
-    /// @copydoc IMultiTypeQueue::isFull(MessageType, const std::string)
-    bool isFull(MessageType type, const std::string moduleName = "") override;
+    /// @copydoc IMultiTypeQueue::isFull(MessageType, const std::string, const std::string)
+    bool isFull(MessageType type, const std::string moduleName = "", const std::string moduleType = "") override;
 
-    /// @copydoc IMultiTypeQueue::storedItems(MessageType, const std::string)
-    int storedItems(MessageType type, const std::string moduleName = "") override;
+    /// @copydoc IMultiTypeQueue::storedItems(MessageType, const std::string, const std::string)
+    int storedItems(MessageType type, const std::string moduleName = "", const std::string moduleType = "") override;
 
     /// @copydoc IMultiTypeQueue::sizePerType(MessageType type)
     size_t sizePerType(MessageType type) override;
diff --git a/src/agent/multitype_queue/src/multitype_queue.cpp b/src/agent/multitype_queue/src/multitype_queue.cpp
index 77e21cc8ce..c398eaa391 100644
--- a/src/agent/multitype_queue/src/multitype_queue.cpp
+++ b/src/agent/multitype_queue/src/multitype_queue.cpp
@@ -202,12 +202,12 @@ std::vector<Message> MultiTypeQueue::getNextBytes(MessageType type,
     return result;
 }
 
-bool MultiTypeQueue::pop(MessageType type, const std::string moduleName)
+bool MultiTypeQueue::pop(MessageType type, const std::string moduleName, const std::string moduleType)
 {
     bool result = false;
     if (m_mapMessageTypeName.contains(type))
     {
-        result = m_persistenceDest->RemoveMultiple(1, m_mapMessageTypeName.at(type), moduleName);
+        result = m_persistenceDest->RemoveMultiple(1, m_mapMessageTypeName.at(type), moduleName, moduleType);
     }
     else
     {
@@ -216,12 +216,16 @@ bool MultiTypeQueue::pop(MessageType type, const std::string moduleName)
     return result;
 }
 
-int MultiTypeQueue::popN(MessageType type, int messageQuantity, const std::string moduleName)
+int MultiTypeQueue::popN(MessageType type,
+                         int messageQuantity,
+                         const std::string moduleName,
+                         const std::string moduleType)
 {
     int result = 0;
     if (m_mapMessageTypeName.contains(type))
     {
-        result = m_persistenceDest->RemoveMultiple(messageQuantity, m_mapMessageTypeName.at(type), moduleName);
+        result =
+            m_persistenceDest->RemoveMultiple(messageQuantity, m_mapMessageTypeName.at(type), moduleName, moduleType);
     }
     else
     {
@@ -230,11 +234,11 @@ int MultiTypeQueue::popN(MessageType type, int messageQuantity, const std::strin
     return result;
 }
 
-bool MultiTypeQueue::isEmpty(MessageType type, const std::string moduleName)
+bool MultiTypeQueue::isEmpty(MessageType type, const std::string moduleName, const std::string moduleType)
 {
     if (m_mapMessageTypeName.contains(type))
     {
-        return m_persistenceDest->GetElementCount(m_mapMessageTypeName.at(type), moduleName) == 0;
+        return m_persistenceDest->GetElementCount(m_mapMessageTypeName.at(type), moduleName, moduleType) == 0;
     }
     else
     {
@@ -243,12 +247,12 @@ bool MultiTypeQueue::isEmpty(MessageType type, const std::string moduleName)
     return false;
 }
 
-bool MultiTypeQueue::isFull(MessageType type, const std::string moduleName)
+bool MultiTypeQueue::isFull(MessageType type, const std::string moduleName, const std::string moduleType)
 {
     if (m_mapMessageTypeName.contains(type))
     {
-        return static_cast<size_t>(m_persistenceDest->GetElementCount(m_mapMessageTypeName.at(type), moduleName)) ==
-               m_maxItems;
+        return static_cast<size_t>(m_persistenceDest->GetElementCount(
+                   m_mapMessageTypeName.at(type), moduleName, moduleType)) == m_maxItems;
     }
     else
     {
@@ -257,11 +261,11 @@ bool MultiTypeQueue::isFull(MessageType type, const std::string moduleName)
     return false;
 }
 
-int MultiTypeQueue::storedItems(MessageType type, const std::string moduleName)
+int MultiTypeQueue::storedItems(MessageType type, const std::string moduleName, const std::string moduleType)
 {
     if (m_mapMessageTypeName.contains(type))
     {
-        return m_persistenceDest->GetElementCount(m_mapMessageTypeName.at(type), moduleName);
+        return m_persistenceDest->GetElementCount(m_mapMessageTypeName.at(type), moduleName, moduleType);
     }
     else
     {
diff --git a/src/agent/tests/message_queue_utils_test.cpp b/src/agent/tests/message_queue_utils_test.cpp
index 680a7c1ba1..69a06379c0 100644
--- a/src/agent/tests/message_queue_utils_test.cpp
+++ b/src/agent/tests/message_queue_utils_test.cpp
@@ -29,10 +29,10 @@ class MockMultiTypeQueue : public MultiTypeQueue
                 getNextBytesAwaitable,
                 (MessageType, const size_t, const std::string, const std::string),
                 (override));
-    MOCK_METHOD(int, popN, (MessageType, int, const std::string), (override));
+    MOCK_METHOD(int, popN, (MessageType, int, const std::string, const std::string), (override));
     MOCK_METHOD(int, push, (Message, bool), (override));
     MOCK_METHOD(int, push, (std::vector<Message>), (override));
-    MOCK_METHOD(bool, isEmpty, (MessageType, const std::string), (override));
+    MOCK_METHOD(bool, isEmpty, (MessageType, const std::string, const std::string), (override));
     MOCK_METHOD(Message, getNext, (MessageType, const std::string, const std::string), (override));
 };
 
@@ -157,7 +157,7 @@ TEST_F(MessageQueueUtilsTest, GetEmptyMessagesFromQueueTest)
 
 TEST_F(MessageQueueUtilsTest, PopMessagesFromQueueTest)
 {
-    EXPECT_CALL(*mockQueue, popN(MessageType::STATEFUL, 1, "")).Times(1);
+    EXPECT_CALL(*mockQueue, popN(MessageType::STATEFUL, 1, "", "")).Times(1);
     PopMessagesFromQueue(mockQueue, MessageType::STATEFUL, 1);
 }
 
@@ -189,7 +189,7 @@ TEST_F(MessageQueueUtilsTest, NoCommandsToPushTest)
 
 TEST_F(MessageQueueUtilsTest, GetCommandFromQueueEmptyTest)
 {
-    EXPECT_CALL(*mockQueue, isEmpty(MessageType::COMMAND, "")).WillOnce(testing::Return(true));
+    EXPECT_CALL(*mockQueue, isEmpty(MessageType::COMMAND, "", "")).WillOnce(testing::Return(true));
 
     ASSERT_EQ(std::nullopt, GetCommandFromQueue(mockQueue));
 }
@@ -198,7 +198,7 @@ TEST_F(MessageQueueUtilsTest, GetCommandFromQueueTest)
 {
     Message testMessage {MessageType::COMMAND, BASE_DATA_CONTENT};
 
-    EXPECT_CALL(*mockQueue, isEmpty(MessageType::COMMAND, "")).WillOnce(testing::Return(false));
+    EXPECT_CALL(*mockQueue, isEmpty(MessageType::COMMAND, "", "")).WillOnce(testing::Return(false));
 
     EXPECT_CALL(*mockQueue, getNext(MessageType::COMMAND, "", "")).WillOnce(testing::Return(testMessage));