diff --git a/.clang-tidy b/.clang-tidy
index c6046c518c3f6d53b05c8e54f2d0a6992e99bfc6..fb1e61e2ee788dcfc872f591c937dd2ebdb7c76f 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -17,10 +17,7 @@ Checks: >
   misc-*,
   -misc-non-private-member-variables-in-classes,
   modernize-*,
-  -modernize-use-nodiscard,
-  -modernize-use-equals-default,
   -modernize-use-trailing-return-type,
-  -modernize-use-using,
   performance-*,
   readability-*,
   -readability-identifier-naming,
diff --git a/include/MantleAPI/Common/i_geometry_helper.h b/include/MantleAPI/Common/i_geometry_helper.h
index 214c68598f7d206665905b022df7d7cc0a8e85a3..61a334d2238fc84238a8561d2a1bd7c7f82bfe8f 100644
--- a/include/MantleAPI/Common/i_geometry_helper.h
+++ b/include/MantleAPI/Common/i_geometry_helper.h
@@ -34,7 +34,7 @@ public:
   ///                          the global coordinate system
   /// @param local_translation desired translation in local coordinates
   /// @return translated position in global coordinates
-  virtual Vec3<units::length::meter_t> TranslateGlobalPositionLocally(
+  [[nodiscard]] virtual Vec3<units::length::meter_t> TranslateGlobalPositionLocally(
       const Vec3<units::length::meter_t>& global_position,
       const Orientation3<units::angle::radian_t>& local_orientation,
       const Vec3<units::length::meter_t>& local_translation) const = 0;
@@ -44,7 +44,7 @@ public:
   /// @param local_origin  local coordinate system origin
   /// @param local_orientation local system orientation
   /// @return converted polyline points
-  virtual std::vector<Vec3<units::length::meter_t>> TransformPolylinePointsFromWorldToLocal(
+  [[nodiscard]] virtual std::vector<Vec3<units::length::meter_t>> TransformPolylinePointsFromWorldToLocal(
       const std::vector<Vec3<units::length::meter_t>>& polyline_points,
       const Vec3<units::length::meter_t>& local_origin,
       const Orientation3<units::angle::radian_t>& local_orientation) const = 0;
@@ -54,7 +54,7 @@ public:
   /// @param local_origin  local coordinate system origin
   /// @param local_orientation local system orientation
   /// @return transformed point
-  virtual Vec3<units::length::meter_t> TransformPositionFromWorldToLocal(
+  [[nodiscard]] virtual Vec3<units::length::meter_t> TransformPositionFromWorldToLocal(
       const Vec3<units::length::meter_t>& world_position,
       const Vec3<units::length::meter_t>& local_origin,
       const Orientation3<units::angle::radian_t>& local_orientation) const = 0;
diff --git a/include/MantleAPI/Common/i_identifiable.h b/include/MantleAPI/Common/i_identifiable.h
index a46500c74f6e0aa779284fbf11aa4bff424b7bc0..f063d97a3ee0684eebab0d5ec76746b912a7d9cb 100644
--- a/include/MantleAPI/Common/i_identifiable.h
+++ b/include/MantleAPI/Common/i_identifiable.h
@@ -31,12 +31,12 @@ public:
   virtual ~IIdentifiable() = default;
 
   /// The unique id is provided and maintained by the scenario simulator.
-  virtual UniqueId GetUniqueId() const = 0;
+  [[nodiscard]] virtual UniqueId GetUniqueId() const = 0;
   /// Scenario specific name of an object.
   ///
   /// The scenario description is responsible for keeping the name unique.
   virtual void SetName(const std::string& name) = 0;
-  virtual const std::string& GetName() const = 0;
+  [[nodiscard]] virtual const std::string& GetName() const = 0;
 };
 
 }  // namespace mantle_api
diff --git a/include/MantleAPI/Common/orientation.h b/include/MantleAPI/Common/orientation.h
index 58331452d2a26bdf82d94b0aeceb49be97e5c891..47ac54a5026debd125a6f2aa3783c24b68a9ef31 100644
--- a/include/MantleAPI/Common/orientation.h
+++ b/include/MantleAPI/Common/orientation.h
@@ -28,7 +28,7 @@ UNIT_ADD(angular_acceleration,
 
 namespace category
 {
-typedef base_unit<detail::meter_ratio<0>, std::ratio<0>, std::ratio<-2>, std::ratio<1>> angular_acceleration_unit;
+using angular_acceleration_unit = base_unit<detail::meter_ratio<0>, std::ratio<0>, std::ratio<-2>, std::ratio<1>>;
 }
 
 UNIT_ADD_CATEGORY_TRAIT(angular_acceleration)
@@ -41,7 +41,7 @@ UNIT_ADD(angular_jerk,
 
 namespace category
 {
-typedef base_unit<detail::meter_ratio<0>, std::ratio<0>, std::ratio<-3>, std::ratio<1>> angular_jerk_unit;
+using angular_jerk_unit = base_unit<detail::meter_ratio<0>, std::ratio<0>, std::ratio<-3>, std::ratio<1>>;
 }
 
 UNIT_ADD_CATEGORY_TRAIT(angular_jerk)
diff --git a/include/MantleAPI/Common/spline.h b/include/MantleAPI/Common/spline.h
index 4c109eec614de5fb69546fd1a8af751aa0e3035f..e57105080f3541aa401232865f051cc8204ff278 100644
--- a/include/MantleAPI/Common/spline.h
+++ b/include/MantleAPI/Common/spline.h
@@ -34,7 +34,7 @@ UNIT_ADD(jerk,
 
 namespace category
 {
-typedef base_unit<detail::meter_ratio<1>, std::ratio<0>, std::ratio<-3>> jerk_unit;
+using jerk_unit = base_unit<detail::meter_ratio<1>, std::ratio<0>, std::ratio<-3>>;
 }
 
 UNIT_ADD_CATEGORY_TRAIT(jerk)
@@ -47,7 +47,7 @@ UNIT_ADD(jerk_acceleration,
 
 namespace category
 {
-typedef base_unit<detail::meter_ratio<1>, std::ratio<0>, std::ratio<-4>> jerk_acceleration_unit;
+using jerk_acceleration_unit = base_unit<detail::meter_ratio<1>, std::ratio<0>, std::ratio<-4>>;
 }
 
 UNIT_ADD_CATEGORY_TRAIT(jerk_acceleration)
diff --git a/include/MantleAPI/Execution/i_environment.h b/include/MantleAPI/Execution/i_environment.h
index 2b24453446d7be5a6d86b454467d2f8882f6e550..0d680ae647b7d63cf5a32769e0f9c407f6518f7e 100644
--- a/include/MantleAPI/Execution/i_environment.h
+++ b/include/MantleAPI/Execution/i_environment.h
@@ -63,17 +63,17 @@ public:
   ///
   /// @param entity_id    The entity to check
   /// @param type         The control strategy type
-  virtual bool HasControlStrategyGoalBeenReached(UniqueId entity_id, mantle_api::ControlStrategyType type) const = 0;
+  [[nodiscard]] virtual bool HasControlStrategyGoalBeenReached(UniqueId entity_id, mantle_api::ControlStrategyType type) const = 0;
 
-  virtual const ILaneLocationQueryService& GetQueryService() const = 0;
-  virtual const ICoordConverter* GetConverter() const = 0;
-  virtual const IGeometryHelper* GetGeometryHelper() const = 0;
+  [[nodiscard]] virtual const ILaneLocationQueryService& GetQueryService() const = 0;
+  [[nodiscard]] virtual const ICoordConverter* GetConverter() const = 0;
+  [[nodiscard]] virtual const IGeometryHelper* GetGeometryHelper() const = 0;
 
   virtual IEntityRepository& GetEntityRepository() = 0;
-  virtual const IEntityRepository& GetEntityRepository() const = 0;
+  [[nodiscard]] virtual const IEntityRepository& GetEntityRepository() const = 0;
 
   virtual IControllerRepository& GetControllerRepository() = 0;
-  virtual const IControllerRepository& GetControllerRepository() const = 0;
+  [[nodiscard]] virtual const IControllerRepository& GetControllerRepository() const = 0;
 
   /// @brief DateTime in UTC (converted from RFC 3339 standard)
   virtual void SetDateTime(mantle_api::Time time) = 0;
diff --git a/include/MantleAPI/Execution/i_scenario_engine.h b/include/MantleAPI/Execution/i_scenario_engine.h
index f4cbff8184fb6c8fba25267fc3778d918d077b5b..e7bbbde87d04fcb9f65069d7979dab8aa91c375e 100644
--- a/include/MantleAPI/Execution/i_scenario_engine.h
+++ b/include/MantleAPI/Execution/i_scenario_engine.h
@@ -30,7 +30,7 @@ public:
   virtual void Init() = 0;
 
   /// Provide information about the scenario loaded in `Init()`
-  virtual ScenarioInfo GetScenarioInfo() const = 0;
+  [[nodiscard]] virtual ScenarioInfo GetScenarioInfo() const = 0;
 
   /// Calculate the new state of the scenario implementation.
   ///
@@ -40,7 +40,7 @@ public:
 
   /// Indicates whether the scenario implementation has finished processing the scenario (end of scenario is reached).
   /// @return `true` if processing the scenario is complete, `false` otherwise.
-  virtual bool IsFinished() const = 0;
+  [[nodiscard]] virtual bool IsFinished() const = 0;
 
   virtual void ActivateExternalHostControl() = 0;
 
diff --git a/include/MantleAPI/Map/i_coord_converter.h b/include/MantleAPI/Map/i_coord_converter.h
index 1b03af12dd18d35309ccdf5b231b29296f759e1b..d4850f9921c618820462c9b198fa4d2d61a1c426 100644
--- a/include/MantleAPI/Map/i_coord_converter.h
+++ b/include/MantleAPI/Map/i_coord_converter.h
@@ -28,7 +28,7 @@ class ICoordConverter
 public:
   virtual ~ICoordConverter() = default;
   /// Converts a track position to its corresponding inertial position.
-  virtual Vec3<units::length::meter_t> Convert(Position position) const = 0;
+  [[nodiscard]] virtual Vec3<units::length::meter_t> Convert(Position position) const = 0;
 };
 
 }  // namespace mantle_api
diff --git a/include/MantleAPI/Map/i_lane_location_query_service.h b/include/MantleAPI/Map/i_lane_location_query_service.h
index 61eaef358730694902e0b9435284e786f43788fb..12434aac031138fdd26dba8b2cb3f11c0e410844 100644
--- a/include/MantleAPI/Map/i_lane_location_query_service.h
+++ b/include/MantleAPI/Map/i_lane_location_query_service.h
@@ -52,7 +52,7 @@ public:
   /// @param position  Position that shall be mapped to a lane
   /// @return Orientation of the lane at this position
   /// @throw If the position cannot be mapped to a lane
-  virtual Orientation3<units::angle::radian_t> GetLaneOrientation(
+  [[nodiscard]] virtual Orientation3<units::angle::radian_t> GetLaneOrientation(
       const Vec3<units::length::meter_t>& position) const = 0;
 
   /// @brief Shifts a position the given amount upwards along the lane normal. This function is used for shifting
@@ -65,21 +65,21 @@ public:
   ///                                 world z-direction is used instead of the lane normal for the shift
   /// @return Upwards shifted position
   /// @throw If the position cannot be mapped to a lane and allow_invalid_positions=false.
-  virtual Vec3<units::length::meter_t> GetUpwardsShiftedLanePosition(const Vec3<units::length::meter_t>& position,
-                                                                     double upwards_shift,
-                                                                     bool allow_invalid_positions = false) const = 0;
+  [[nodiscard]] virtual Vec3<units::length::meter_t> GetUpwardsShiftedLanePosition(const Vec3<units::length::meter_t>& position,
+                                                                                   double upwards_shift,
+                                                                                   bool allow_invalid_positions = false) const = 0;
 
   /// @brief Checks, if a given position can be mapped to a lane
   ///
   /// @param position  Position to be checked
   /// @return true if the position can be mapped to a lane, false otherwise
-  virtual bool IsPositionOnLane(const Vec3<units::length::meter_t>& position) const = 0;
+  [[nodiscard]] virtual bool IsPositionOnLane(const Vec3<units::length::meter_t>& position) const = 0;
 
   /// @brief Returns a list of IDs representing all lanes enclosing the passed in position within their shape(s).
   ///
   /// @param position  Position to search for the Lane IDs
   /// @return List of global lane IDs
-  virtual std::vector<UniqueId> GetLaneIdsAtPosition(const Vec3<units::length::meter_t>& position) const = 0;
+  [[nodiscard]] virtual std::vector<UniqueId> GetLaneIdsAtPosition(const Vec3<units::length::meter_t>& position) const = 0;
 
   /// @brief Calculate the new pose which is at a certain longitudinal distance from the reference_pose_on_lane
   ///        following a direction.
@@ -94,9 +94,9 @@ public:
   ///         orientation is parallel to the lane orientation at the target position. The lateral offset from the lane
   ///         center line stays the same as at reference_pose_on_lane. If the reference_pose_on_lane cannot be mapped to
   ///         a lane or the target position would be beyond the road network limits, no value is returned.
-  virtual std::optional<Pose> FindLanePoseAtDistanceFrom(const Pose& reference_pose_on_lane,
-                                                         units::length::meter_t distance,
-                                                         Direction direction) const = 0;
+  [[nodiscard]] virtual std::optional<Pose> FindLanePoseAtDistanceFrom(const Pose& reference_pose_on_lane,
+                                                                       units::length::meter_t distance,
+                                                                       Direction direction) const = 0;
 
   /// @brief Calculate the longitudinal distance of two given positions on a lane.
   ///
@@ -107,7 +107,7 @@ public:
   ///         service implementation.
   ///         No value returned if the distance is not calculable.
 
-  virtual std::optional<units::length::meter_t> GetLongitudinalLaneDistanceBetweenPositions(
+  [[nodiscard]] virtual std::optional<units::length::meter_t> GetLongitudinalLaneDistanceBetweenPositions(
       const mantle_api::Vec3<units::length::meter_t>& start_position,
       const mantle_api::Vec3<units::length::meter_t>& target_position) const = 0;
 
@@ -126,10 +126,10 @@ public:
   ///         parallel to the lane orientation at the target position. No value is returned, if the
   ///         reference_pose_on_lane cannot be mapped to a lane or if the target position would be beyond the road
   ///         network limits in longitudinal or lateral direction.
-  virtual std::optional<Pose> FindRelativeLanePoseAtDistanceFrom(const Pose& reference_pose_on_lane,
-                                                                 int relative_target_lane,
-                                                                 units::length::meter_t distance,
-                                                                 units::length::meter_t lateral_offset) const = 0;
+  [[nodiscard]] virtual std::optional<Pose> FindRelativeLanePoseAtDistanceFrom(const Pose& reference_pose_on_lane,
+                                                                               int relative_target_lane,
+                                                                               units::length::meter_t distance,
+                                                                               units::length::meter_t lateral_offset) const = 0;
 
   /// @brief Calculate the lane id of the relative target lane from a given position
   ///
@@ -139,8 +139,8 @@ public:
   /// @return Lane id that is at the given lateral shift (relative_lane_target) from given position
   ///         (reference_pose_on_lane). No value, if reference pose is not on a lane or if the lane doesn't have a
   ///         suitable adjacent lane.
-  virtual std::optional<mantle_api::LaneId> GetRelativeLaneId(const mantle_api::Pose& reference_pose_on_lane,
-                                                              int relative_lane_target) const = 0;
+  [[nodiscard]] virtual std::optional<mantle_api::LaneId> GetRelativeLaneId(const mantle_api::Pose& reference_pose_on_lane,
+                                                                            int relative_lane_target) const = 0;
 };
 
 }  // namespace mantle_api
diff --git a/include/MantleAPI/Map/i_route.h b/include/MantleAPI/Map/i_route.h
index eee882f8d28b8347236aa1a39e84ef52cb2401f4..4f32d9c4eab5bedc92355608ba7e0b690a00ff5a 100644
--- a/include/MantleAPI/Map/i_route.h
+++ b/include/MantleAPI/Map/i_route.h
@@ -28,14 +28,14 @@ class IRoute : public virtual IIdentifiable
 public:
   virtual IRoute& AddWaypoint(const Vec3<units::length::meter_t>& inert_pos) = 0;
   virtual IRoute& AddWaypoint(Vec3<units::length::meter_t>&& inert_pos) = 0;
-  virtual Vec3<units::length::meter_t> GetInertPos(units::length::meter_t route_pos,
-                                                   LaneId lane_id,
-                                                   units::length::meter_t lane_offset = units::length::meter_t{
-                                                       0.0}) const = 0;
-  virtual units::length::meter_t GetLaneWidth(units::length::meter_t route_pos, LaneId lane_id) const = 0;
-  virtual LaneId GetLaneId(const Vec3<units::length::meter_t>& inert_pos) const = 0;
-  virtual units::length::meter_t GetDistanceFromStartTo(const Vec3<units::length::meter_t>& inert_pos) const = 0;
-  virtual units::length::meter_t GetLength() const = 0;
+  [[nodiscard]] virtual Vec3<units::length::meter_t> GetInertPos(units::length::meter_t route_pos,
+                                                                 LaneId lane_id,
+                                                                 units::length::meter_t lane_offset = units::length::meter_t{
+                                                                     0.0}) const = 0;
+  [[nodiscard]] virtual units::length::meter_t GetLaneWidth(units::length::meter_t route_pos, LaneId lane_id) const = 0;
+  [[nodiscard]] virtual LaneId GetLaneId(const Vec3<units::length::meter_t>& inert_pos) const = 0;
+  [[nodiscard]] virtual units::length::meter_t GetDistanceFromStartTo(const Vec3<units::length::meter_t>& inert_pos) const = 0;
+  [[nodiscard]] virtual units::length::meter_t GetLength() const = 0;
 };
 
 }  // namespace mantle_api
diff --git a/include/MantleAPI/Traffic/i_controller_config.h b/include/MantleAPI/Traffic/i_controller_config.h
index ce35330991812a507ce3eaba15601c23332a1eaa..a0c2a7a97191b3de7861ba8d2458f4a43d2b4a22 100644
--- a/include/MantleAPI/Traffic/i_controller_config.h
+++ b/include/MantleAPI/Traffic/i_controller_config.h
@@ -30,7 +30,7 @@ namespace mantle_api
 {
 struct IControllerConfig
 {
-  IControllerConfig() {}
+  IControllerConfig() = default;
   IControllerConfig(const IControllerConfig& controller_config)
       : map_query_service(controller_config.map_query_service)
   {
diff --git a/include/MantleAPI/Traffic/i_controller_repository.h b/include/MantleAPI/Traffic/i_controller_repository.h
index d245c9a25647c9153665c93622958119ed482e88..864e44d034d729aa857e3ca88df0027bef5d91cd 100644
--- a/include/MantleAPI/Traffic/i_controller_repository.h
+++ b/include/MantleAPI/Traffic/i_controller_repository.h
@@ -30,7 +30,7 @@ public:
   [[deprecated]] virtual IController& Create(UniqueId id, std::unique_ptr<IControllerConfig> config) = 0; // deprecated
 
   virtual std::optional<std::reference_wrapper<IController>> Get(UniqueId id) = 0;
-  virtual bool Contains(UniqueId id) const = 0;
+  [[nodiscard]] virtual bool Contains(UniqueId id) const = 0;
 
   virtual void Delete(UniqueId id) = 0;
 
diff --git a/include/MantleAPI/Traffic/i_entity.h b/include/MantleAPI/Traffic/i_entity.h
index 3918b9d2c9bd38e428d2b026770ed364527793a9..b8d33bd9a82aa412184e1d21f4bef9c6a9285475 100644
--- a/include/MantleAPI/Traffic/i_entity.h
+++ b/include/MantleAPI/Traffic/i_entity.h
@@ -53,43 +53,43 @@ public:
   /// The position of the entity is the geometric center of its bounding box. The origin of the entity coordinate system
   /// can be defined flexibly in relation to the geometric center (see bounding box).
   virtual void SetPosition(const Vec3<units::length::meter_t>& inert_pos) = 0;
-  virtual Vec3<units::length::meter_t> GetPosition() const = 0;
+  [[nodiscard]] virtual Vec3<units::length::meter_t> GetPosition() const = 0;
 
   virtual void SetVelocity(const Vec3<units::velocity::meters_per_second_t>& velocity) = 0;
-  virtual Vec3<units::velocity::meters_per_second_t> GetVelocity() const = 0;
+  [[nodiscard]] virtual Vec3<units::velocity::meters_per_second_t> GetVelocity() const = 0;
 
   virtual void SetAcceleration(const Vec3<units::acceleration::meters_per_second_squared_t>& acceleration) = 0;
-  virtual Vec3<units::acceleration::meters_per_second_squared_t> GetAcceleration() const = 0;
+  [[nodiscard]] virtual Vec3<units::acceleration::meters_per_second_squared_t> GetAcceleration() const = 0;
 
   virtual void SetOrientation(const Orientation3<units::angle::radian_t>& orientation) = 0;
-  virtual Orientation3<units::angle::radian_t> GetOrientation() const = 0;
+  [[nodiscard]] virtual Orientation3<units::angle::radian_t> GetOrientation() const = 0;
 
   virtual void SetOrientationRate(
       const Orientation3<units::angular_velocity::radians_per_second_t>& orientation_rate) = 0;
-  virtual Orientation3<units::angular_velocity::radians_per_second_t> GetOrientationRate() const = 0;
+  [[nodiscard]] virtual Orientation3<units::angular_velocity::radians_per_second_t> GetOrientationRate() const = 0;
 
   virtual void SetOrientationAcceleration(
       const Orientation3<units::angular_acceleration::radians_per_second_squared_t>& orientation_acceleration) = 0;
-  virtual Orientation3<units::angular_acceleration::radians_per_second_squared_t> GetOrientationAcceleration()
+  [[nodiscard]] virtual Orientation3<units::angular_acceleration::radians_per_second_squared_t> GetOrientationAcceleration()
       const = 0;
 
   virtual void SetProperties(std::unique_ptr<mantle_api::EntityProperties> properties) = 0;
-  virtual EntityProperties* GetProperties() const = 0;
+  [[nodiscard]] virtual EntityProperties* GetProperties() const = 0;
 
   virtual void SetAssignedLaneIds(const std::vector<std::uint64_t>& assigned_lane_ids) = 0;
-  virtual std::vector<std::uint64_t> GetAssignedLaneIds() const = 0;
+  [[nodiscard]] virtual std::vector<std::uint64_t> GetAssignedLaneIds() const = 0;
 
   virtual void SetVisibility(const EntityVisibilityConfig& visibility) = 0;
-  virtual EntityVisibilityConfig GetVisibility() const = 0;
+  [[nodiscard]] virtual EntityVisibilityConfig GetVisibility() const = 0;
 };
 
 class IVehicle : public virtual IEntity
 {
 public:
-  VehicleProperties* GetProperties() const override = 0;
+  [[nodiscard]] VehicleProperties* GetProperties() const override = 0;
 
   virtual void SetIndicatorState(IndicatorState state) = 0;
-  virtual IndicatorState GetIndicatorState() const = 0;
+  [[nodiscard]] virtual IndicatorState GetIndicatorState() const = 0;
 
   //    virtual bool IsHost() const = 0;
   //    virtual void SetHost() = 0;
@@ -98,13 +98,13 @@ public:
 class IPedestrian : public virtual IEntity
 {
 public:
-  PedestrianProperties* GetProperties() const override = 0;
+  [[nodiscard]] PedestrianProperties* GetProperties() const override = 0;
 };
 
 class IStaticObject : public virtual IEntity
 {
 public:
-  StaticObjectProperties* GetProperties() const override = 0;
+  [[nodiscard]] StaticObjectProperties* GetProperties() const override = 0;
 };
 
 }  // namespace mantle_api
diff --git a/include/MantleAPI/Traffic/i_entity_repository.h b/include/MantleAPI/Traffic/i_entity_repository.h
index 080d38277fef0e486d3cba85b69e5c2015701eb2..03cd4f2b93d5da889a06d8bb603559bec4f580b7 100644
--- a/include/MantleAPI/Traffic/i_entity_repository.h
+++ b/include/MantleAPI/Traffic/i_entity_repository.h
@@ -38,15 +38,15 @@ public:
 
   virtual IVehicle& GetHost() = 0;
   virtual std::optional<std::reference_wrapper<IEntity>> Get(const std::string& name) = 0;
-  virtual std::optional<std::reference_wrapper<const IEntity>> Get(const std::string& name) const = 0;
+  [[nodiscard]] virtual std::optional<std::reference_wrapper<const IEntity>> Get(const std::string& name) const = 0;
   virtual std::optional<std::reference_wrapper<IEntity>> Get(UniqueId id) = 0;
-  virtual std::optional<std::reference_wrapper<const IEntity>> Get(UniqueId id) const = 0;
-  virtual bool Contains(UniqueId id) const = 0;
+  [[nodiscard]] virtual std::optional<std::reference_wrapper<const IEntity>> Get(UniqueId id) const = 0;
+  [[nodiscard]] virtual bool Contains(UniqueId id) const = 0;
 
   virtual void Delete(const std::string& name) = 0;
   virtual void Delete(UniqueId id) = 0;
 
-  virtual const std::vector<std::unique_ptr<mantle_api::IEntity>>& GetEntities() const = 0;
+  [[nodiscard]] virtual const std::vector<std::unique_ptr<mantle_api::IEntity>>& GetEntities() const = 0;
 
   virtual void RegisterEntityCreatedCallback(const std::function<void(IEntity&)>& callback) = 0;
   virtual void RegisterEntityDeletedCallback(const std::function<void(const std::string&)>& callback) = 0;