diff --git a/source/RobotAPI/libraries/armem/client/Writer.cpp b/source/RobotAPI/libraries/armem/client/Writer.cpp
index e9b06f66e1e297296a2f47c39cdf6474c0015795..727c1ff1941fa92001c3946e1b3b8b290166a174 100644
--- a/source/RobotAPI/libraries/armem/client/Writer.cpp
+++ b/source/RobotAPI/libraries/armem/client/Writer.cpp
@@ -5,7 +5,6 @@
 
 #include "../error.h"
 
-
 namespace armarx::armem::client
 {
 
@@ -13,7 +12,10 @@ namespace armarx::armem::client
     {
     }
 
-    data::AddSegmentResult Writer::addSegment(const std::string& coreSegmentName, const std::string& providerSegmentName, bool clearWhenExists)
+    data::AddSegmentResult
+    Writer::addSegment(const std::string& coreSegmentName,
+                       const std::string& providerSegmentName,
+                       bool clearWhenExists) const
     {
         data::AddSegmentInput input;
         input.coreSegmentName = coreSegmentName;
@@ -22,24 +24,30 @@ namespace armarx::armem::client
         return addSegment(input);
     }
 
-    data::AddSegmentResult Writer::addSegment(const MemoryID& providerSegmentID, bool clearWhenExists)
+    data::AddSegmentResult
+    Writer::addSegment(const MemoryID& providerSegmentID, bool clearWhenExists) const
     {
-        return addSegment(providerSegmentID.coreSegmentName, providerSegmentID.providerSegmentName, clearWhenExists);
+        return addSegment(providerSegmentID.coreSegmentName,
+                          providerSegmentID.providerSegmentName,
+                          clearWhenExists);
     }
 
-    data::AddSegmentResult Writer::addSegment(const std::pair<std::string, std::string>& names, bool clearWhenExists)
+    data::AddSegmentResult
+    Writer::addSegment(const std::pair<std::string, std::string>& names, bool clearWhenExists) const
     {
         return addSegment(names.first, names.second, clearWhenExists);
     }
 
-    data::AddSegmentResult Writer::addSegment(const data::AddSegmentInput& input)
+    data::AddSegmentResult
+    Writer::addSegment(const data::AddSegmentInput& input) const
     {
         data::AddSegmentsResult results = addSegments({input});
         ARMARX_CHECK_EQUAL(results.size(), 1);
         return results.at(0);
     }
 
-    data::AddSegmentsResult Writer::addSegments(const data::AddSegmentsInput& inputs)
+    data::AddSegmentsResult
+    Writer::addSegments(const data::AddSegmentsInput& inputs) const
     {
         ARMARX_CHECK_NOT_NULL(memory);
         data::AddSegmentsResult results = memory->addSegments(inputs);
@@ -47,8 +55,8 @@ namespace armarx::armem::client
         return results;
     }
 
-
-    CommitResult Writer::commit(const Commit& commit)
+    CommitResult
+    Writer::commit(const Commit& commit) const
     {
         ARMARX_CHECK_NOT_NULL(memory);
 
@@ -63,15 +71,15 @@ namespace armarx::armem::client
         return result;
     }
 
-
-    data::CommitResult Writer::commit(const data::Commit& _commit)
+    data::CommitResult
+    Writer::commit(const data::Commit& _commit) const
     {
         data::Commit commit = _commit;
         return this->_commit(commit);
     }
 
-
-    EntityUpdateResult Writer::commit(const EntityUpdate& update)
+    EntityUpdateResult
+    Writer::commit(const EntityUpdate& update) const
     {
         armem::Commit commit;
         commit.updates.push_back(update);
@@ -81,10 +89,10 @@ namespace armarx::armem::client
         return result.results.at(0);
     }
 
-    EntityUpdateResult Writer::commit(
-        const MemoryID& entityID,
-        const std::vector<aron::data::DictPtr>& instancesData,
-        Time referencedTime)
+    EntityUpdateResult
+    Writer::commit(const MemoryID& entityID,
+                   const std::vector<aron::data::DictPtr>& instancesData,
+                   Time referencedTime) const
     {
         EntityUpdate update;
         update.entityID = entityID;
@@ -99,7 +107,8 @@ namespace armarx::armem::client
         this->memory = memory;
     }
 
-    data::CommitResult Writer::_commit(data::Commit& commit)
+    data::CommitResult
+    Writer::_commit(data::Commit& commit) const
     {
         ARMARX_CHECK_NOT_NULL(memory);
 
@@ -119,11 +128,11 @@ namespace armarx::armem::client
         }
 
         data::CommitResult result;
-        auto handleError = [&commit, &result](const std::string & what)
+        auto handleError = [&commit, &result](const std::string& what)
         {
             for (const auto& _ : commit.updates)
             {
-                (void) _;
+                (void)_;
                 data::EntityUpdateResult& r = result.results.emplace_back();
                 r.success = false;
                 r.errorMessage = "Memory component not registered.\n" + std::string(what);
@@ -149,18 +158,20 @@ namespace armarx::armem::client
 
         return result;
     }
-}
+} // namespace armarx::armem::client
 
-
-std::ostream& armarx::armem::data::operator<<(std::ostream& os, const AddSegmentInput& rhs)
+std::ostream&
+armarx::armem::data::operator<<(std::ostream& os, const AddSegmentInput& rhs)
 {
     return os << "AddSegmentInput: "
-           << "\n- core segment:     \t'" << rhs.coreSegmentName << "'"
-           << "\n- provider segment: \t'" << rhs.providerSegmentName << "'"
-           << "\n- clear when exists:\t"  << rhs.clearWhenExists << ""
-           << "\n";
+              << "\n- core segment:     \t'" << rhs.coreSegmentName << "'"
+              << "\n- provider segment: \t'" << rhs.providerSegmentName << "'"
+              << "\n- clear when exists:\t" << rhs.clearWhenExists << ""
+              << "\n";
 }
-std::ostream& armarx::armem::data::operator<<(std::ostream& os, const AddSegmentsInput& rhs)
+
+std::ostream&
+armarx::armem::data::operator<<(std::ostream& os, const AddSegmentsInput& rhs)
 {
     for (size_t i = 0; i < rhs.size(); ++i)
     {
@@ -168,15 +179,18 @@ std::ostream& armarx::armem::data::operator<<(std::ostream& os, const AddSegment
     }
     return os;
 }
-std::ostream& armarx::armem::data::operator<<(std::ostream& os, const AddSegmentResult& rhs)
+
+std::ostream&
+armarx::armem::data::operator<<(std::ostream& os, const AddSegmentResult& rhs)
 {
     return os << "AddSegmentResult:"
-           << "\n- success:       \t" << rhs.success
-           << "\n- segment ID:    \t'" << rhs.segmentID << "'"
-           << "\n- error message: \t"  << rhs.errorMessage
-           << "\n";
+              << "\n- success:       \t" << rhs.success << "\n- segment ID:    \t'" << rhs.segmentID
+              << "'"
+              << "\n- error message: \t" << rhs.errorMessage << "\n";
 }
-std::ostream& armarx::armem::data::operator<<(std::ostream& os, const AddSegmentsResult& rhs)
+
+std::ostream&
+armarx::armem::data::operator<<(std::ostream& os, const AddSegmentsResult& rhs)
 {
     for (size_t i = 0; i < rhs.size(); ++i)
     {
diff --git a/source/RobotAPI/libraries/armem/client/Writer.h b/source/RobotAPI/libraries/armem/client/Writer.h
index 61eeef93be3164d79d09f6c5aa3371cb362b58b2..65d405a3736e62e39971e08928bd098c0e469636 100644
--- a/source/RobotAPI/libraries/armem/client/Writer.h
+++ b/source/RobotAPI/libraries/armem/client/Writer.h
@@ -32,28 +32,28 @@ namespace armarx::armem::client
 
         data::AddSegmentResult addSegment(const std::string& coreSegmentName,
                                           const std::string& providerSegmentName,
-                                          bool clearWhenExists = false);
+                                          bool clearWhenExists = false) const;
         data::AddSegmentResult addSegment(const MemoryID& providerSegmentID,
-                                          bool clearWhenExists = false);
+                                          bool clearWhenExists = false) const;
         data::AddSegmentResult addSegment(const std::pair<std::string, std::string>& names,
-                                          bool clearWhenExists = false);
-        data::AddSegmentResult addSegment(const data::AddSegmentInput& input);
-        data::AddSegmentsResult addSegments(const data::AddSegmentsInput& input);
+                                          bool clearWhenExists = false) const;
+        data::AddSegmentResult addSegment(const data::AddSegmentInput& input) const;
+        data::AddSegmentsResult addSegments(const data::AddSegmentsInput& input) const;
 
 
         /**
          * @brief Writes a `Commit` to the memory.
          */
-        CommitResult commit(const Commit& commit);
+        CommitResult commit(const Commit& commit) const;
         /// Commit a single entity update.
-        EntityUpdateResult commit(const EntityUpdate& update);
+        EntityUpdateResult commit(const EntityUpdate& update) const;
         /// Commit a single entity update.
         EntityUpdateResult commit(const MemoryID& entityID,
                                   const std::vector<aron::data::DictPtr>& instancesData,
-                                  Time referencedTime);
+                                  Time referencedTime) const;
 
         // with bare-ice types
-        data::CommitResult commit(const data::Commit& commit);
+        data::CommitResult commit(const data::Commit& commit) const;
 
 
         void setWritingMemory(server::WritingMemoryInterfacePrx memory);
@@ -65,7 +65,7 @@ namespace armarx::armem::client
 
     private:
         /// Sets `timeSent` on all entity updates and performs the commit,
-        data::CommitResult _commit(data::Commit& commit);
+        data::CommitResult _commit(data::Commit& commit) const;
 
 
     public:
diff --git a/source/RobotAPI/libraries/armem_objects/client/articulated_object/ArticulatedObjectReader.h b/source/RobotAPI/libraries/armem_objects/client/articulated_object/ArticulatedObjectReader.h
index ab0c5aa6d30a0bc0b377981c22f65d0d3b8c3ade..4bdcaac5bde3e0920c8e59f72cc06abd49875d55 100644
--- a/source/RobotAPI/libraries/armem_objects/client/articulated_object/ArticulatedObjectReader.h
+++ b/source/RobotAPI/libraries/armem_objects/client/articulated_object/ArticulatedObjectReader.h
@@ -15,8 +15,9 @@ namespace armarx::armem::articulated_object
                                                     const std::optional<std::string>& providerName,
                                                     const std::string& instanceName = "");
 
-        bool synchronizeArticulatedObject(VirtualRobot::Robot& object,
-                                          const armem::Time& timestamp,
-                                          const std::optional<std::string>& providerName);
+        [[nodiscard]] bool
+        synchronizeArticulatedObject(VirtualRobot::Robot& object,
+                                     const armem::Time& timestamp,
+                                     const std::optional<std::string>& providerName);
     };
 } // namespace armarx::armem::articulated_object
diff --git a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.cpp b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.cpp
index 16c83498cd59f65418d00f649031b750d4d44969..f21151f1982a28f852bc2b79215709cb0520e4f1 100644
--- a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.cpp
+++ b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.cpp
@@ -26,7 +26,6 @@
 
 #include "utils.h"
 
-namespace fs = ::std::filesystem;
 
 namespace armarx::armem::articulated_object
 {
@@ -100,7 +99,7 @@ namespace armarx::armem::articulated_object
     std::optional<ArticulatedObject>
     Reader::get(const std::string& name,
                 const armem::Time& timestamp,
-                const std::optional<std::string>& providerName)
+                const std::optional<std::string>& providerName) const
     {
         ARMARX_TRACE;
 
@@ -125,7 +124,7 @@ namespace armarx::armem::articulated_object
     Reader::get(const ArticulatedObjectDescription& description,
                 const armem::Time& timestamp,
                 const std::string& instanceName,
-                const std::optional<std::string>& providerName)
+                const std::optional<std::string>& providerName) const
     {
         ARMARX_TRACE;
 
@@ -142,7 +141,7 @@ namespace armarx::armem::articulated_object
     bool
     Reader::synchronize(ArticulatedObject& obj,
                         const armem::Time& timestamp,
-                        const std::optional<std::string>& providerName)
+                        const std::optional<std::string>& providerName) const
     {
         ARMARX_TRACE;
 
@@ -164,7 +163,7 @@ namespace armarx::armem::articulated_object
 
     std::vector<robot::RobotDescription>
     Reader::queryDescriptions(const armem::Time& timestamp,
-                              const std::optional<std::string>& providerName)
+                              const std::optional<std::string>& providerName) const
     {
         ARMARX_TRACE;
         // Query all entities from provider.
@@ -209,7 +208,7 @@ namespace armarx::armem::articulated_object
     std::optional<robot::RobotDescription>
     Reader::queryDescription(const std::string& name,
                              const armem::Time& timestamp,
-                             const std::optional<std::string>& providerName)
+                             const std::optional<std::string>& providerName) const
     {
         ARMARX_TRACE;
 
@@ -256,7 +255,7 @@ namespace armarx::armem::articulated_object
     std::optional<robot::RobotState>
     Reader::queryState(const std::string& instanceName,
                        const armem::Time& timestamp,
-                       const std::optional<std::string>& providerName)
+                       const std::optional<std::string>& providerName) const
     {
         ARMARX_TRACE;
 
diff --git a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.h b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.h
index 0eb5bd104f4de49f3b7dfa6cc14ce232a99933fc..50c342c0cfc87614505df230ecdc3fce9cd8b43b 100644
--- a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.h
+++ b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Reader.h
@@ -26,13 +26,17 @@
 
 #include <VirtualRobot/VirtualRobot.h>
 
-#include <ArmarXCore/core/application/properties/PropertyDefinitionContainer.h>
+#include "ArmarXCore/core/application/properties/forward_declarations.h"
 
-#include <RobotAPI/libraries/armem/client/MemoryNameSystem.h>
 #include <RobotAPI/libraries/armem/client/Reader.h>
+#include <RobotAPI/libraries/armem/client/forward_declarations.h>
 
 #include "interfaces.h"
 
+// #include <ArmarXCore/core/application/properties/PropertyDefinitionContainer.h>
+// #include <RobotAPI/libraries/armem/client/MemoryNameSystem.h>
+
+
 namespace armarx::armem::articulated_object
 {
 
@@ -40,7 +44,7 @@ namespace armarx::armem::articulated_object
     {
     public:
         Reader() = default;
-        virtual ~Reader() = default;
+        ~Reader() override = default;
 
         void
         registerPropertyDefinitions(armarx::PropertyDefinitionsPtr& def)
@@ -49,30 +53,30 @@ namespace armarx::armem::articulated_object
 
         void connect(armem::client::MemoryNameSystem& memoryNameSystem);
 
-        bool synchronize(ArticulatedObject& obj,
+        [[nodiscard]] bool synchronize(ArticulatedObject& obj,
                          const armem::Time& timestamp,
-                         const std::optional<std::string>& providerName) override;
+                         const std::optional<std::string>& providerName) const override;
 
         std::optional<ArticulatedObject>
         get(const std::string& name,
             const armem::Time& timestamp,
-            const std::optional<std::string>& providerName) override;
+            const std::optional<std::string>& providerName) const override;
         ArticulatedObject get(const ArticulatedObjectDescription& description,
                               const armem::Time& timestamp,
                               const std::string& instanceName,
-                              const std::optional<std::string>& providerName) override;
+                              const std::optional<std::string>& providerName) const override;
 
         std::optional<robot::RobotState> queryState(const std::string& instanceName,
                                                     const armem::Time& timestamp,
-                                                    const std::optional<std::string>& providerName);
+                                                    const std::optional<std::string>& providerName) const;
         std::optional<robot::RobotDescription>
         queryDescription(const std::string& name,
                          const armem::Time& timestamp,
-                         const std::optional<std::string>& providerName);
+                         const std::optional<std::string>& providerName) const;
 
         std::vector<robot::RobotDescription>
         queryDescriptions(const armem::Time& timestamp,
-                          const std::optional<std::string>& providerName);
+                          const std::optional<std::string>& providerName) const;
 
         std::string getProviderName() const;
         void setProviderName(const std::string& providerName);
diff --git a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.cpp b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.cpp
index c507fd90594bb6b300080f737d6263a5025417dc..4df7921025ba582a4a913a0fa88906959137b3bb 100644
--- a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.cpp
+++ b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.cpp
@@ -103,7 +103,7 @@ namespace armarx::armem::articulated_object
     }
 
     std::optional<armem::MemoryID>
-    Writer::storeOrGetClass(const ArticulatedObject& obj)
+    Writer::storeOrGetClass(const ArticulatedObject& obj) const
     {
         ARMARX_TRACE;
 
@@ -129,7 +129,7 @@ namespace armarx::armem::articulated_object
     }
 
     std::optional<armem::MemoryID>
-    Writer::storeClass(const ArticulatedObject& obj)
+    Writer::storeClass(const ArticulatedObject& obj) const
     {
         std::lock_guard g{memoryWriterMutex};
 
@@ -190,7 +190,7 @@ namespace armarx::armem::articulated_object
     }
 
     bool
-    Writer::storeInstance(const ArticulatedObject& obj)
+    Writer::storeInstance(const ArticulatedObject& obj) const
     {
         std::lock_guard g{memoryWriterMutex};
 
@@ -259,7 +259,7 @@ namespace armarx::armem::articulated_object
     }
 
     bool
-    Writer::store(const ArticulatedObject& obj)
+    Writer::store(const ArticulatedObject& obj) const
     {
         const std::optional<armem::MemoryID> classId = storeOrGetClass(obj);
 
diff --git a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.h b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.h
index 6245ef374edc289afa452900ee97e769ed4eae8b..bf1c7d9459654c422f27c26b8cab9c9e6ae9b20f 100644
--- a/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.h
+++ b/source/RobotAPI/libraries/armem_objects/client/articulated_object/Writer.h
@@ -39,16 +39,16 @@ namespace armarx::armem::articulated_object
     {
     public:
         Writer() = default;
-        virtual ~Writer() = default;
+        ~Writer() override = default;
 
         void registerPropertyDefinitions(armarx::PropertyDefinitionsPtr& def);
         void connect(armem::client::MemoryNameSystem& memoryNameSystem);
 
 
-        bool store(const ArticulatedObject& obj) override;
+        bool store(const ArticulatedObject& obj) const override;
 
-        bool storeInstance(const ArticulatedObject& obj);
-        std::optional<armem::MemoryID> storeClass(const ArticulatedObject& obj);
+        bool storeInstance(const ArticulatedObject& obj) const;
+        std::optional<armem::MemoryID> storeClass(const ArticulatedObject& obj) const;
 
         // const std::string& getPropertyPrefix() const override;
 
@@ -57,7 +57,7 @@ namespace armarx::armem::articulated_object
 
 
     private:
-        std::optional<armem::MemoryID> storeOrGetClass(const ArticulatedObject& obj);
+        std::optional<armem::MemoryID> storeOrGetClass(const ArticulatedObject& obj) const;
 
         void updateKnownObjects(const armem::MemoryID& subscriptionID,
                                 const std::vector<armem::MemoryID>& snapshotIDs);
@@ -85,13 +85,13 @@ namespace armarx::armem::articulated_object
         const std::string propertyPrefix = "mem.obj.articulated.";
 
         armem::client::Writer memoryWriter;
-        std::mutex memoryWriterMutex;
+        mutable std::mutex memoryWriterMutex;
 
         armem::client::Reader memoryReader;
-        std::mutex memoryReaderMutex;
+        mutable std::mutex memoryReaderMutex;
 
         // key: name of object: RobotDescription::name
-        std::unordered_map<std::string, MemoryID> knownObjects;
+        mutable std::unordered_map<std::string, MemoryID> knownObjects;
     };
 
 
diff --git a/source/RobotAPI/libraries/armem_objects/client/articulated_object/interfaces.h b/source/RobotAPI/libraries/armem_objects/client/articulated_object/interfaces.h
index 6031eba4bfd1288d6567b946a0dd359018482792..899cb1e79ac7ada7991e064b2a1ae1c20310749a 100644
--- a/source/RobotAPI/libraries/armem_objects/client/articulated_object/interfaces.h
+++ b/source/RobotAPI/libraries/armem_objects/client/articulated_object/interfaces.h
@@ -11,19 +11,26 @@ namespace armarx::armem::articulated_object
     public:
         virtual ~ReaderInterface() = default;
 
-        virtual bool synchronize(ArticulatedObject& obj, const armem::Time& timestamp, const std::optional<std::string>& providerName) = 0;
-
-        virtual ArticulatedObject get(const ArticulatedObjectDescription& description, const armem::Time& timestamp, const std::string& instanceName, const std::optional<std::string>& providerName) = 0;
-        virtual std::optional<ArticulatedObject> get(const std::string& name, const armem::Time& timestamp, const std::optional<std::string>& providerName) = 0;
+        virtual bool synchronize(ArticulatedObject& obj,
+                                 const armem::Time& timestamp,
+                                 const std::optional<std::string>& providerName) const = 0;
+
+        virtual ArticulatedObject get(const ArticulatedObjectDescription& description,
+                                      const armem::Time& timestamp,
+                                      const std::string& instanceName,
+                                      const std::optional<std::string>& providerName) const = 0;
+        virtual std::optional<ArticulatedObject>
+        get(const std::string& name,
+            const armem::Time& timestamp,
+            const std::optional<std::string>& providerName) const = 0;
     };
 
-
     class WriterInterface
     {
     public:
         virtual ~WriterInterface() = default;
 
-        virtual bool store(const ArticulatedObject& obj) = 0;
+        virtual bool store(const ArticulatedObject& obj) const = 0;
     };
 
-}  // namespace armarx::armem::articulated_object
+} // namespace armarx::armem::articulated_object