diff --git a/source/RobotAPI/libraries/armem_robot_state/client/common/VirtualRobotReader.cpp b/source/RobotAPI/libraries/armem_robot_state/client/common/VirtualRobotReader.cpp
index 197ab804eb3d99095ea4b9cabf4f860c6327956f..76fa10a4c0186acecdb969ec69af75d97975708f 100644
--- a/source/RobotAPI/libraries/armem_robot_state/client/common/VirtualRobotReader.cpp
+++ b/source/RobotAPI/libraries/armem_robot_state/client/common/VirtualRobotReader.cpp
@@ -17,36 +17,32 @@ namespace armarx::armem::robot_state
 {
 
     VirtualRobotReader::VirtualRobotReader(armem::client::MemoryNameSystem& memoryNameSystem) :
-        RobotReader(memoryNameSystem)
+            RobotReader(memoryNameSystem)
     {
     }
 
-    void
-    VirtualRobotReader::connect()
+    void VirtualRobotReader::connect()
     {
         RobotReader::connect();
     }
 
     // TODO(fabian.reister): register property defs
-    void
-    VirtualRobotReader::registerPropertyDefinitions(::armarx::PropertyDefinitionsPtr& def)
+    void VirtualRobotReader::registerPropertyDefinitions(::armarx::PropertyDefinitionsPtr& def)
     {
         RobotReader::registerPropertyDefinitions(def);
     }
 
-    bool
-    VirtualRobotReader::synchronizeRobot(VirtualRobot::Robot& robot, const armem::Time& timestamp)
+    bool VirtualRobotReader::synchronizeRobot(VirtualRobot::Robot& robot, const armem::Time& timestamp)
     {
         // const static auto packages = armarx::CMakePackageFinder::FindAllArmarXSourcePackages();
         // const auto package = armarx::ArmarXDataPath::getProject(packages, robot.getFilename());
 
-        const robot::RobotDescription robotDescription{.name = robot.getName(),
-                                                       .xml = PackagePath{"", ""}};
+        const robot::RobotDescription robotDescription{.name = robot.getName(), .xml = PackagePath{"", ""}};
 
         const auto robotState = queryState(robotDescription, timestamp);
         if (not robotState)
         {
-            ARMARX_VERBOSE << "Querying robot state failed for robot `" << robot.getName() << "` "
+            ARMARX_VERBOSE << deactivateSpam(5) << "Querying robot state failed for robot `" << robot.getName() << "` "
                            << "(type `" << robot.getType() << "`)!";
             return false;
         }
@@ -57,18 +53,15 @@ namespace armarx::armem::robot_state
         return true;
     }
 
-    VirtualRobot::RobotPtr
-    VirtualRobotReader::getRobot(const std::string& name,
-                                 const armem::Time& timestamp,
-                                 const VirtualRobot::RobotIO::RobotDescription& loadMode)
+    VirtualRobot::RobotPtr VirtualRobotReader::getRobot(const std::string& name, const armem::Time& timestamp,
+                                                        const VirtualRobot::RobotIO::RobotDescription& loadMode)
     {
-        ARMARX_VERBOSE << deactivateSpam(60) << "Querying robot description for robot '" << name
-                       << "'";
+        ARMARX_VERBOSE << deactivateSpam(60) << "Querying robot description for robot '" << name << "'";
         const auto description = queryDescription(name, timestamp);
 
         if (not description)
         {
-            ARMARX_VERBOSE << "The description of robot `" << name << "` is not a available!";
+            ARMARX_VERBOSE << deactivateSpam(5) << "The description of robot `" << name << "` is not a available!";
 
             return nullptr;
         }
@@ -76,7 +69,7 @@ namespace armarx::armem::robot_state
         const std::string xmlFilename = description->xml.toSystemPath();
         ARMARX_CHECK(std::filesystem::exists(xmlFilename)) << xmlFilename;
 
-        ARMARX_VERBOSE << "Loading (virtual) robot '" << description->name << "' from XML file '"
+        ARMARX_VERBOSE << deactivateSpam(5) << "Loading (virtual) robot '" << description->name << "' from XML file '"
                        << xmlFilename << "'";
 
         auto robot = VirtualRobot::RobotIO::loadRobot(xmlFilename, loadMode);
@@ -87,30 +80,24 @@ namespace armarx::armem::robot_state
         return robot;
     }
 
-    VirtualRobot::RobotPtr
-    VirtualRobotReader::getSynchronizedRobot(const std::string& name,
-                                             const VirtualRobot::BaseIO::RobotDescription& loadMode,
-                                             bool blocking)
+    VirtualRobot::RobotPtr VirtualRobotReader::getSynchronizedRobot(const std::string& name,
+                                                                    const VirtualRobot::BaseIO::RobotDescription& loadMode,
+                                                                    bool blocking)
     {
         return _getSynchronizedRobot(name, armem::Time::Invalid(), loadMode, blocking);
     }
 
     VirtualRobot::RobotPtr
-    VirtualRobotReader::getSynchronizedRobot(
-        const std::string& name,
-        const armem::Time& timestamp,
-        const VirtualRobot::RobotIO::RobotDescription& loadMode,
-        const bool blocking)
+    VirtualRobotReader::getSynchronizedRobot(const std::string& name, const armem::Time& timestamp,
+                                             const VirtualRobot::RobotIO::RobotDescription& loadMode,
+                                             const bool blocking)
     {
         return _getSynchronizedRobot(name, timestamp, loadMode, blocking);
     }
 
-    VirtualRobot::RobotPtr
-    VirtualRobotReader::_getSynchronizedRobot(
-        const std::string& name,
-        const Time& timestamp,
-        const VirtualRobot::BaseIO::RobotDescription& loadMode,
-        bool blocking)
+    VirtualRobot::RobotPtr VirtualRobotReader::_getSynchronizedRobot(const std::string& name, const Time& timestamp,
+                                                                     const VirtualRobot::BaseIO::RobotDescription& loadMode,
+                                                                     bool blocking)
     {
         while (blocking)
         {
@@ -122,11 +109,11 @@ namespace armarx::armem::robot_state
                 return robot;
             }
 
-            ARMARX_INFO << "Retrying to query robot after failure";
+            ARMARX_VERBOSE << deactivateSpam(5) << "Retrying to query robot after failure";
             Clock::WaitFor(sleepAfterFailure);
         }
 
-        ARMARX_VERBOSE << "Failed to get synchronized robot `" << name << "`";
+        ARMARX_VERBOSE << deactivateSpam(5) << "Failed to get synchronized robot `" << name << "`";
         return nullptr;
     }