diff --git a/Core/include/Acts/AmbiguityResolution/GreedyAmbiguityResolution.hpp b/Core/include/Acts/AmbiguityResolution/GreedyAmbiguityResolution.hpp
index 39f967b3494..1e59440b534 100644
--- a/Core/include/Acts/AmbiguityResolution/GreedyAmbiguityResolution.hpp
+++ b/Core/include/Acts/AmbiguityResolution/GreedyAmbiguityResolution.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2023-2024 CERN for the benefit of the Acts project
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -77,13 +77,11 @@ class GreedyAmbiguityResolution {
   /// @param state An empty state object which is expected to be default constructed.
   /// @param sourceLinkHash A functor to acquire a hash from a given source link.
   /// @param sourceLinkEquality A functor to check equality of two source links.
-  template <typename track_container_t, typename traj_t,
-            template <typename> class holder_t, typename source_link_hash_t,
+  template <typename track_container_t, typename source_link_hash_t,
             typename source_link_equality_t>
-  void computeInitialState(
-      const TrackContainer<track_container_t, traj_t, holder_t>& tracks,
-      State& state, source_link_hash_t&& sourceLinkHash,
-      source_link_equality_t&& sourceLinkEquality) const;
+  void computeInitialState(const track_container_t& tracks, State& state,
+                           source_link_hash_t&& sourceLinkHash,
+                           source_link_equality_t&& sourceLinkEquality) const;
 
   /// Updates the state iteratively by evicting one track after the other until
   /// the final state conditions are met.
diff --git a/Core/include/Acts/AmbiguityResolution/GreedyAmbiguityResolution.ipp b/Core/include/Acts/AmbiguityResolution/GreedyAmbiguityResolution.ipp
index ee2d14b1564..7fd3a1ce9b4 100644
--- a/Core/include/Acts/AmbiguityResolution/GreedyAmbiguityResolution.ipp
+++ b/Core/include/Acts/AmbiguityResolution/GreedyAmbiguityResolution.ipp
@@ -14,12 +14,11 @@
 
 namespace Acts {
 
-template <typename track_container_t, typename traj_t,
-          template <typename> class holder_t, typename source_link_hash_t,
+template <typename track_container_t, typename source_link_hash_t,
           typename source_link_equality_t>
 void GreedyAmbiguityResolution::computeInitialState(
-    const TrackContainer<track_container_t, traj_t, holder_t>& tracks,
-    State& state, source_link_hash_t&& sourceLinkHash,
+    const track_container_t& tracks, State& state,
+    source_link_hash_t&& sourceLinkHash,
     source_link_equality_t&& sourceLinkEquality) const {
   auto measurementIndexMap =
       std::unordered_map<SourceLink, std::size_t, source_link_hash_t,
diff --git a/Core/include/Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.hpp b/Core/include/Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.hpp
index afc19083117..132be21e225 100644
--- a/Core/include/Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.hpp
+++ b/Core/include/Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.hpp
@@ -116,16 +116,12 @@ class ScoreBasedAmbiguityResolution {
   /// The optional cuts,weights and score are used to remove tracks that are not
   /// good enough, based on some criteria. Users are free to add their own cuts
   /// with the help of this struct.
-  template <typename track_container_t, typename traj_t,
-            template <typename> class holder_t, bool ReadOnly = true>
+  template <typename track_proxy_t>
   struct OptionalCuts {
-    using OptionalFilter =
-        std::function<bool(const Acts::TrackProxy<track_container_t, traj_t,
-                                                  holder_t, ReadOnly>&)>;
+    using OptionalFilter = std::function<bool(const track_proxy_t&)>;
 
-    using OptionalScoreModifier = std::function<void(
-        const Acts::TrackProxy<track_container_t, traj_t, holder_t, ReadOnly>&,
-        double&)>;
+    using OptionalScoreModifier =
+        std::function<void(const track_proxy_t&, double&)>;
     std::vector<OptionalFilter> cuts = {};
     std::vector<OptionalScoreModifier> weights = {};
 
@@ -146,12 +142,10 @@ class ScoreBasedAmbiguityResolution {
   /// @param sourceLinkEquality is the equality function for the source links
   /// @param trackFeaturesVectors is the trackFeatures map from detector ID to trackFeatures
   /// @return a vector of the initial state of the tracks
-  template <typename track_container_t, typename traj_t,
-            template <typename> class holder_t, typename source_link_hash_t,
+  template <typename track_container_t, typename source_link_hash_t,
             typename source_link_equality_t>
   std::vector<std::vector<MeasurementInfo>> computeInitialState(
-      const TrackContainer<track_container_t, traj_t, holder_t>& tracks,
-      source_link_hash_t sourceLinkHash,
+      const track_container_t& tracks, source_link_hash_t sourceLinkHash,
       source_link_equality_t sourceLinkEquality,
       std::vector<std::vector<TrackFeatures>>& trackFeaturesVectors) const;
 
@@ -161,12 +155,11 @@ class ScoreBasedAmbiguityResolution {
   /// @param trackFeaturesVectors is the trackFeatures map from detector ID to trackFeatures
   /// @param optionalCuts is the user defined optional cuts to be applied.
   /// @return a vector of scores for each track
-  template <typename track_container_t, typename traj_t,
-            template <typename> class holder_t, bool ReadOnly = true>
+  template <typename track_container_t>
   std::vector<double> simpleScore(
-      const TrackContainer<track_container_t, traj_t, holder_t>& tracks,
+      const track_container_t& tracks,
       const std::vector<std::vector<TrackFeatures>>& trackFeaturesVectors,
-      const OptionalCuts<track_container_t, traj_t, holder_t, ReadOnly>&
+      const OptionalCuts<typename track_container_t::ConstTrackProxy>&
           optionalCuts = {}) const;
 
   /// Compute the score of each track based on the ambiguity function.
@@ -175,12 +168,11 @@ class ScoreBasedAmbiguityResolution {
   /// @param trackFeaturesVectors is the trackFeatures map from detector ID to trackFeatures
   /// @param optionalCuts is the user defined optional cuts to be applied.
   /// @return a vector of scores for each track
-  template <typename track_container_t, typename traj_t,
-            template <typename> class holder_t, bool ReadOnly = true>
+  template <typename track_container_t>
   std::vector<double> ambiguityScore(
-      const TrackContainer<track_container_t, traj_t, holder_t>& tracks,
+      const track_container_t& tracks,
       const std::vector<std::vector<TrackFeatures>>& trackFeaturesVectors,
-      const OptionalCuts<track_container_t, traj_t, holder_t, ReadOnly>&
+      const OptionalCuts<typename track_container_t::ConstTrackProxy>&
           optionalCuts = {}) const;
 
   /// Remove hits that are not good enough for each track and removes tracks
@@ -205,13 +197,12 @@ class ScoreBasedAmbiguityResolution {
   /// @param trackFeaturesVectors is the map of detector id to trackFeatures for each track
   /// @param optionalCuts is the optional cuts to be applied
   /// @return a vector of IDs of the tracks we want to keep
-  template <typename track_container_t, typename traj_t,
-            template <typename> class holder_t, bool ReadOnly = true>
+  template <typename track_container_t>
   std::vector<int> solveAmbiguity(
-      const TrackContainer<track_container_t, traj_t, holder_t>& tracks,
+      const track_container_t& tracks,
       const std::vector<std::vector<MeasurementInfo>>& measurementsPerTrack,
       const std::vector<std::vector<TrackFeatures>>& trackFeaturesVectors,
-      const OptionalCuts<track_container_t, traj_t, holder_t, ReadOnly>&
+      const OptionalCuts<typename track_container_t::ConstTrackProxy>&
           optionalCuts = {}) const;
 
  private:
diff --git a/Core/include/Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.ipp b/Core/include/Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.ipp
index cb3f5803342..903b1bb63d4 100644
--- a/Core/include/Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.ipp
+++ b/Core/include/Acts/AmbiguityResolution/ScoreBasedAmbiguityResolution.ipp
@@ -20,13 +20,11 @@ inline const Logger& ScoreBasedAmbiguityResolution::logger() const {
   return *m_logger;
 }
 
-template <typename track_container_t, typename traj_t,
-          template <typename> class holder_t, typename source_link_hash_t,
+template <typename track_container_t, typename source_link_hash_t,
           typename source_link_equality_t>
 std::vector<std::vector<ScoreBasedAmbiguityResolution::MeasurementInfo>>
 ScoreBasedAmbiguityResolution::computeInitialState(
-    const TrackContainer<track_container_t, traj_t, holder_t>& tracks,
-    source_link_hash_t sourceLinkHash,
+    const track_container_t& tracks, source_link_hash_t sourceLinkHash,
     source_link_equality_t sourceLinkEquality,
     std::vector<std::vector<TrackFeatures>>& trackFeaturesVectors) const {
   auto MeasurementIndexMap =
@@ -98,12 +96,11 @@ ScoreBasedAmbiguityResolution::computeInitialState(
   return measurementsPerTrack;
 }
 
-template <typename track_container_t, typename traj_t,
-          template <typename> class holder_t, bool ReadOnly>
+template <typename track_container_t>
 std::vector<double> Acts::ScoreBasedAmbiguityResolution::simpleScore(
-    const TrackContainer<track_container_t, traj_t, holder_t>& tracks,
+    const track_container_t& tracks,
     const std::vector<std::vector<TrackFeatures>>& trackFeaturesVectors,
-    const OptionalCuts<track_container_t, traj_t, holder_t, ReadOnly>&
+    const OptionalCuts<typename track_container_t::ConstTrackProxy>&
         optionalCuts) const {
   std::vector<double> trackScore;
   trackScore.reserve(tracks.size());
@@ -248,12 +245,11 @@ std::vector<double> Acts::ScoreBasedAmbiguityResolution::simpleScore(
   return trackScore;
 }
 
-template <typename track_container_t, typename traj_t,
-          template <typename> class holder_t, bool ReadOnly>
+template <typename track_container_t>
 std::vector<double> Acts::ScoreBasedAmbiguityResolution::ambiguityScore(
-    const TrackContainer<track_container_t, traj_t, holder_t>& tracks,
+    const track_container_t& tracks,
     const std::vector<std::vector<TrackFeatures>>& trackFeaturesVectors,
-    const OptionalCuts<track_container_t, traj_t, holder_t, ReadOnly>&
+    const OptionalCuts<typename track_container_t::ConstTrackProxy>&
         optionalCuts) const {
   std::vector<double> trackScore;
   trackScore.reserve(tracks.size());
@@ -425,13 +421,13 @@ std::vector<double> Acts::ScoreBasedAmbiguityResolution::ambiguityScore(
 
   return trackScore;
 }
-template <typename track_container_t, typename traj_t,
-          template <typename> class holder_t, bool ReadOnly>
+
+template <typename track_container_t>
 std::vector<int> Acts::ScoreBasedAmbiguityResolution::solveAmbiguity(
-    const TrackContainer<track_container_t, traj_t, holder_t>& tracks,
+    const track_container_t& tracks,
     const std::vector<std::vector<MeasurementInfo>>& measurementsPerTrack,
     const std::vector<std::vector<TrackFeatures>>& trackFeaturesVectors,
-    const OptionalCuts<track_container_t, traj_t, holder_t, ReadOnly>&
+    const OptionalCuts<typename track_container_t::ConstTrackProxy>&
         optionalCuts) const {
   ACTS_INFO("Number of tracks before Ambiguty Resolution: " << tracks.size());
   // vector of trackFeaturesVectors. where each trackFeaturesVector contains the
diff --git a/Core/include/Acts/EventData/TrackHelpers.hpp b/Core/include/Acts/EventData/TrackHelpers.hpp
index d88d1104850..2ee615fa656 100644
--- a/Core/include/Acts/EventData/TrackHelpers.hpp
+++ b/Core/include/Acts/EventData/TrackHelpers.hpp
@@ -15,16 +15,10 @@ namespace Acts {
 /// Helper function to calculate a number of track level quantities and store
 /// them on the track itself
 /// @note The input track needs to be mutable, so @c ReadOnly=false
-/// @tparam track_container_t the track container backend
-/// @tparam track_state_container_t the track state container backend
-/// @tparam holder_t the holder type for the track container backends
+/// @tparam track_proxy_t The type of the track proxy
 /// @param track A mutable track proxy to operate on
-template <typename track_container_t, typename track_state_container_t,
-          template <typename> class holder_t>
-void calculateTrackQuantities(
-    Acts::TrackProxy<track_container_t, track_state_container_t, holder_t,
-                     false>
-        track) {
+template <typename track_proxy_t>
+void calculateTrackQuantities(track_proxy_t track) {
   track.chi2() = 0;
   track.nDoF() = 0;
 
diff --git a/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp b/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp
index 49debb5d4cc..d5342a82443 100644
--- a/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp
+++ b/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp
@@ -91,13 +91,12 @@ struct GaussianSumFitter {
 
   /// @brief The fit function for the Direct navigator
   template <typename source_link_it_t, typename start_parameters_t,
-            typename track_container_t, template <typename> class holder_t>
+            typename track_container_t>
   auto fit(source_link_it_t begin, source_link_it_t end,
            const start_parameters_t& sParameters,
            const GsfOptions<traj_t>& options,
            const std::vector<const Surface*>& sSequence,
-           TrackContainer<track_container_t, traj_t, holder_t>& trackContainer)
-      const {
+           track_container_t& trackContainer) const {
     // Check if we have the correct navigator
     static_assert(
         std::is_same_v<DirectNavigator, typename propagator_t::Navigator>);
@@ -148,12 +147,11 @@ struct GaussianSumFitter {
 
   /// @brief The fit function for the standard navigator
   template <typename source_link_it_t, typename start_parameters_t,
-            typename track_container_t, template <typename> class holder_t>
+            typename track_container_t>
   auto fit(source_link_it_t begin, source_link_it_t end,
            const start_parameters_t& sParameters,
            const GsfOptions<traj_t>& options,
-           TrackContainer<track_container_t, traj_t, holder_t>& trackContainer)
-      const {
+           track_container_t& trackContainer) const {
     // Check if we have the correct navigator
     static_assert(std::is_same_v<Navigator, typename propagator_t::Navigator>);
 
@@ -200,16 +198,13 @@ struct GaussianSumFitter {
   /// first measurementSurface
   template <typename source_link_it_t, typename start_parameters_t,
             typename fwd_prop_initializer_t, typename bwd_prop_initializer_t,
-            typename track_container_t, template <typename> class holder_t>
-  Acts::Result<
-      typename TrackContainer<track_container_t, traj_t, holder_t>::TrackProxy>
-  fit_impl(source_link_it_t begin, source_link_it_t end,
-           const start_parameters_t& sParameters,
-           const GsfOptions<traj_t>& options,
-           const fwd_prop_initializer_t& fwdPropInitializer,
-           const bwd_prop_initializer_t& bwdPropInitializer,
-           TrackContainer<track_container_t, traj_t, holder_t>& trackContainer)
-      const {
+            typename track_container_t>
+  Acts::Result<typename track_container_t::TrackProxy> fit_impl(
+      source_link_it_t begin, source_link_it_t end,
+      const start_parameters_t& sParameters, const GsfOptions<traj_t>& options,
+      const fwd_prop_initializer_t& fwdPropInitializer,
+      const bwd_prop_initializer_t& bwdPropInitializer,
+      track_container_t& trackContainer) const {
     // return or abort utility
     auto return_error_or_abort = [&](auto error) {
       if (options.abortOnError) {
diff --git a/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp b/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp
index 49da43f4dcf..bdc59d26646 100644
--- a/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp
+++ b/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp
@@ -656,15 +656,13 @@ class Gx2Fitter {
   /// @return the output as an output track
   template <typename source_link_iterator_t, typename start_parameters_t,
             typename parameters_t = BoundTrackParameters,
-            typename track_container_t, template <typename> class holder_t,
-            bool _isdn = isDirectNavigator>
+            typename track_container_t, bool _isdn = isDirectNavigator>
   auto fit(source_link_iterator_t it, source_link_iterator_t end,
            const start_parameters_t& sParameters,
            const Gx2FitterOptions<traj_t>& gx2fOptions,
-           TrackContainer<track_container_t, traj_t, holder_t>& trackContainer)
-      const -> std::enable_if_t<
-          !_isdn, Result<typename TrackContainer<track_container_t, traj_t,
-                                                 holder_t>::TrackProxy>> {
+           track_container_t& trackContainer) const
+      -> std::enable_if_t<!_isdn,
+                          Result<typename track_container_t::TrackProxy>> {
     // Preprocess Measurements (SourceLinks -> map)
     // To be able to find measurements later, we put them into a map
     // We need to copy input SourceLinks anyway, so the map can own them.
diff --git a/Core/include/Acts/TrackFitting/KalmanFitter.hpp b/Core/include/Acts/TrackFitting/KalmanFitter.hpp
index 7492e55cd9f..c4072d78b75 100644
--- a/Core/include/Acts/TrackFitting/KalmanFitter.hpp
+++ b/Core/include/Acts/TrackFitting/KalmanFitter.hpp
@@ -1067,8 +1067,7 @@ class KalmanFitter {
   /// @tparam source_link_iterator_t Iterator type used to pass source links
   /// @tparam start_parameters_t Type of the initial parameters
   /// @tparam parameters_t Type of parameters used for local parameters
-  /// @tparam track_container_t Type of the track container backend
-  /// @tparam holder_t Type defining track container backend ownership
+  /// @tparam track_container_t Type of the track container
   ///
   /// @param it Begin iterator for the fittable uncalibrated measurements
   /// @param end End iterator for the fittable uncalibrated measurements
@@ -1082,15 +1081,13 @@ class KalmanFitter {
   /// @return the output as an output track
   template <typename source_link_iterator_t, typename start_parameters_t,
             typename parameters_t = BoundTrackParameters,
-            typename track_container_t, template <typename> class holder_t,
-            bool _isdn = isDirectNavigator>
+            typename track_container_t, bool _isdn = isDirectNavigator>
   auto fit(source_link_iterator_t it, source_link_iterator_t end,
            const start_parameters_t& sParameters,
            const KalmanFitterOptions<traj_t>& kfOptions,
-           TrackContainer<track_container_t, traj_t, holder_t>& trackContainer)
-      const -> std::enable_if_t<
-          !_isdn, Result<typename TrackContainer<track_container_t, traj_t,
-                                                 holder_t>::TrackProxy>> {
+           track_container_t& trackContainer) const
+      -> std::enable_if_t<!_isdn,
+                          Result<typename track_container_t::TrackProxy>> {
     // To be able to find measurements later, we put them into a map
     // We need to copy input SourceLinks anyway, so the map can own them.
     ACTS_VERBOSE("Preparing " << std::distance(it, end)
@@ -1144,9 +1141,9 @@ class KalmanFitter {
     kalmanActor.extensions = kfOptions.extensions;
     kalmanActor.actorLogger = m_actorLogger.get();
 
-    return fit_impl<start_parameters_t, PropagatorOptions, KalmanResult,
-                    track_container_t, holder_t>(sParameters, propagatorOptions,
-                                                 trackContainer);
+    return fit_impl<start_parameters_t, Actors, Aborters, KalmanResult,
+                    track_container_t>(sParameters, propagatorOptions,
+                                       trackContainer);
   }
 
   /// Fit implementation of the forward filter, calls the
@@ -1155,8 +1152,7 @@ class KalmanFitter {
   /// @tparam source_link_iterator_t Iterator type used to pass source links
   /// @tparam start_parameters_t Type of the initial parameters
   /// @tparam parameters_t Type of parameters used for local parameters
-  /// @tparam track_container_t Type of the track container backend
-  /// @tparam holder_t Type defining track container backend ownership
+  /// @tparam track_container_t Type of the track container
   ///
   /// @param it Begin iterator for the fittable uncalibrated measurements
   /// @param end End iterator for the fittable uncalibrated measurements
@@ -1172,16 +1168,14 @@ class KalmanFitter {
   /// @return the output as an output track
   template <typename source_link_iterator_t, typename start_parameters_t,
             typename parameters_t = BoundTrackParameters,
-            typename track_container_t, template <typename> class holder_t,
-            bool _isdn = isDirectNavigator>
+            typename track_container_t, bool _isdn = isDirectNavigator>
   auto fit(source_link_iterator_t it, source_link_iterator_t end,
            const start_parameters_t& sParameters,
            const KalmanFitterOptions<traj_t>& kfOptions,
            const std::vector<const Surface*>& sSequence,
-           TrackContainer<track_container_t, traj_t, holder_t>& trackContainer)
-      const -> std::enable_if_t<
-          _isdn, Result<typename TrackContainer<track_container_t, traj_t,
-                                                holder_t>::TrackProxy>> {
+           track_container_t& trackContainer) const
+      -> std::enable_if_t<_isdn,
+                          Result<typename track_container_t::TrackProxy>> {
     // To be able to find measurements later, we put them into a map
     // We need to copy input SourceLinks anyway, so the map can own them.
     ACTS_VERBOSE("Preparing " << std::distance(it, end)
@@ -1229,9 +1223,9 @@ class KalmanFitter {
     // Set the surface sequence
     propagatorOptions.navigation.surfaces = sSequence;
 
-    return fit_impl<start_parameters_t, PropagatorOptions, KalmanResult,
-                    track_container_t, holder_t>(sParameters, propagatorOptions,
-                                                 trackContainer);
+    return fit_impl<start_parameters_t, Actors, Aborters, KalmanResult,
+                    track_container_t>(sParameters, propagatorOptions,
+                                       trackContainer);
   }
 
  private:
@@ -1241,8 +1235,7 @@ class KalmanFitter {
   /// @tparam actor_list_t Type of the actor list
   /// @tparam aborter_list_t Type of the abort list
   /// @tparam kalman_result_t Type of the KF result
-  /// @tparam track_container_t Type of the track container backend
-  /// @tparam holder_t Type defining track container backend ownership
+  /// @tparam track_container_t Type of the track container
   ///
   /// @param sParameters The initial track parameters
   /// @param propagatorOptions The Propagator Options
@@ -1250,14 +1243,11 @@ class KalmanFitter {
   ///
   /// @return the output as an output track
   template <typename start_parameters_t, typename propagator_options_t,
-            typename kalman_result_t, typename track_container_t,
-            template <typename> class holder_t>
-  auto fit_impl(
-      const start_parameters_t& sParameters,
-      const propagator_options_t& propagatorOptions,
-      TrackContainer<track_container_t, traj_t, holder_t>& trackContainer) const
-      -> Result<typename TrackContainer<track_container_t, traj_t,
-                                        holder_t>::TrackProxy> {
+            typename kalman_result_t, typename track_container_t>
+  auto fit_impl(const start_parameters_t& sParameters,
+                const propagator_options_t& propagatorOptions,
+                track_container_t& trackContainer) const
+      -> Result<typename track_container_t::TrackProxy> {
     auto propagatorState =
         m_propagator.template makeState(sParameters, propagatorOptions);
 
@@ -1310,6 +1300,6 @@ class KalmanFitter {
     // Return the converted Track
     return track;
   }
-};
+};  // namespace Acts
 
 }  // namespace Acts
diff --git a/Examples/Algorithms/AmbiguityResolution/src/ScoreBasedAmbiguityResolutionAlgorithm.cpp b/Examples/Algorithms/AmbiguityResolution/src/ScoreBasedAmbiguityResolutionAlgorithm.cpp
index f3c7b99219c..41446543dc7 100644
--- a/Examples/Algorithms/AmbiguityResolution/src/ScoreBasedAmbiguityResolutionAlgorithm.cpp
+++ b/Examples/Algorithms/AmbiguityResolution/src/ScoreBasedAmbiguityResolutionAlgorithm.cpp
@@ -124,9 +124,7 @@ ActsExamples::ScoreBasedAmbiguityResolutionAlgorithm::execute(
   measurementsPerTracks = m_ambi.computeInitialState(
       tracks, &sourceLinkHash, &sourceLinkEquality, trackFeaturesVectors);
 
-  Acts::ScoreBasedAmbiguityResolution::OptionalCuts<
-      Acts::ConstVectorTrackContainer, Acts::ConstVectorMultiTrajectory,
-      std::shared_ptr, true>
+  Acts::ScoreBasedAmbiguityResolution::OptionalCuts<ConstTrackProxy>
       optionalCuts;
   optionalCuts.cuts.push_back(doubleHolesFilter);
   std::vector<int> goodTracks = m_ambi.solveAmbiguity(
diff --git a/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/AmbiguityDBScanClustering.hpp b/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/AmbiguityDBScanClustering.hpp
index 16a5801f971..071d15b81a4 100644
--- a/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/AmbiguityDBScanClustering.hpp
+++ b/Examples/Algorithms/TrackFindingML/include/ActsExamples/TrackFindingML/AmbiguityDBScanClustering.hpp
@@ -25,13 +25,11 @@ namespace Acts {
 /// @param epsilon Maximum distance between 2 tracks to be clustered
 /// @param minPoints Minimum number of tracks to create a cluster
 /// @return an unordered map representing the clusters, the keys the ID of the primary track of each cluster and the store a vector of track IDs.
-template <typename track_container_t, typename traj_t,
-          template <typename> class holder_t>
+template <typename track_container_t>
 std::unordered_map<std::size_t, std::vector<std::size_t>> dbscanTrackClustering(
     std::multimap<int, std::pair<std::size_t, std::vector<std::size_t>>>&
         trackMap,
-    const Acts::TrackContainer<track_container_t, traj_t, holder_t>& tracks,
-    float epsilon = 0.07, int minPoints = 2) {
+    const track_container_t& tracks, float epsilon = 0.07, int minPoints = 2) {
   // Unordered map associating a vector with all the track ID of a cluster to
   // the ID of the first track of the cluster
   std::unordered_map<std::size_t, std::vector<std::size_t>> cluster;
diff --git a/Plugins/EDM4hep/include/Acts/Plugins/EDM4hep/EDM4hepUtil.hpp b/Plugins/EDM4hep/include/Acts/Plugins/EDM4hep/EDM4hepUtil.hpp
index 505f9bbe1cc..7d494154a33 100644
--- a/Plugins/EDM4hep/include/Acts/Plugins/EDM4hep/EDM4hepUtil.hpp
+++ b/Plugins/EDM4hep/include/Acts/Plugins/EDM4hep/EDM4hepUtil.hpp
@@ -60,14 +60,10 @@ BoundTrackParameters convertTrackParametersFromEdm4hep(
 
 }  // namespace detail
 
-template <typename track_container_t, typename track_state_container_t,
-          template <typename> class holder_t>
-void writeTrack(
-    const Acts::GeometryContext& gctx,
-    Acts::TrackProxy<track_container_t, track_state_container_t, holder_t, true>
-        track,
-    edm4hep::MutableTrack to, double Bz,
-    const Logger& logger = getDummyLogger()) {
+template <typename track_proxy_t>
+void writeTrack(const Acts::GeometryContext& gctx, track_proxy_t track,
+                edm4hep::MutableTrack to, double Bz,
+                const Logger& logger = getDummyLogger()) {
   ACTS_VERBOSE("Converting track to EDM4hep");
   to.setChi2(track.chi2());
   to.setNdf(track.nDoF());
@@ -164,13 +160,9 @@ void writeTrack(
   }
 }
 
-template <typename track_container_t, typename track_state_container_t,
-          template <typename> class holder_t>
-void readTrack(const edm4hep::Track& from,
-               Acts::TrackProxy<track_container_t, track_state_container_t,
-                                holder_t, false>
-                   track,
-               double Bz, const Logger& logger = getDummyLogger()) {
+template <typename track_proxy_t>
+void readTrack(const edm4hep::Track& from, track_proxy_t track, double Bz,
+               const Logger& logger = getDummyLogger()) {
   ACTS_VERBOSE("Reading track from EDM4hep");
   TrackStatePropMask mask = TrackStatePropMask::Smoothed;
 
diff --git a/Plugins/Onnx/include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp b/Plugins/Onnx/include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp
index 8759450abd4..420c0fc9761 100644
--- a/Plugins/Onnx/include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp
+++ b/Plugins/Onnx/include/Acts/Plugins/Onnx/AmbiguityTrackClassifier.hpp
@@ -36,12 +36,10 @@ class AmbiguityTrackClassifier {
   /// @param clusters is a map of clusters, each cluster correspond to a vector of track ID
   /// @param tracks is the input track container
   /// @return a vector of vector of track score. Due to the architecture of the network each track only have a size 1 score vector.
-  template <typename track_container_t, typename traj_t,
-            template <typename> class holder_t>
+  template <typename track_proxy_t>
   std::vector<std::vector<float>> inferScores(
       std::unordered_map<std::size_t, std::vector<std::size_t>>& clusters,
-      const Acts::TrackContainer<track_container_t, traj_t, holder_t>& tracks)
-      const {
+      const track_proxy_t& tracks) const {
     // Compute the number of entry (since it is smaller than the number of
     // track)
     int trackNb = 0;
@@ -107,12 +105,10 @@ class AmbiguityTrackClassifier {
   /// @param clusters is a map of clusters, each cluster correspond to a vector of track ID
   /// @param tracks is the input track container
   /// @return a vector of trackID corresponding tho the good tracks
-  template <typename track_container_t, typename traj_t,
-            template <typename> class holder_t>
+  template <typename track_container_t>
   std::vector<std::size_t> solveAmbiguity(
       std::unordered_map<std::size_t, std::vector<std::size_t>>& clusters,
-      const Acts::TrackContainer<track_container_t, traj_t, holder_t>& tracks)
-      const {
+      const track_container_t& tracks) const {
     std::vector<std::vector<float>> outputTensor =
         inferScores(clusters, tracks);
     std::vector<std::size_t> goodTracks =