diff --git a/source/RobotAPI/libraries/armem/mns/ClientPlugin.cpp b/source/RobotAPI/libraries/armem/mns/ClientPlugin.cpp
index 6b318abf8ef693c9d306e2fa88167d06d244e612..c05e8db327456ab4db2126116ddf613f14f3ea2d 100644
--- a/source/RobotAPI/libraries/armem/mns/ClientPlugin.cpp
+++ b/source/RobotAPI/libraries/armem/mns/ClientPlugin.cpp
@@ -2,7 +2,7 @@
 
 #include <ArmarXCore/core/exceptions/local/ExpressionException.h>
 
-#include "../error.h"
+#include <RobotAPI/libraries/armem/core/error.h>
 
 
 
@@ -75,52 +75,68 @@ namespace armarx::armem::mns::plugins
 
     armem::data::WaitForMemoryResult ClientPluginUserBase::useMemory(const MemoryID& id)
     {
-        return useMemory(id.memoryName);
-    }
-
-    armem::data::WaitForMemoryResult ClientPluginUserBase::useMemory(const std::string& memoryName)
-    {
-        armem::data::WaitForMemoryInput input;
-        input.name = memoryName;
-
-        armem::data::WaitForMemoryResult result = memoryNameSystem.getMemoryNameSystem()->waitForMemory(input);
-        if (result.success)
+        armem::data::WaitForMemoryResult result;
+        try
         {
-            if (Component* comp = dynamic_cast<Component*>(this))
+            if (ManagedIceObject* comp = dynamic_cast<ManagedIceObject*>(this))
             {
                 // Add dependency.
-                comp->usingProxy(result.proxy->ice_getIdentity().name);
+                result.proxy = memoryNameSystem.useServer(id, *comp);
             }
+            else
+            {
+                result.proxy = memoryNameSystem.waitForServer(id);
+            }
+            result.success = true;
+        }
+        catch (const armem::error::CouldNotResolveMemoryServer& e)
+        {
+            result.success = false;
+            result.errorMessage = e.what();
         }
         return result;
     }
 
+    armem::data::WaitForMemoryResult ClientPluginUserBase::useMemory(const std::string& memoryName)
+    {
+        useMemory(MemoryID().withMemoryName(memoryName));
+    }
+
     armem::data::WaitForMemoryResult ClientPluginUserBase::waitForMemory(const std::string& memoryName)
     {
-        if (!memoryNameSystem)
+        armem::data::WaitForMemoryResult result;
+        try
+        {
+            result.proxy = memoryNameSystem.waitForServer(MemoryID().withMemoryName(memoryName));
+            result.success = true;
+        }
+        catch (const armem::error::CouldNotResolveMemoryServer& e)
         {
-            return {};
+            result.success = false;
+            result.errorMessage = e.what();
         }
-        armem::data::WaitForMemoryInput input;
-        input.name = memoryName;
-        return memoryNameSystem.getMemoryNameSystem()->waitForMemory(input);
+        return result;
     }
 
     armem::data::ResolveMemoryNameResult ClientPluginUserBase::resolveMemoryName(const std::string& memoryName)
     {
-        if (!memoryNameSystem)
+        armem::data::ResolveMemoryNameResult result;
+        try
+        {
+            result.proxy = memoryNameSystem.resolveServer(MemoryID().withMemoryName(memoryName));
+            result.success = true;
+        }
+        catch (const armem::error::CouldNotResolveMemoryServer& e)
         {
-            return {};
+            result.success = false;
+            result.errorMessage = e.what();
         }
-        armem::data::ResolveMemoryNameInput input;
-        input.name = memoryName;
-        return memoryNameSystem.getMemoryNameSystem()->resolveMemoryName(input);
+        return result;
     }
 
     bool ClientPluginUserBase::isMemoryAvailable(const std::string& memoryName)
     {
-        armem::data::ResolveMemoryNameResult result = resolveMemoryName(memoryName);
-        return result.success && result.proxy;
+        return memoryNameSystem.resolveServer(MemoryID().withMemoryName(memoryName));
     }
 
 }
diff --git a/source/RobotAPI/libraries/armem/mns/ClientPlugin.h b/source/RobotAPI/libraries/armem/mns/ClientPlugin.h
index 51249a2a3516cad13de49b626d5290ca13f98c4a..dd9b5abad3b821e98b53fdd86dd3b081663ea083 100644
--- a/source/RobotAPI/libraries/armem/mns/ClientPlugin.h
+++ b/source/RobotAPI/libraries/armem/mns/ClientPlugin.h
@@ -65,6 +65,8 @@ namespace armarx::armem::mns::plugins
 
         armem::data::WaitForMemoryResult waitForMemory(const std::string& memoryName);
         armem::data::ResolveMemoryNameResult resolveMemoryName(const std::string& memoryName);
+
+        [[deprecated("Use memoryNameSystem.resolveServer(MemoryID().withMemoryName(memoryName)) instead.")]]
         bool isMemoryAvailable(const std::string& memoryName);
 
         armem::data::WaitForMemoryResult useMemory(const MemoryID& id);
diff --git a/source/RobotAPI/libraries/armem/server/ComponentPlugin.cpp b/source/RobotAPI/libraries/armem/server/ComponentPlugin.cpp
index 536c72f49d6ccb4c656f37c345dc6a4ec70b4f17..8d4833508f560ec75ea536fc3412f7e72602139a 100644
--- a/source/RobotAPI/libraries/armem/server/ComponentPlugin.cpp
+++ b/source/RobotAPI/libraries/armem/server/ComponentPlugin.cpp
@@ -2,12 +2,13 @@
 
 #include <ArmarXCore/core/exceptions/local/ExpressionException.h>
 
-#include "../error.h"
+#include <RobotAPI/libraries/armem/core/error.h>
 
 #include "MemoryToIceAdapter.h"
 
 //#include <RobotAPI/libraries/armem/core/io/diskWriter/NlohmannJSON/NlohmannJSONDiskWriter.h>
 
+
 namespace armarx::armem::server::plugins
 {
     ComponentPlugin::~ComponentPlugin()
@@ -57,19 +58,22 @@ namespace armarx::armem::server::plugins
 
     data::RegisterMemoryResult ComponentPlugin::registerMemory(ComponentPluginUser& parent)
     {
-        data::RegisterMemoryInput input;
-        input.name = parent.workingMemory.name();
-        input.proxy = MemoryInterfacePrx::checkedCast(parent.getProxy());
-        ARMARX_CHECK_NOT_NULL(input.proxy);
-        data::RegisterMemoryResult result = parent.memoryNameSystem->registerMemory(input);
-        if (result.success)
+        MemoryID id = MemoryID().withMemoryName(parent.workingMemory.name());
+        MemoryInterfacePrx proxy = MemoryInterfacePrx::checkedCast(parent.getProxy());
+        ARMARX_CHECK_NOT_NULL(proxy);
+
+        data::RegisterMemoryResult result;
+        try
         {
-            ARMARX_DEBUG << "Registered memory '" << input.name << "' in the Memory Name System (MNS).";
+            parent.memoryNameSystem.registerServer(id, proxy);
+            result.success = true;
+            ARMARX_DEBUG << "Registered memory server for " << id << " in the Memory Name System (MNS).";
         }
-        else
+        catch (const armem::error::ServerRegistrationOrRemovalFailed& e)
         {
-            ARMARX_WARNING << "Failed to register this memory in the Memory Name System (MNS):"
-                           << "\n" << result.errorMessage;
+            result.success = false;
+            result.errorMessage = e.what();
+            ARMARX_WARNING << e.what();
         }
         return result;
     }
@@ -77,21 +81,20 @@ namespace armarx::armem::server::plugins
 
     data::RemoveMemoryResult ComponentPlugin::removeMemory(ComponentPluginUser& parent)
     {
+        MemoryID id = MemoryID().withMemoryName(parent.workingMemory.name());
+
         data::RemoveMemoryResult result;
         try
         {
-            data::RemoveMemoryInput input;
-            input.name = parent.workingMemory.name();
-            result = parent.memoryNameSystem->removeMemory(input);
-            if (result.success)
-            {
-                ARMARX_DEBUG << "Removed memory '" << input.name << "' from the Memory Name System (MNS).";
-            }
-            else
-            {
-                ARMARX_WARNING << "Failed to remove this memory in the Memory Name System (MNS):"
-                               << "\n" << result.errorMessage;
-            }
+            parent.memoryNameSystem.removeServer(id);
+            result.success = true;
+            ARMARX_DEBUG << "Removed memory server for " << id << " from the Memory Name System (MNS).";
+        }
+        catch (const armem::error::ServerRegistrationOrRemovalFailed& e)
+        {
+            result.success = false;
+            result.errorMessage = e.what();
+            ARMARX_WARNING << e.what();
         }
         catch (const Ice::NotRegisteredException&)
         {