diff --git a/src/Evolution/Executables/Cce/CharacteristicExtractBase.hpp b/src/Evolution/Executables/Cce/CharacteristicExtractBase.hpp
index 449c2c06b95a..d67f929f4dba 100644
--- a/src/Evolution/Executables/Cce/CharacteristicExtractBase.hpp
+++ b/src/Evolution/Executables/Cce/CharacteristicExtractBase.hpp
@@ -14,7 +14,7 @@
 #include "NumericalAlgorithms/SpinWeightedSphericalHarmonics/SwshTags.hpp"
 #include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/ErrorControl.hpp"
-#include "Time/StepChoosers/Increase.hpp"
+#include "Time/StepChoosers/LimitIncrease.hpp"
 #include "Utilities/TMPL.hpp"
 
 template <bool EvolveCcm>
@@ -112,7 +112,7 @@ struct CharacteristicExtractDefaults {
                           tmpl::list<Cce::Tags::CauchyAngularCoords>>;
   using cce_step_choosers =
       tmpl::list<StepChoosers::Constant<StepChooserUse::LtsStep>,
-                 StepChoosers::Increase<StepChooserUse::LtsStep>,
+                 StepChoosers::LimitIncrease<StepChooserUse::LtsStep>,
                  StepChoosers::ErrorControl<StepChooserUse::LtsStep,
                                             Tags::Variables<evolved_swsh_tags>,
                                             swsh_vars_selector>,
diff --git a/src/Evolution/Executables/GeneralizedHarmonic/EvolveGhBinaryBlackHole.hpp b/src/Evolution/Executables/GeneralizedHarmonic/EvolveGhBinaryBlackHole.hpp
index d81df2741b05..2d7de8172ef3 100644
--- a/src/Evolution/Executables/GeneralizedHarmonic/EvolveGhBinaryBlackHole.hpp
+++ b/src/Evolution/Executables/GeneralizedHarmonic/EvolveGhBinaryBlackHole.hpp
@@ -164,13 +164,8 @@
 #include "Time/Actions/UpdateU.hpp"
 #include "Time/ChangeSlabSize/Action.hpp"
 #include "Time/ChangeSlabSize/Tags.hpp"
-#include "Time/StepChoosers/Cfl.hpp"
-#include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/Factory.hpp"
-#include "Time/StepChoosers/Increase.hpp"
-#include "Time/StepChoosers/PreventRapidIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
-#include "Time/StepChoosers/StepToTimes.hpp"
 #include "Time/Tags/StepperErrors.hpp"
 #include "Time/Tags/Time.hpp"
 #include "Time/Tags/TimeStepId.hpp"
diff --git a/src/Evolution/Executables/GeneralizedHarmonic/GeneralizedHarmonicBase.hpp b/src/Evolution/Executables/GeneralizedHarmonic/GeneralizedHarmonicBase.hpp
index 9e94f95d22a2..64ea0abcdd6c 100644
--- a/src/Evolution/Executables/GeneralizedHarmonic/GeneralizedHarmonicBase.hpp
+++ b/src/Evolution/Executables/GeneralizedHarmonic/GeneralizedHarmonicBase.hpp
@@ -131,13 +131,8 @@
 #include "Time/Actions/RecordTimeStepperData.hpp"
 #include "Time/Actions/SelfStartActions.hpp"
 #include "Time/Actions/UpdateU.hpp"
-#include "Time/StepChoosers/Cfl.hpp"
-#include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/Factory.hpp"
-#include "Time/StepChoosers/Increase.hpp"
-#include "Time/StepChoosers/PreventRapidIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
-#include "Time/StepChoosers/StepToTimes.hpp"
 #include "Time/Tags/Time.hpp"
 #include "Time/TimeSequence.hpp"
 #include "Time/TimeSteppers/Factory.hpp"
diff --git a/src/Evolution/Executables/GrMhd/GhValenciaDivClean/GhValenciaDivCleanBase.hpp b/src/Evolution/Executables/GrMhd/GhValenciaDivClean/GhValenciaDivCleanBase.hpp
index 9046d648334c..bae017435b34 100644
--- a/src/Evolution/Executables/GrMhd/GhValenciaDivClean/GhValenciaDivCleanBase.hpp
+++ b/src/Evolution/Executables/GrMhd/GhValenciaDivClean/GhValenciaDivCleanBase.hpp
@@ -221,13 +221,8 @@
 #include "Time/Actions/SelfStartActions.hpp"  // IWYU pragma: keep
 #include "Time/Actions/UpdateU.hpp"
 #include "Time/ChangeSlabSize/Action.hpp"
-#include "Time/StepChoosers/Cfl.hpp"
-#include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/Factory.hpp"
-#include "Time/StepChoosers/Increase.hpp"
-#include "Time/StepChoosers/PreventRapidIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
-#include "Time/StepChoosers/StepToTimes.hpp"
 #include "Time/Tags/Time.hpp"
 #include "Time/Tags/TimeStepId.hpp"
 #include "Time/TimeSequence.hpp"
diff --git a/src/Evolution/Executables/ScalarTensor/ScalarTensorBase.hpp b/src/Evolution/Executables/ScalarTensor/ScalarTensorBase.hpp
index 3e6b48e2e583..a1ffec5b349d 100644
--- a/src/Evolution/Executables/ScalarTensor/ScalarTensorBase.hpp
+++ b/src/Evolution/Executables/ScalarTensor/ScalarTensorBase.hpp
@@ -132,13 +132,8 @@
 #include "Time/Actions/RecordTimeStepperData.hpp"
 #include "Time/Actions/SelfStartActions.hpp"
 #include "Time/Actions/UpdateU.hpp"
-#include "Time/StepChoosers/Cfl.hpp"
-#include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/Factory.hpp"
-#include "Time/StepChoosers/Increase.hpp"
-#include "Time/StepChoosers/PreventRapidIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
-#include "Time/StepChoosers/StepToTimes.hpp"
 #include "Time/Tags/Time.hpp"
 #include "Time/TimeSequence.hpp"
 #include "Time/TimeSteppers/Factory.hpp"
diff --git a/src/Evolution/Initialization/Evolution.hpp b/src/Evolution/Initialization/Evolution.hpp
index de6bfcdea451..6f832f623b9e 100644
--- a/src/Evolution/Initialization/Evolution.hpp
+++ b/src/Evolution/Initialization/Evolution.hpp
@@ -26,6 +26,7 @@
 #include "Parallel/Tags/ArrayIndex.hpp"
 #include "ParallelAlgorithms/Amr/Protocols/Projector.hpp"
 #include "Time/AdaptiveSteppingDiagnostics.hpp"
+#include "Time/ChangeSlabSize/Tags.hpp"
 #include "Time/ChooseLtsStepSize.hpp"
 #include "Time/Slab.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
@@ -114,7 +115,8 @@ struct TimeStepping {
   /// Tags for items in the DataBox that are mutated by the apply function
   using return_tags =
       tmpl::list<::Tags::Next<::Tags::TimeStepId>, ::Tags::TimeStep,
-                 ::Tags::Next<::Tags::TimeStep>>;
+                 ::Tags::Next<::Tags::TimeStep>,
+                 ::Tags::ChangeSlabSize::SlabSizeGoal>;
 
   /// Tags for mutable DataBox items that are either default initialized or
   /// initialized by the apply function
@@ -130,6 +132,7 @@ struct TimeStepping {
   static void apply(const gsl::not_null<TimeStepId*> next_time_step_id,
                     const gsl::not_null<TimeDelta*> time_step,
                     const gsl::not_null<TimeDelta*> next_time_step,
+                    const gsl::not_null<double*> slab_size_goal,
                     const double initial_time_value,
                     const double initial_dt_value,
                     const double initial_slab_size,
@@ -141,6 +144,8 @@ struct TimeStepping {
                                   time_runs_forward, time_stepper);
     *time_step = choose_lts_step_size(initial_time, initial_dt_value);
     *next_time_step = *time_step;
+    *slab_size_goal =
+        time_runs_forward ? initial_slab_size : -initial_slab_size;
   }
 
   /// Given the items fetched from a DataBox by the argument_tags, when not
@@ -148,6 +153,7 @@ struct TimeStepping {
   static void apply(const gsl::not_null<TimeStepId*> next_time_step_id,
                     const gsl::not_null<TimeDelta*> time_step,
                     const gsl::not_null<TimeDelta*> next_time_step,
+                    const gsl::not_null<double*> slab_size_goal,
                     const double initial_time_value,
                     const double initial_dt_value,
                     const double initial_slab_size,
@@ -159,6 +165,8 @@ struct TimeStepping {
                                   time_runs_forward, time_stepper);
     *time_step = (time_runs_forward ? 1 : -1) * initial_time.slab().duration();
     *next_time_step = *time_step;
+    *slab_size_goal =
+        time_runs_forward ? initial_slab_size : -initial_slab_size;
   }
 };
 
@@ -168,7 +176,8 @@ struct ProjectTimeStepping : tt::ConformsTo<amr::protocols::Projector> {
   using return_tags =
       tmpl::list<::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                  ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>, ::Tags::Time,
-                 ::Tags::AdaptiveSteppingDiagnostics>;
+                 ::Tags::AdaptiveSteppingDiagnostics,
+                 ::Tags::ChangeSlabSize::SlabSizeGoal>;
   using argument_tags = tmpl::list<Parallel::Tags::ArrayIndex>;
 
   static void apply(
@@ -179,6 +188,7 @@ struct ProjectTimeStepping : tt::ConformsTo<amr::protocols::Projector> {
       const gsl::not_null<double*> /*time*/,
       const gsl::not_null<AdaptiveSteppingDiagnostics*>
       /*adaptive_stepping_diagnostics*/,
+      const gsl::not_null<double*> /*slab_size_goal*/,
       const ElementId<Dim>& /*element_id*/,
       const std::pair<Mesh<Dim>, Element<Dim>>& /*old_mesh_and_element*/) {
     // Do not change anything for p-refinement
@@ -192,6 +202,7 @@ struct ProjectTimeStepping : tt::ConformsTo<amr::protocols::Projector> {
                     const gsl::not_null<double*> time,
                     const gsl::not_null<AdaptiveSteppingDiagnostics*>
                         adaptive_stepping_diagnostics,
+                    const gsl::not_null<double*> slab_size_goal,
                     const ElementId<Dim>& element_id,
                     const tuples::TaggedTuple<Tags...>& parent_items) {
     *time_step_id = get<::Tags::TimeStepId>(parent_items);
@@ -199,6 +210,7 @@ struct ProjectTimeStepping : tt::ConformsTo<amr::protocols::Projector> {
     *time_step = get<::Tags::TimeStep>(parent_items);
     *next_time_step = get<::Tags::Next<::Tags::TimeStep>>(parent_items);
     *time = get<::Tags::Time>(parent_items);
+    *slab_size_goal = get<::Tags::ChangeSlabSize::SlabSizeGoal>(parent_items);
 
     // Since AdaptiveSteppingDiagnostics are reduced over all elements, we
     // set the slab quantities to the same value over all children, and the
@@ -229,6 +241,7 @@ struct ProjectTimeStepping : tt::ConformsTo<amr::protocols::Projector> {
       const gsl::not_null<double*> time,
       const gsl::not_null<AdaptiveSteppingDiagnostics*>
           adaptive_stepping_diagnostics,
+      const gsl::not_null<double*> slab_size_goal,
       const ElementId<Dim>& /*element_id*/,
       const std::unordered_map<ElementId<Dim>, tuples::TaggedTuple<Tags...>>&
           children_items) {
@@ -248,6 +261,8 @@ struct ProjectTimeStepping : tt::ConformsTo<amr::protocols::Projector> {
     *time_step = get<::Tags::TimeStep>(slowest_child_items);
     *next_time_step = get<::Tags::Next<::Tags::TimeStep>>(slowest_child_items);
     *time = get<::Tags::Time>(slowest_child_items);
+    *slab_size_goal =
+        get<::Tags::ChangeSlabSize::SlabSizeGoal>(slowest_child_items);
     const auto& slowest_child_diagnostics =
         get<::Tags::AdaptiveSteppingDiagnostics>(slowest_child_items);
 
diff --git a/src/Time/Actions/ChangeStepSize.hpp b/src/Time/Actions/ChangeStepSize.hpp
index ff8982ace95c..123a30b0567b 100644
--- a/src/Time/Actions/ChangeStepSize.hpp
+++ b/src/Time/Actions/ChangeStepSize.hpp
@@ -15,6 +15,7 @@
 #include "Time/ChooseLtsStepSize.hpp"
 #include "Time/Tags/AdaptiveSteppingDiagnostics.hpp"
 #include "Time/Tags/HistoryEvolvedVariables.hpp"
+#include "Time/TimeStepRequestProcessor.hpp"
 #include "Time/TimeSteppers/LtsTimeStepper.hpp"
 #include "Utilities/ErrorHandling/Assert.hpp"
 #include "Utilities/Gsl.hpp"
@@ -61,6 +62,20 @@ bool change_step_size(const gsl::not_null<db::DataBox<DbTags>*> box) {
 
   const auto& time_step_id = db::get<Tags::TimeStepId>(*box);
   ASSERT(time_step_id.substep() == 0, "Can't change step size on a substep.");
+
+  const auto& current_step = db::get<Tags::TimeStep>(*box);
+  const double last_step_size = current_step.value();
+
+  TimeStepRequestProcessor step_requests(time_step_id.time_runs_forward());
+  bool step_accepted = true;
+  for (const auto& step_chooser : step_choosers) {
+    const auto [step_request, step_choice_accepted] =
+        step_chooser->template desired_step<StepChoosersToUse>(last_step_size,
+                                                               *box);
+    step_requests.process(step_request);
+    step_accepted = step_accepted and step_choice_accepted;
+  }
+
   using history_tags = ::Tags::get_all_history_tags<DbTags>;
   bool can_change_step_size = true;
   tmpl::for_each<history_tags>([&box, &can_change_step_size, &time_stepper,
@@ -74,28 +89,14 @@ bool change_step_size(const gsl::not_null<db::DataBox<DbTags>*> box) {
         time_stepper.can_change_step_size(time_step_id, history);
   });
   if (not can_change_step_size) {
+    step_requests.error_on_hard_limit(
+        current_step.value(),
+        (time_step_id.step_time() + current_step).value());
     return true;
   }
 
-  const auto& current_step = db::get<Tags::TimeStep>(*box);
-
-  const double last_step_size = std::abs(db::get<Tags::TimeStep>(*box).value());
-
-  // The step choosers return the magnitude of the desired step, so
-  // we always want the minimum requirement, but we have to negate
-  // the final answer if time is running backwards.
-  double desired_step = std::numeric_limits<double>::infinity();
-  bool step_accepted = true;
-  for (const auto& step_chooser : step_choosers) {
-    const auto [step_choice, step_choice_accepted] =
-        step_chooser->template desired_step<StepChoosersToUse>(
-            last_step_size, *box);
-    desired_step = std::min(desired_step, step_choice);
-    step_accepted = step_accepted and step_choice_accepted;
-  }
-  if (not current_step.is_positive()) {
-    desired_step = -desired_step;
-  }
+  const double desired_step = step_requests.step_size(
+      time_step_id.step_time().value(), current_step.value());
 
   constexpr double smallest_relative_step_size = 1.0e-9;
   if (abs(desired_step / current_step.slab().duration().value()) <
@@ -124,6 +125,9 @@ bool change_step_size(const gsl::not_null<db::DataBox<DbTags>*> box) {
   // if step accepted, just proceed. Otherwise, change Time::Next and jump
   // back to the first instance of `UpdateU`.
   if (step_accepted) {
+    step_requests.error_on_hard_limit(
+        current_step.value(),
+        (time_step_id.step_time() + current_step).value());
     return true;
   } else {
     db::mutate<Tags::Next<Tags::TimeStepId>, Tags::TimeStep>(
diff --git a/src/Time/CMakeLists.txt b/src/Time/CMakeLists.txt
index 7b3876d3b8f0..b70d8d64d5a7 100644
--- a/src/Time/CMakeLists.txt
+++ b/src/Time/CMakeLists.txt
@@ -20,6 +20,8 @@ spectre_target_sources(
   Time.cpp
   TimeSequence.cpp
   TimeStepId.cpp
+  TimeStepRequest.cpp
+  TimeStepRequestProcessor.cpp
   Utilities.cpp
   )
 
@@ -42,6 +44,8 @@ spectre_target_headers(
   Time.hpp
   TimeSequence.hpp
   TimeStepId.hpp
+  TimeStepRequest.hpp
+  TimeStepRequestProcessor.hpp
   Utilities.hpp
   )
 
diff --git a/src/Time/ChangeSlabSize/Action.hpp b/src/Time/ChangeSlabSize/Action.hpp
index b7f4a7ce2a11..ff35a2510a10 100644
--- a/src/Time/ChangeSlabSize/Action.hpp
+++ b/src/Time/ChangeSlabSize/Action.hpp
@@ -7,16 +7,18 @@
 #include <cstdint>
 #include <map>
 #include <optional>
-#include <unordered_set>
+#include <vector>
 
 #include "DataStructures/DataBox/DataBox.hpp"
 #include "Parallel/AlgorithmExecution.hpp"
 #include "Time/ChangeSlabSize/ChangeSlabSize.hpp"
 #include "Time/ChangeSlabSize/Tags.hpp"
 #include "Time/Tags/HistoryEvolvedVariables.hpp"
+#include "Time/TimeStepRequestProcessor.hpp"
 #include "Time/TimeSteppers/TimeStepper.hpp"
 #include "Utilities/Algorithm.hpp"
 #include "Utilities/ErrorHandling/Assert.hpp"
+#include "Utilities/Numeric.hpp"
 #include "Utilities/TMPL.hpp"
 
 /// \cond
@@ -25,6 +27,7 @@ template <typename Metavariables>
 class GlobalCache;
 }  // namespace Parallel
 namespace Tags {
+struct TimeStep;
 struct TimeStepId;
 template <typename StepperInterface>
 struct TimeStepper;
@@ -73,78 +76,84 @@ struct ChangeSlabSize {
       return {Parallel::AlgorithmExecution::Continue, std::nullopt};
     }
 
+    TimeStepRequestProcessor step_requests(time_step_id.time_runs_forward());
+
     const auto slab_number = time_step_id.slab_number();
     const auto& expected_messages_map =
         db::get<::Tags::ChangeSlabSize::NumberOfExpectedMessages>(box);
-    if (expected_messages_map.empty() or
-        expected_messages_map.begin()->first != slab_number) {
-      return {Parallel::AlgorithmExecution::Continue, std::nullopt};
-    }
-    const size_t expected_messages = expected_messages_map.begin()->second;
-    ASSERT(expected_messages > 0,
-           "Should only create map entries when sending messages.");
-
-    const auto& slab_size_messages =
-        db::get<::Tags::ChangeSlabSize::NewSlabSize>(box);
-    if (slab_size_messages.empty()) {
-      return {Parallel::AlgorithmExecution::Retry, std::nullopt};
+    if (not expected_messages_map.empty() and
+        expected_messages_map.begin()->first == slab_number) {
+      const size_t expected_messages = expected_messages_map.begin()->second;
+      ASSERT(expected_messages > 0,
+             "Should only create map entries when sending messages.");
+
+      const auto& slab_size_messages =
+          db::get<::Tags::ChangeSlabSize::NewSlabSize>(box);
+      if (slab_size_messages.empty()) {
+        return {Parallel::AlgorithmExecution::Retry, std::nullopt};
+      }
+      const int64_t first_received_change_slab =
+          slab_size_messages.begin()->first;
+
+      ASSERT(first_received_change_slab >= slab_number,
+             "Received data for a change at slab " << first_received_change_slab
+             << " but it is already slab " << slab_number);
+      if (first_received_change_slab != slab_number) {
+        return {Parallel::AlgorithmExecution::Retry, std::nullopt};
+      }
+
+      const auto& received_changes = slab_size_messages.begin()->second;
+      ASSERT(expected_messages >= received_changes.size(),
+             "Received " << received_changes.size()
+                         << " size change messages at slab " << slab_number
+                         << ", but only expected " << expected_messages);
+      if (received_changes.size() != expected_messages) {
+        return {Parallel::AlgorithmExecution::Retry, std::nullopt};
+      }
+
+      // We have all the data we need.
+
+      step_requests =
+          alg::accumulate(slab_size_messages.begin()->second, step_requests);
+
+      db::mutate<::Tags::ChangeSlabSize::NumberOfExpectedMessages,
+                 ::Tags::ChangeSlabSize::NewSlabSize>(
+          [](const gsl::not_null<std::map<int64_t, size_t>*> expected,
+             const gsl::not_null<
+                 std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                 sizes) {
+            expected->erase(expected->begin());
+            sizes->erase(sizes->begin());
+          },
+          make_not_null(&box));
     }
-    const int64_t first_received_change_slab =
-        slab_size_messages.begin()->first;
-
-    ASSERT(first_received_change_slab >= slab_number,
-           "Received data for a change at slab " << first_received_change_slab
-           << " but it is already slab " << slab_number);
-    if (first_received_change_slab != slab_number) {
-      return {Parallel::AlgorithmExecution::Retry, std::nullopt};
+    const double new_slab_end = step_requests.step_end(
+        time_step_id.step_time().value(),
+        db::get<::Tags::ChangeSlabSize::SlabSizeGoal>(box));
+
+    if (const auto new_goal = step_requests.new_step_size_goal();
+        new_goal.has_value()) {
+      db::mutate<::Tags::ChangeSlabSize::SlabSizeGoal>(
+          [&](const gsl::not_null<double*> slab_size_goal) {
+            *slab_size_goal = *new_goal;
+          },
+          make_not_null(&box));
     }
 
-    const auto& received_changes = slab_size_messages.begin()->second;
-    ASSERT(expected_messages >= received_changes.size(),
-           "Received " << received_changes.size()
-                       << " size change messages at slab "
-                       << slab_number << ", but only expected "
-                       << expected_messages);
-    if (received_changes.size() != expected_messages) {
-      return {Parallel::AlgorithmExecution::Retry, std::nullopt};
-    }
-
-    // We have all the data we need.
-
-    const double new_slab_size =
-        *alg::min_element(slab_size_messages.begin()->second);
-
-    db::mutate<::Tags::ChangeSlabSize::NumberOfExpectedMessages,
-               ::Tags::ChangeSlabSize::NewSlabSize>(
-        [](const gsl::not_null<std::map<int64_t, size_t>*> expected,
-           const gsl::not_null<
-               std::map<int64_t, std::unordered_multiset<double>>*>
-               sizes) {
-          expected->erase(expected->begin());
-          sizes->erase(sizes->begin());
-        },
-        make_not_null(&box));
-
     const TimeStepper& time_stepper =
         db::get<::Tags::TimeStepper<TimeStepper>>(box);
 
     // Sometimes time steppers need to run with a fixed step size.
     // This is generally at the start of an evolution when the history
     // is in an unusual state.
-    if (not time_stepper.can_change_step_size(
+    if (time_stepper.can_change_step_size(
             time_step_id, db::get<::Tags::HistoryEvolvedVariables<>>(box))) {
-      return {Parallel::AlgorithmExecution::Continue, std::nullopt};
+      change_slab_size(make_not_null(&box), new_slab_end);
     }
 
-    const auto current_slab = time_step_id.step_time().slab();
-
-    const double new_slab_end =
-        time_step_id.time_runs_forward()
-            ? current_slab.start().value() + new_slab_size
-            : current_slab.end().value() - new_slab_size;
-
-    change_slab_size(make_not_null(&box), new_slab_end);
-
+    step_requests.error_on_hard_limit(
+        db::get<::Tags::TimeStep>(box).value(),
+        (time_step_id.step_time() + db::get<::Tags::TimeStep>(box)).value());
     return {Parallel::AlgorithmExecution::Continue, std::nullopt};
   }
 };
diff --git a/src/Time/ChangeSlabSize/Event.hpp b/src/Time/ChangeSlabSize/Event.hpp
index 5fa7658fb489..832fb959757f 100644
--- a/src/Time/ChangeSlabSize/Event.hpp
+++ b/src/Time/ChangeSlabSize/Event.hpp
@@ -7,6 +7,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <limits>
+#include <map>
 #include <memory>
 #include <pup.h>
 #include <pup_stl.h>
@@ -14,6 +15,8 @@
 #include <vector>
 
 #include "DataStructures/DataBox/DataBox.hpp"
+#include "Options/Context.hpp"
+#include "Options/ParseError.hpp"
 #include "Options/String.hpp"
 #include "Parallel/GlobalCache.hpp"
 #include "Parallel/Reduction.hpp"
@@ -21,7 +24,10 @@
 #include "Time/ChangeSlabSize/Tags.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Time/TimeStepRequestProcessor.hpp"
 #include "Utilities/Functional.hpp"
+#include "Utilities/PrettyType.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
@@ -40,11 +46,12 @@ struct StoreNewSlabSize {
   static void apply(db::DataBox<DbTags>& box,
                     Parallel::GlobalCache<Metavariables>& /*cache*/,
                     const ArrayIndex& /*array_index*/,
-                    const int64_t slab_number, const double slab_size) {
+                    const int64_t slab_number,
+                    const TimeStepRequestProcessor& requests) {
     db::mutate<::Tags::ChangeSlabSize::NewSlabSize>(
         [&](const gsl::not_null<
-            std::map<int64_t, std::unordered_multiset<double>>*>
-                sizes) { (*sizes)[slab_number].insert(slab_size); },
+            std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                sizes) { (*sizes)[slab_number].emplace_back(requests); },
         make_not_null(&box));
   }
 };
@@ -67,7 +74,7 @@ struct StoreNewSlabSize {
 class ChangeSlabSize : public Event {
   using ReductionData = Parallel::ReductionData<
       Parallel::ReductionDatum<int64_t, funcl::AssertEqual<>>,
-      Parallel::ReductionDatum<double, funcl::Min<>>>;
+      Parallel::ReductionDatum<TimeStepRequestProcessor, funcl::Plus<>>>;
 
  public:
   /// \cond
@@ -97,8 +104,21 @@ class ChangeSlabSize : public Event {
   ChangeSlabSize() = default;
   ChangeSlabSize(std::vector<std::unique_ptr<StepChooser<StepChooserUse::Slab>>>
                      step_choosers,
-                 const uint64_t delay_change)
-      : step_choosers_(std::move(step_choosers)), delay_change_(delay_change) {}
+                 const uint64_t delay_change, const Options::Context& context)
+      : step_choosers_(std::move(step_choosers)), delay_change_(delay_change) {
+    if (delay_change != 0) {
+      for (const auto& chooser : step_choosers_) {
+        if (not chooser->can_be_delayed()) {
+          // The runtime name might not be exactly the same as the one
+          // used by the factory, but hopefully it's close enough that
+          // the user can figure it out.
+          PARSE_ERROR(context,
+                      "The " << pretty_type::get_runtime_type_name(*chooser)
+                      << " StepChooser cannot be applied with a delay.");
+        }
+      }
+    }
+  }
 
   using compute_tags_for_observation_box = tmpl::list<>;
 
@@ -121,16 +141,15 @@ class ChangeSlabSize : public Event {
                                          : time_step_id.slab_number() + 1;
     const auto slab_to_change =
         next_changable_slab + static_cast<int64_t>(delay_change_);
+    const auto slab_start = time_step_id.step_time();
+    const auto current_slab_size = (time_step_id.time_runs_forward() ? 1 : -1) *
+                                   slab_start.slab().duration();
 
-    double desired_slab_size = std::numeric_limits<double>::infinity();
+    TimeStepRequestProcessor step_requests(time_step_id.time_runs_forward());
     bool synchronization_required = false;
     for (const auto& step_chooser : step_choosers_) {
-      desired_slab_size = std::min(
-          desired_slab_size,
-          step_chooser
-              ->desired_step(time_step_id.step_time().slab().duration().value(),
-                             *box)
-              .first);
+      step_requests.process(
+          step_chooser->desired_step(current_slab_size.value(), *box).first);
       // We must synchronize if any step chooser requires it, not just
       // the limiting one, because choosers requiring synchronization
       // can be limiting on some processors and not others.
@@ -151,15 +170,13 @@ class ChangeSlabSize : public Event {
     if (synchronization_required) {
       Parallel::contribute_to_reduction<
           ChangeSlabSize_detail::StoreNewSlabSize>(
-          ReductionData(slab_to_change, desired_slab_size), self_proxy,
+          ReductionData(slab_to_change, step_requests), self_proxy,
           component_proxy);
     } else {
       db::mutate<::Tags::ChangeSlabSize::NewSlabSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
-                  sizes) {
-            (*sizes)[slab_to_change].insert(desired_slab_size);
-          },
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                  sizes) { (*sizes)[slab_to_change].push_back(step_requests); },
           box);
     }
   }
diff --git a/src/Time/ChangeSlabSize/Tags.hpp b/src/Time/ChangeSlabSize/Tags.hpp
index aed2107ef59f..95cd157e543b 100644
--- a/src/Time/ChangeSlabSize/Tags.hpp
+++ b/src/Time/ChangeSlabSize/Tags.hpp
@@ -6,18 +6,25 @@
 #include <cstddef>
 #include <cstdint>
 #include <map>
-#include <unordered_set>
+#include <vector>
 
 #include "DataStructures/DataBox/Tag.hpp"
+#include "Time/TimeStepRequestProcessor.hpp"
 
 namespace Tags::ChangeSlabSize {
 /// Sizes requested for each slab by ChangeSlabSize events.
 struct NewSlabSize : db::SimpleTag {
-  using type = std::map<int64_t, std::unordered_multiset<double>>;
+  using type = std::map<int64_t, std::vector<TimeStepRequestProcessor>>;
 };
 
 /// Number of ChangeSlabSize events changing the size at each slab.
 struct NumberOfExpectedMessages : db::SimpleTag {
   using type = std::map<int64_t, size_t>;
 };
+
+/// Long-term desired slab size.  Used as the default size if nothing
+/// chooses a smaller one.
+struct SlabSizeGoal : db::SimpleTag {
+  using type = double;
+};
 }  // namespace Tags::ChangeSlabSize
diff --git a/src/Time/StepChoosers/ByBlock.hpp b/src/Time/StepChoosers/ByBlock.hpp
index e539445ee1f1..11c14aa3f066 100644
--- a/src/Time/StepChoosers/ByBlock.hpp
+++ b/src/Time/StepChoosers/ByBlock.hpp
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cmath>
 #include <cstddef>
 #include <pup.h>
 #include <pup_stl.h>  // IWYU pragma: keep
@@ -10,7 +11,8 @@
 #include <vector>
 
 #include "Options/String.hpp"
-#include "Time/StepChoosers/StepChooser.hpp"  // IWYU pragma: keep
+#include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ErrorHandling/Error.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
@@ -27,7 +29,7 @@ struct Element;
 /// \endcond
 
 namespace StepChoosers {
-/// Suggests specified step sizes in each block
+/// Sets a goal specified per-block.
 template <typename StepChooserUse, size_t Dim>
 class ByBlock : public StepChooser<StepChooserUse> {
  public:
@@ -44,25 +46,24 @@ class ByBlock : public StepChooser<StepChooserUse> {
         "Step sizes, indexed by block number"};
   };
 
-  static constexpr Options::String help{
-      "Suggests specified step sizes in each block"};
+  static constexpr Options::String help{"Sets a goal specified per-block."};
   using options = tmpl::list<Sizes>;
 
   explicit ByBlock(std::vector<double> sizes) : sizes_(std::move(sizes)) {}
 
   using argument_tags = tmpl::list<domain::Tags::Element<Dim>>;
 
-  std::pair<double, bool> operator()(
-      const Element<Dim>& element,
-      const double /*last_step_magnitude*/) const {
+  std::pair<TimeStepRequest, bool> operator()(const Element<Dim>& element,
+                                              const double last_step) const {
     const size_t block = element.id().block_id();
     if (block >= sizes_.size()) {
       ERROR("Step size not specified for block " << block);
     }
-    return std::make_pair(sizes_[block], true);
+    return {{.size_goal = std::copysign(sizes_[block], last_step)}, true};
   }
 
   bool uses_local_data() const override { return true; }
+  bool can_be_delayed() const override { return true; }
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override { p | sizes_; }
diff --git a/src/Time/StepChoosers/CMakeLists.txt b/src/Time/StepChoosers/CMakeLists.txt
index 14281b061449..9558c65cbb9c 100644
--- a/src/Time/StepChoosers/CMakeLists.txt
+++ b/src/Time/StepChoosers/CMakeLists.txt
@@ -5,6 +5,7 @@ spectre_target_sources(
   ${LIBRARY}
   PRIVATE
   Constant.cpp
+  Maximum.cpp
   Random.cpp
   StepToTimes.cpp
   )
@@ -19,7 +20,8 @@ spectre_target_headers(
   ElementSizeCfl.hpp
   ErrorControl.hpp
   Factory.hpp
-  Increase.hpp
+  LimitIncrease.hpp
+  Maximum.hpp
   PreventRapidIncrease.hpp
   Random.hpp
   StepChooser.hpp
diff --git a/src/Time/StepChoosers/Cfl.hpp b/src/Time/StepChoosers/Cfl.hpp
index 6c77b1e46114..40a0e1a44254 100644
--- a/src/Time/StepChoosers/Cfl.hpp
+++ b/src/Time/StepChoosers/Cfl.hpp
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cmath>
 #include <cstddef>
 #include <limits>
 #include <pup.h>
@@ -11,7 +12,8 @@
 #include "DataStructures/DataBox/DataBox.hpp"
 #include "Domain/MinimumGridSpacing.hpp"
 #include "Options/String.hpp"
-#include "Time/StepChoosers/StepChooser.hpp"  // IWYU pragma: keep
+#include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/TimeSteppers/TimeStepper.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
@@ -31,7 +33,7 @@ struct MinimumGridSpacing;
 /// \endcond
 
 namespace StepChoosers {
-/// Suggests a step size based on the CFL stability criterion.
+/// Sets a goal based on the CFL stability criterion.
 template <typename StepChooserUse, typename Frame, typename System>
 class Cfl : public StepChooser<StepChooserUse> {
  public:
@@ -49,7 +51,7 @@ class Cfl : public StepChooser<StepChooserUse> {
   };
 
   static constexpr Options::String help{
-      "Suggests a step size based on the CFL stability criterion."};
+      "Sets a goal based on the CFL stability criterion."};
   using options = tmpl::list<SafetyFactor>;
 
   explicit Cfl(const double safety_factor) : safety_factor_(safety_factor) {}
@@ -63,19 +65,21 @@ class Cfl : public StepChooser<StepChooserUse> {
       domain::Tags::MinimumGridSpacingCompute<System::volume_dim, Frame>,
       typename System::compute_largest_characteristic_speed>;
 
-  std::pair<double, bool> operator()(
-      const double minimum_grid_spacing,
-      const TimeStepper& time_stepper,
-      const double speed, const double last_step_magnitude) const {
+  std::pair<TimeStepRequest, bool> operator()(const double minimum_grid_spacing,
+                                              const TimeStepper& time_stepper,
+                                              const double speed,
+                                              const double last_step) const {
     const double time_stepper_stability_factor = time_stepper.stable_step();
     const double step_size = safety_factor_ * time_stepper_stability_factor *
                              minimum_grid_spacing /
                              (speed * System::volume_dim);
     // Reject the step if the CFL condition is violated.
-    return std::make_pair(step_size, last_step_magnitude <= step_size);
+    return {{.size_goal = std::copysign(step_size, last_step)},
+            abs(last_step) <= step_size};
   }
 
   bool uses_local_data() const override { return true; }
+  bool can_be_delayed() const override { return true; }
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override { p | safety_factor_; }
diff --git a/src/Time/StepChoosers/Constant.cpp b/src/Time/StepChoosers/Constant.cpp
index 9b63ebe6da3f..2e9587cd8829 100644
--- a/src/Time/StepChoosers/Constant.cpp
+++ b/src/Time/StepChoosers/Constant.cpp
@@ -10,12 +10,7 @@ namespace Constant_detail {
 // This function lets us avoid including ParseOptions.hpp in the
 // header.
 double parse_options(const Options::Option& options) {
-  const auto value = options.parse_as<double>();
-  if (value <= 0.) {
-    PARSE_ERROR(options.context(),
-                "Requested step magnitude should be positive.");
-  }
-  return value;
+  return options.parse_as<double>();
 }
 }  // namespace Constant_detail
 }  // namespace StepChoosers
diff --git a/src/Time/StepChoosers/Constant.hpp b/src/Time/StepChoosers/Constant.hpp
index fe6b6977b499..73cd0e22a099 100644
--- a/src/Time/StepChoosers/Constant.hpp
+++ b/src/Time/StepChoosers/Constant.hpp
@@ -3,20 +3,21 @@
 
 #pragma once
 
+#include <cmath>
 #include <limits>
 #include <pup.h>
 #include <utility>
 
 #include "Options/Options.hpp"
 #include "Options/String.hpp"
-#include "Time/StepChoosers/StepChooser.hpp"  // IWYU pragma: keep
-#include "Utilities/ErrorHandling/Assert.hpp"
+#include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
 namespace StepChoosers {
 
-/// Suggests a constant step size.
+/// Sets a constant goal.
 template <typename StepChooserUse>
 class Constant : public StepChooser<StepChooserUse> {
  public:
@@ -27,20 +28,18 @@ class Constant : public StepChooser<StepChooserUse> {
   WRAPPED_PUPable_decl_template(Constant);  // NOLINT
   /// \endcond
 
-  static constexpr Options::String help{"Suggests a constant step size."};
+  static constexpr Options::String help{"Sets a constant goal."};
 
-  explicit Constant(const double value) : value_(value) {
-    ASSERT(value_ > 0., "Requested step magnitude should be positive.");
-  }
+  explicit Constant(const double value) : value_(value) {}
 
   using argument_tags = tmpl::list<>;
 
-  std::pair<double, bool> operator()(
-      const double /*last_step_magnitude*/) const {
-    return std::make_pair(value_, true);
+  std::pair<TimeStepRequest, bool> operator()(const double last_step) const {
+    return {{.size_goal = std::copysign(value_, last_step)}, true};
   }
 
   bool uses_local_data() const override { return false; }
+  bool can_be_delayed() const override { return true; }
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override { p | value_; }
diff --git a/src/Time/StepChoosers/ElementSizeCfl.hpp b/src/Time/StepChoosers/ElementSizeCfl.hpp
index ef78d3263500..d70ab4d8c143 100644
--- a/src/Time/StepChoosers/ElementSizeCfl.hpp
+++ b/src/Time/StepChoosers/ElementSizeCfl.hpp
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cmath>
 #include <cstddef>
 #include <limits>
 #include <pup.h>
@@ -12,6 +13,7 @@
 #include "Domain/SizeOfElement.hpp"
 #include "Options/String.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/TimeSteppers/TimeStepper.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
@@ -31,7 +33,7 @@ struct SizeOfElement;
 /// \endcond
 
 namespace StepChoosers {
-/// Suggests a step size based on the CFL stability criterion, but uses the full
+/// Sets a goal based on the CFL stability criterion, but uses the full
 /// size of the element as the length scale in question.
 ///
 /// This is useful as a coarse estimate for slabs, or to place a ceiling on
@@ -53,7 +55,7 @@ class ElementSizeCfl : public StepChooser<StepChooserUse> {
   };
 
   static constexpr Options::String help{
-      "Suggests a step size based on the CFL stability criterion, but in which "
+      "Sets a goal based on the CFL stability criterion, but in which "
       "the entire size of the element is used as the spacing in the "
       "computation. This is useful primarily for placing a ceiling on another "
       "dynamically-adjusted step chooser"};
@@ -70,10 +72,10 @@ class ElementSizeCfl : public StepChooser<StepChooserUse> {
       tmpl::list<domain::Tags::SizeOfElementCompute<Dim>,
                  typename System::compute_largest_characteristic_speed>;
 
-  std::pair<double, bool> operator()(
+  std::pair<TimeStepRequest, bool> operator()(
       const TimeStepper& time_stepper,
       const std::array<double, Dim>& element_size, const double speed,
-      const double last_step_magnitude) const {
+      const double last_step) const {
     double min_size_of_element = std::numeric_limits<double>::infinity();
     for (auto face_to_face_dimension : element_size) {
       if (face_to_face_dimension < min_size_of_element) {
@@ -84,10 +86,12 @@ class ElementSizeCfl : public StepChooser<StepChooserUse> {
     const double step_size = safety_factor_ * time_stepper_stability_factor *
                              min_size_of_element / (speed * Dim);
     // Reject the step if the CFL condition is violated.
-    return std::make_pair(step_size, last_step_magnitude <= step_size);
+    return {{.size_goal = std::copysign(step_size, last_step)},
+            abs(last_step) <= step_size};
   }
 
   bool uses_local_data() const override { return true; }
+  bool can_be_delayed() const override { return true; }
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override { p | safety_factor_; }
diff --git a/src/Time/StepChoosers/ErrorControl.hpp b/src/Time/StepChoosers/ErrorControl.hpp
index 3718fef7d61c..be7c7f7e80f3 100644
--- a/src/Time/StepChoosers/ErrorControl.hpp
+++ b/src/Time/StepChoosers/ErrorControl.hpp
@@ -23,6 +23,7 @@
 #include "Time/Tags/IsUsingTimeSteppingErrorControl.hpp"
 #include "Time/Tags/StepperErrorTolerances.hpp"
 #include "Time/Tags/StepperErrors.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ErrorHandling/Assert.hpp"
 #include "Utilities/Gsl.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
@@ -54,8 +55,7 @@ struct ErrorControlBase : IsAnErrorControl {
 }  // namespace ErrorControl_detail
 
 /*!
- * \brief Suggests a step size based on a target absolute and/or relative error
- * measure.
+ * \brief Sets a goal based on time-stepper truncation error.
  *
  * \details The suggested step is calculated via a simple specialization of the
  * scheme suggested in \cite Hairer1993. We first compute the aggregated error
@@ -175,7 +175,7 @@ class ErrorControl
   };
 
   static constexpr Options::String help{
-      "Chooses a step based on a target relative and absolute error tolerance"};
+      "Sets a goal based on time-stepper truncation error."};
   using options = tmpl::list<AbsoluteTolerance, RelativeTolerance, MaxFactor,
                              MinFactor, SafetyFactor>;
 
@@ -199,16 +199,16 @@ class ErrorControl
 
   using argument_tags = tmpl::list<::Tags::StepperErrors<EvolvedVariableTag>>;
 
-  std::pair<double, bool> operator()(
+  std::pair<TimeStepRequest, bool> operator()(
       const typename ::Tags::StepperErrors<EvolvedVariableTag>::type& errors,
       const double previous_step) const {
-    // request that the step size not be changed if there isn't a new error
+    // Do not request that the step size be changed if there isn't a new error
     // estimate
     if (not errors[1].has_value()) {
-      return std::make_pair(std::numeric_limits<double>::infinity(), true);
+      return {{}, true};
     }
     double new_step;
-    if (not errors[0].has_value()) {
+    if (not errors[0].has_value() or errors[0]->order != errors[1]->order) {
       new_step = errors[1]->step_size.value() *
                  std::clamp(safety_factor_ *
                                 pow(1.0 / std::max(errors[1]->error, 1e-14),
@@ -217,9 +217,6 @@ class ErrorControl
     } else {
       // From simple advice from Numerical Recipes 17.2.1 regarding a heuristic
       // for PI step control.
-      ASSERT(errors[0]->order == errors[1]->order,
-             "Error estimates are different orders.  Need to figure our what "
-             "to do in this case.");
       const double alpha_factor = 0.7 / (errors[1]->order + 1);
       const double beta_factor = 0.4 / (errors[0]->order + 1);
       new_step =
@@ -233,11 +230,12 @@ class ErrorControl
     // If the error is out-of-date we can still reject a step, but it
     // won't improve the reported error, so make sure to only do it
     // if we actually request a smaller step.
-    return {abs(new_step),
-            abs(new_step) >= previous_step or errors[1]->error <= 1.0};
+    return {{.size_goal = new_step},
+            abs(new_step) >= abs(previous_step) or errors[1]->error <= 1.0};
   }
 
   bool uses_local_data() const override { return true; }
+  bool can_be_delayed() const override { return true; }
 
   StepperErrorTolerances tolerances() const override {
     return {.absolute = absolute_tolerance_, .relative = relative_tolerance_};
diff --git a/src/Time/StepChoosers/Factory.hpp b/src/Time/StepChoosers/Factory.hpp
index ac5edcf1f314..25e2b979ef9a 100644
--- a/src/Time/StepChoosers/Factory.hpp
+++ b/src/Time/StepChoosers/Factory.hpp
@@ -9,7 +9,8 @@
 #include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/ElementSizeCfl.hpp"
 #include "Time/StepChoosers/ErrorControl.hpp"
-#include "Time/StepChoosers/Increase.hpp"
+#include "Time/StepChoosers/LimitIncrease.hpp"
+#include "Time/StepChoosers/Maximum.hpp"
 #include "Time/StepChoosers/PreventRapidIncrease.hpp"
 #include "Time/StepChoosers/StepToTimes.hpp"
 #include "Utilities/TMPL.hpp"
@@ -30,7 +31,8 @@ using common_step_choosers = tmpl::push_back<
             StepChoosers::Cfl<Use, Frame::Inertial, System>,
             StepChoosers::ElementSizeCfl<Use, System::volume_dim, System>>,
         tmpl::list<>>,
-    StepChoosers::Constant<Use>, StepChoosers::Increase<Use>>;
+    StepChoosers::Constant<Use>, StepChoosers::LimitIncrease<Use>,
+    StepChoosers::Maximum<Use>>;
 template <typename Use, typename System>
 using step_choosers_for_step_only =
     tmpl::list<StepChoosers::PreventRapidIncrease<Use>,
diff --git a/src/Time/StepChoosers/Increase.hpp b/src/Time/StepChoosers/LimitIncrease.hpp
similarity index 52%
rename from src/Time/StepChoosers/Increase.hpp
rename to src/Time/StepChoosers/LimitIncrease.hpp
index 3ec1b4e8e6d5..8c7776f77ea7 100644
--- a/src/Time/StepChoosers/Increase.hpp
+++ b/src/Time/StepChoosers/LimitIncrease.hpp
@@ -9,40 +9,43 @@
 #include <utility>
 
 #include "Options/String.hpp"
-#include "Time/StepChoosers/StepChooser.hpp"  // IWYU pragma: keep
+#include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
 namespace StepChoosers {
-/// Suggests increasing the step size by a constant ratio.
+/// Limits step increase to a constant ratio.
 template <typename StepChooserUse>
-class Increase : public StepChooser<StepChooserUse> {
+class LimitIncrease : public StepChooser<StepChooserUse> {
  public:
   /// \cond
-  Increase() = default;
-  explicit Increase(CkMigrateMessage* /*unused*/) {}
+  LimitIncrease() = default;
+  explicit LimitIncrease(CkMigrateMessage* /*unused*/) {}
   using PUP::able::register_constructor;
-  WRAPPED_PUPable_decl_template(Increase);  // NOLINT
+  WRAPPED_PUPable_decl_template(LimitIncrease);  // NOLINT
   /// \endcond
 
   struct Factor {
     using type = double;
-    static constexpr Options::String help{"Factor to increase by"};
+    static constexpr Options::String help{"Factor to allow increase by"};
     static type lower_bound() { return 1.0; }
   };
 
-  static constexpr Options::String help{"Suggests a constant factor increase."};
+  static constexpr Options::String help{
+      "Limits step increase to a constant ratio."};
   using options = tmpl::list<Factor>;
 
-  explicit Increase(const double factor) : factor_(factor) {}
+  explicit LimitIncrease(const double factor) : factor_(factor) {}
 
   using argument_tags = tmpl::list<>;
 
-  std::pair<double, bool> operator()(const double last_step_magnitude) const {
-    return std::make_pair(last_step_magnitude * factor_, true);
+  std::pair<TimeStepRequest, bool> operator()(const double last_step) const {
+    return {{.size = last_step * factor_}, true};
   }
 
   bool uses_local_data() const override { return false; }
+  bool can_be_delayed() const override { return true; }
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override { p | factor_; }
@@ -53,6 +56,6 @@ class Increase : public StepChooser<StepChooserUse> {
 
 /// \cond
 template <typename StepChooserUse>
-PUP::able::PUP_ID Increase<StepChooserUse>::my_PUP_ID = 0;  // NOLINT
+PUP::able::PUP_ID LimitIncrease<StepChooserUse>::my_PUP_ID = 0;  // NOLINT
 /// \endcond
 }  // namespace StepChoosers
diff --git a/src/Time/StepChoosers/Maximum.cpp b/src/Time/StepChoosers/Maximum.cpp
new file mode 100644
index 000000000000..e799bb8c6a6c
--- /dev/null
+++ b/src/Time/StepChoosers/Maximum.cpp
@@ -0,0 +1,14 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Time/StepChoosers/Maximum.hpp"
+
+#include "Options/ParseOptions.hpp"
+
+namespace StepChoosers::Maximum_detail {
+// This function lets us avoid including ParseOptions.hpp in the
+// header.
+double parse_options(const Options::Option& options) {
+  return options.parse_as<double>();
+}
+}  // namespace StepChoosers::Maximum_detail
diff --git a/src/Time/StepChoosers/Maximum.hpp b/src/Time/StepChoosers/Maximum.hpp
new file mode 100644
index 000000000000..ee63bf131bc0
--- /dev/null
+++ b/src/Time/StepChoosers/Maximum.hpp
@@ -0,0 +1,69 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#pragma once
+
+#include <cmath>
+#include <limits>
+#include <pup.h>
+#include <utility>
+
+#include "Options/Options.hpp"
+#include "Options/String.hpp"
+#include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Utilities/Serialization/CharmPupable.hpp"
+#include "Utilities/TMPL.hpp"
+
+namespace StepChoosers {
+
+/// Limits the step size to a constant.
+template <typename StepChooserUse>
+class Maximum : public StepChooser<StepChooserUse> {
+ public:
+  /// \cond
+  Maximum() = default;
+  explicit Maximum(CkMigrateMessage* /*unused*/) {}
+  using PUP::able::register_constructor;
+  WRAPPED_PUPable_decl_template(Maximum);  // NOLINT
+  /// \endcond
+
+  static constexpr Options::String help{"Limits the step size to a constant."};
+
+  explicit Maximum(const double value) : value_(value) {}
+
+  using argument_tags = tmpl::list<>;
+
+  std::pair<TimeStepRequest, bool> operator()(const double last_step) const {
+    return {{.size = std::copysign(value_, last_step)}, true};
+  }
+
+  bool uses_local_data() const override { return false; }
+  bool can_be_delayed() const override { return true; }
+
+  // NOLINTNEXTLINE(google-runtime-references)
+  void pup(PUP::er& p) override { p | value_; }
+
+ private:
+  double value_ = std::numeric_limits<double>::signaling_NaN();
+};
+
+/// \cond
+template <typename StepChooserUse>
+PUP::able::PUP_ID Maximum<StepChooserUse>::my_PUP_ID = 0;  // NOLINT
+/// \endcond
+
+namespace Maximum_detail {
+double parse_options(const Options::Option& options);
+}  // namespace Maximum_detail
+}  // namespace StepChoosers
+
+template <typename StepChooserUse>
+struct Options::create_from_yaml<StepChoosers::Maximum<StepChooserUse>> {
+  template <typename Metavariables>
+  static StepChoosers::Maximum<StepChooserUse> create(
+      const Options::Option& options) {
+    return StepChoosers::Maximum<StepChooserUse>(
+        StepChoosers::Maximum_detail::parse_options(options));
+  }
+};
diff --git a/src/Time/StepChoosers/PreventRapidIncrease.hpp b/src/Time/StepChoosers/PreventRapidIncrease.hpp
index 86c8fb28b9f7..824f8670a558 100644
--- a/src/Time/StepChoosers/PreventRapidIncrease.hpp
+++ b/src/Time/StepChoosers/PreventRapidIncrease.hpp
@@ -4,23 +4,25 @@
 #pragma once
 
 #include <cmath>  // IWYU pragma: keep  // for abs
-#include <limits>
 #include <pup.h>
 #include <utility>
 
 #include "Options/String.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"  // IWYU pragma: keep
 #include "Time/Tags/HistoryEvolvedVariables.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/Utilities.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
 namespace StepChoosers {
+/// Limits the time step to prevent multistep integrator instabilities.
+///
 /// Avoids instabilities due to rapid increases in the step size by
-/// preventing the step size from increasing unless all steps in the
-/// time-stepper history are the same size.  If there have been recent
-/// step size changes the new size bound is the size of the most
-/// recent step, otherwise it is infinite (no restriction is imposed).
+/// preventing the step size from increasing if any step in the
+/// time-stepper history increased.  If there have been recent step
+/// size increases, the new size bound is the size of the most recent
+/// step, otherwise no restriction is imposed.
 template <typename StepChooserUse>
 class PreventRapidIncrease : public StepChooser<StepChooserUse> {
  public:
@@ -32,40 +34,40 @@ class PreventRapidIncrease : public StepChooser<StepChooserUse> {
   /// \endcond
 
   static constexpr Options::String help{
-      "Prevents rapid increases in time step that can cause integrator \n"
-      "instabilities."};
+      "Limits the time step to prevent multistep integrator instabilities."};
   using options = tmpl::list<>;
 
   using argument_tags = tmpl::list<::Tags::HistoryEvolvedVariables<>>;
 
   template <typename History>
-  std::pair<double, bool> operator()(const History& history,
-                                     const double last_step_magnitude) const {
+  std::pair<TimeStepRequest, bool> operator()(const History& history,
+                                              const double last_step) const {
     if (history.size() < 2) {
-      return std::make_pair(std::numeric_limits<double>::infinity(), true);
+      return {{}, true};
     }
 
     const double sloppiness =
         slab_rounding_error(history.front().time_step_id.step_time());
     std::optional<Time> previous_time{};
-    for (const auto& record : history) {
-      const Time time = record.time_step_id.step_time();
+    double newer_step = abs(last_step);
+    for (auto record = history.rbegin(); record != history.rend(); ++record) {
+      const Time time = record->time_step_id.step_time();
       if (previous_time.has_value()) {
+        const double this_step = abs(*previous_time - time).value();
         // Potential roundoff error comes from the inability to make
         // slabs exactly the same length.
-        if (abs(abs(*previous_time - time).value() - last_step_magnitude) >
-            sloppiness) {
-          return std::make_pair(last_step_magnitude, true);
+        if (this_step < newer_step - sloppiness) {
+          return {{.size = last_step}, true};
         }
+        newer_step = this_step;
       }
       previous_time.emplace(time);
     }
-    // Request that the step size be at most infinity.  This imposes
-    // no restriction on the chosen step.
-    return std::make_pair(std::numeric_limits<double>::infinity(), true);
+    return {{}, true};
   }
 
   bool uses_local_data() const override { return false; }
+  bool can_be_delayed() const override { return true; }
 };
 
 /// \cond
diff --git a/src/Time/StepChoosers/Random.cpp b/src/Time/StepChoosers/Random.cpp
index bf168d305a5d..b3d17b716c08 100644
--- a/src/Time/StepChoosers/Random.cpp
+++ b/src/Time/StepChoosers/Random.cpp
@@ -15,6 +15,7 @@
 #include "Options/ParseError.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/GenerateInstantiations.hpp"
 
 namespace StepChoosers {
@@ -37,9 +38,9 @@ Random<StepChooserUse, VolumeDim>::Random(const double minimum,
 }
 
 template <typename StepChooserUse, size_t VolumeDim>
-std::pair<double, bool> Random<StepChooserUse, VolumeDim>::operator()(
+std::pair<TimeStepRequest, bool> Random<StepChooserUse, VolumeDim>::operator()(
     const Element<VolumeDim>& element, const TimeStepId& time_step_id,
-    const double /*last_step_magnitude*/) const {
+    const double last_step) const {
   size_t local_seed = seed_;
   boost::hash_combine(local_seed, element.id());
   boost::hash_combine(local_seed, time_step_id);
@@ -49,7 +50,7 @@ std::pair<double, bool> Random<StepChooserUse, VolumeDim>::operator()(
     const double step = exp(dist(rng));
     // Don't produce out-of-range values because of roundoff.
     if (step >= minimum_ and step <= maximum_) {
-      return {step, true};
+      return {{.size_goal = std::copysign(step, last_step)}, true};
     }
   }
 }
@@ -59,6 +60,11 @@ bool Random<StepChooserUse, VolumeDim>::uses_local_data() const {
   return true;
 }
 
+template <typename StepChooserUse, size_t VolumeDim>
+bool Random<StepChooserUse, VolumeDim>::can_be_delayed() const {
+  return true;
+}
+
 template <typename StepChooserUse, size_t VolumeDim>
 void Random<StepChooserUse, VolumeDim>::pup(PUP::er& p) {
   p | minimum_;
diff --git a/src/Time/StepChoosers/Random.hpp b/src/Time/StepChoosers/Random.hpp
index 99b1ccbde5bb..87f86c0ee587 100644
--- a/src/Time/StepChoosers/Random.hpp
+++ b/src/Time/StepChoosers/Random.hpp
@@ -11,6 +11,7 @@
 #include "Options/Context.hpp"
 #include "Options/String.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
@@ -67,11 +68,12 @@ class Random : public StepChooser<StepChooserUse> {
   using argument_tags =
       tmpl::list<domain::Tags::Element<VolumeDim>, Tags::TimeStepId>;
 
-  std::pair<double, bool> operator()(const Element<VolumeDim>& element,
-                                     const TimeStepId& time_step_id,
-                                     double last_step_magnitude) const;
+  std::pair<TimeStepRequest, bool> operator()(const Element<VolumeDim>& element,
+                                              const TimeStepId& time_step_id,
+                                              double last_step) const;
 
   bool uses_local_data() const override;
+  bool can_be_delayed() const override;
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override;
diff --git a/src/Time/StepChoosers/StepChooser.hpp b/src/Time/StepChoosers/StepChooser.hpp
index c1058599ada6..e110465ff194 100644
--- a/src/Time/StepChoosers/StepChooser.hpp
+++ b/src/Time/StepChoosers/StepChooser.hpp
@@ -7,6 +7,7 @@
 
 #include "DataStructures/DataBox/DataBox.hpp"
 #include "Parallel/Tags/Metavariables.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/CallWithDynamicType.hpp"
 #include "Utilities/ErrorHandling/Assert.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
@@ -67,12 +68,13 @@ struct AllStepChoosers {};
 
 /// \ingroup TimeGroup
 ///
-/// \brief StepChoosers suggest upper bounds on step sizes.
+/// \brief StepChoosers suggest upper bounds on step sizes.  See
+/// `TimeStepRequest` for details on how the results are used.
 ///
 /// Concrete StepChoosers should define `operator()` returning the
 /// information described as the return type of `desired_step` and
-/// taking the `last_step_magnitude` and arguments specified by the
-/// class's `argument_tags` type alias.
+/// taking the `last_step` and arguments specified by the class's
+/// `argument_tags` type alias.
 ///
 /// Derived classes must indicate whether the chooser is usable as a
 /// step chooser, slab chooser, or both by inheriting from StepChooser
@@ -100,11 +102,17 @@ class StepChooser : public PUP::able {
   /// domain.  This is ignored for LTS step changing.
   ///
   /// \note As this is only used for slab-size changing, the
-  /// `last_step_magnitude` passed to the call operator is *not*
-  /// considered local data.
+  /// `last_step` passed to the call operator is *not* considered
+  /// local data.
   virtual bool uses_local_data() const = 0;
 
-  /// The `last_step_magnitude` parameter describes the step size to be
+  /// Whether the result can be applied with a delay.
+  ///
+  /// StepChoosers setting the `.end` or `.end_hard_limit` fields of
+  /// `TimeStepRequest` must return false here.
+  virtual bool can_be_delayed() const = 0;
+
+  /// The `last_step` parameter describes the step size to be
   /// adjusted.  It may be the step size or the slab size, or may be
   /// infinite if the appropriate size cannot be determined.
   ///
@@ -118,8 +126,8 @@ class StepChooser : public PUP::able {
   ///
   /// The implementations of the call operator in derived classes
   /// should always return a strictly smaller step than the
-  /// `last_step_magnitude` when they return `false` for the second
-  /// member of the pair (indicating step rejection).
+  /// `last_step` when they return `false` for the second member of
+  /// the pair (indicating step rejection).
   ///
   /// The optional template parameter `StepChoosersToUse` may be used to
   /// indicate a subset of the constructable step choosers to use for the
@@ -128,10 +136,8 @@ class StepChooser : public PUP::able {
   /// option is used when multiple components need to invoke `ChangeStepSize`
   /// with step choosers that may not be compatible with all components.
   template <typename StepChoosersToUse = AllStepChoosers, typename DbTags>
-  std::pair<double, bool> desired_step(const double last_step_magnitude,
-                                       const db::DataBox<DbTags>& box) const {
-    ASSERT(last_step_magnitude > 0.,
-           "Passed non-positive step magnitude: " << last_step_magnitude);
+  std::pair<TimeStepRequest, bool> desired_step(
+      const double last_step, const db::DataBox<DbTags>& box) const {
     using factory_classes =
         typename std::decay_t<decltype(db::get<Parallel::Tags::Metavariables>(
             box))>::factory_creation::factory_classes;
@@ -140,13 +146,23 @@ class StepChooser : public PUP::able {
                             tmpl::at<factory_classes, StepChooser>,
                             StepChoosersToUse>;
     const auto result =
-        call_with_dynamic_type<std::pair<double, bool>, step_choosers>(
-            this, [&last_step_magnitude, &box](const auto* const chooser) {
-              return db::apply(*chooser, box, last_step_magnitude);
+        call_with_dynamic_type<std::pair<TimeStepRequest, bool>, step_choosers>(
+            this, [&last_step, &box](const auto* const chooser) {
+              return db::apply(*chooser, box, last_step);
             });
-    ASSERT(
-        result.first > 0.,
-        "StepChoosers should always return positive values.  Got " << result);
+    ASSERT(not result.first.size_goal.has_value() or
+               (*result.first.size_goal > 0.) == (last_step > 0.),
+           "Step size changed sign: " << *result.first.size_goal);
+    ASSERT(not result.first.size.has_value() or
+               (*result.first.size > 0.) == (last_step > 0.),
+           "Step size changed sign: " << *result.first.size);
+    ASSERT(not result.first.size_hard_limit.has_value() or
+               (*result.first.size_hard_limit > 0.) == (last_step > 0.),
+           "Step size changed sign: " << *result.first.size_hard_limit);
+    ASSERT(not(result.first.end.has_value() and can_be_delayed()),
+           "Delayable end limits are not allowed.");
+    ASSERT(not(result.first.end_hard_limit.has_value() and can_be_delayed()),
+           "Delayable end limits are not allowed.");
     return result;
   }
 };
diff --git a/src/Time/StepChoosers/StepToTimes.cpp b/src/Time/StepChoosers/StepToTimes.cpp
index 33b6142a5dee..c40149e7eaef 100644
--- a/src/Time/StepChoosers/StepToTimes.cpp
+++ b/src/Time/StepChoosers/StepToTimes.cpp
@@ -5,6 +5,7 @@
 
 namespace StepChoosers {
 bool StepToTimes::uses_local_data() const { return false; }
+bool StepToTimes::can_be_delayed() const { return false; }
 
 PUP::able::PUP_ID StepToTimes::my_PUP_ID = 0;  // NOLINT
 }  // namespace StepChoosers
diff --git a/src/Time/StepChoosers/StepToTimes.hpp b/src/Time/StepChoosers/StepToTimes.hpp
index 058151d779fb..8c5c44a8f9f3 100644
--- a/src/Time/StepChoosers/StepToTimes.hpp
+++ b/src/Time/StepChoosers/StepToTimes.hpp
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cmath>
 #include <limits>
 #include <memory>
 #include <pup.h>
@@ -10,16 +11,18 @@
 #include <utility>
 
 #include "Options/String.hpp"
+#include "Time/EvolutionOrdering.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/TimeSequence.hpp"
 #include "Time/TimeStepId.hpp"
-#include "Time/Utilities.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Utilities/Gsl.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
 /// \cond
 namespace Tags {
-struct TimeStepId;
+struct Time;
 }  // namespace Tags
 /// \endcond
 
@@ -52,56 +55,40 @@ class StepToTimes : public StepChooser<StepChooserUse::Slab> {
   explicit StepToTimes(std::unique_ptr<TimeSequence<double>> times)
       : times_(std::move(times)) {}
 
-  using argument_tags = tmpl::list<::Tags::TimeStepId>;
-
-  std::pair<double, bool> operator()(const TimeStepId& time_step_id,
-                                     const double last_step_magnitude) const {
-    const double now = time_step_id.substep_time();
-    // Trying to step to a given time might not get us exactly there
-    // because of rounding errors.  Avoid taking an extra tiny step if
-    // we undershoot.
-    const double sloppiness = slab_rounding_error(time_step_id.step_time());
+  using argument_tags = tmpl::list<::Tags::Time>;
 
+  std::pair<TimeStepRequest, bool> operator()(const double now,
+                                              const double last_step) const {
     const auto goal_times = times_->times_near(now);
-    if (not goal_times[1]) {
+    if (not goal_times[1].has_value()) {
       // No times requested.
-      return std::make_pair(std::numeric_limits<double>::infinity(), true);
+      return {{}, true};
     }
 
-    double distance_to_next_goal = std::numeric_limits<double>::signaling_NaN();
-    if (time_step_id.time_runs_forward()) {
-      const auto next_time =
-          *goal_times[1] > now + sloppiness ? goal_times[1] : goal_times[2];
-      if (not next_time) {
-        // We've passed all the times.  No restriction.
-        return std::make_pair(std::numeric_limits<double>::infinity(), true);
-      }
-      distance_to_next_goal = *next_time - now;
-    } else {
-      const auto next_time =
-          *goal_times[1] < now - sloppiness ? goal_times[1] : goal_times[0];
-      if (not next_time) {
-        // We've passed all the times.  No restriction.
-        return std::make_pair(std::numeric_limits<double>::infinity(), true);
-      }
-      distance_to_next_goal = now - *next_time;
+    const evolution_greater<double> after{last_step > 0.0};
+    const auto next_time = after(*goal_times[1], now)
+                               ? goal_times[1]
+                               : gsl::at(goal_times, last_step > 0.0 ? 2 : 0);
+    if (not next_time.has_value()) {
+      // We've passed all the times.  No restriction.
+      return {{}, true};
     }
 
-    if (distance_to_next_goal < 2.0 / 3.0 * last_step_magnitude) {
-      // Our goal is well within range of the expected allowed step
-      // size.
-      return std::make_pair(distance_to_next_goal, true);
-    } else {
-      // We can't reach our goal in one step, or at least might not be
-      // able to if the step adjusts a relatively small amount for
-      // other reasons.  Prevent the step from bringing us too close
-      // to the goal so that the step following this one will not be
-      // too small.
-      return std::make_pair(2.0 / 3.0 * distance_to_next_goal, true);
-    }
+    // The calling code can ignore one part of the request if it can
+    // fulfill the other part exactly, so this will either step
+    // exactly to *next_time or step at most 2/3 of the way there.
+    // This attempts to balance out the steps to avoid a step almost
+    // to *next_time followed by a very small step.  This will work
+    // poorly if there are two copies of this StepChooser targeting
+    // times very close together, but hopefully people don't do that.
+    return {{.size = 2.0 / 3.0 * (*next_time - now),
+             .end = *next_time,
+             .end_hard_limit = *next_time},
+            true};
   }
 
   bool uses_local_data() const override;
+  bool can_be_delayed() const override;
 
   // NOLINTNEXTLINE(google-runtime-references)
   void pup(PUP::er& p) override { p | times_; }
diff --git a/src/Time/Time.cpp b/src/Time/Time.cpp
index 4992642cd755..2a6a8a0baa8f 100644
--- a/src/Time/Time.cpp
+++ b/src/Time/Time.cpp
@@ -94,12 +94,8 @@ bool Time::StructuralCompare::operator()(const Time& a, const Time& b) const {
 }
 
 void Time::compute_value() {
-  if (is_at_slab_end()) {
-    // Protection against rounding error.
-    value_ = slab_.end_;
-  } else {
-    value_ = slab_.start_ + (slab_.duration() * fraction_).value();
-  }
+  value_ =
+      (1 - fraction_).value() * slab_.start_ + fraction_.value() * slab_.end_;
 }
 
 void Time::range_check() const {
diff --git a/src/Time/TimeStepRequest.cpp b/src/Time/TimeStepRequest.cpp
new file mode 100644
index 000000000000..9b45848bffb2
--- /dev/null
+++ b/src/Time/TimeStepRequest.cpp
@@ -0,0 +1,26 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Time/TimeStepRequest.hpp"
+
+#include <pup.h>
+
+#include "Utilities/Serialization/PupStlCpp17.hpp"
+
+void TimeStepRequest::pup(PUP::er& p) {
+  p | size_goal;
+  p | size;
+  p | end;
+  p | size_hard_limit;
+  p | end_hard_limit;
+}
+
+bool operator==(const TimeStepRequest& a, const TimeStepRequest& b) {
+  return a.size_goal == b.size_goal and a.size == b.size and a.end == b.end and
+         a.size_hard_limit == b.size_hard_limit and
+         a.end_hard_limit == b.end_hard_limit;
+}
+
+bool operator!=(const TimeStepRequest& a, const TimeStepRequest& b) {
+  return not(a == b);
+}
diff --git a/src/Time/TimeStepRequest.hpp b/src/Time/TimeStepRequest.hpp
new file mode 100644
index 000000000000..a97e57488d04
--- /dev/null
+++ b/src/Time/TimeStepRequest.hpp
@@ -0,0 +1,66 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#pragma once
+
+#include <optional>
+
+/// \cond
+namespace PUP {
+class er;
+}  // namespace PUP
+/// \endcond
+
+/// Information on a requested time-step size returned by `StepChooser`s.
+///
+/// Requests made using this struct control most of the changing of
+/// slab and local-time-stepping step sizes.  Slab-size changing is
+/// more complex, as it is controlled using the `ChangeSlabSize`
+/// event, which may run zero or more times per slab, and may have the
+/// application of its result delayed.  The step size for LTS is
+/// adjusted using a constant list of `StepChoosers` on every step.
+///
+/// For slab-size adjustment (including the global time step when not
+/// using LTS), a "goal" step size is maintained from step to step.
+/// It is initially the initial slab size from the input file, and can
+/// be adjusted by any request setting the `size_goal` field of this
+/// struct.  If multiple requests set new goals at the same time, the
+/// smallest value is used.  At the start of each slab, the size is
+/// chosen to be the smallest of the current goal and the temporary
+/// limits imposed by any requests processed at that time.  For the
+/// LTS step size, the current step size is used as the goal if no
+/// request sets a new one.
+///
+/// Any request with either the `size` or `end` fields set introduces
+/// a temporary step size limit.  If only one of the two is set, the
+/// chosen step size will be limited to be not larger than `*size`, or
+/// not go beyond the time `*end`.  If both are set, the tighter limit
+/// may be ignored if the looser limit is chosen as the actual step,
+/// but the step will not be chosen to be intermediate between two
+/// temporary limits from the same request object.
+///
+/// The hard limits are not used in setting the step size, but if the
+/// actual step does not satisfy all hard limits from all requests the
+/// evolution will be terminated with an error.
+///
+/// \note All step sizes are subject to roundoff error in either
+/// direction except for two cases:
+/// * Slab sizes imposed by the `end` limit of a request will always
+///   end precisely at the requested time.
+/// * LTS step sizes within a single slab will always be considered to
+///   have size ratios that are exactly powers of two for the purposes
+///   of the `size_goal` and `size` limits.
+struct TimeStepRequest {
+  std::optional<double> size_goal{};
+
+  std::optional<double> size{};
+  std::optional<double> end{};
+
+  std::optional<double> size_hard_limit{};
+  std::optional<double> end_hard_limit{};
+
+  void pup(PUP::er& p);
+};
+
+bool operator==(const TimeStepRequest& a, const TimeStepRequest& b);
+bool operator!=(const TimeStepRequest& a, const TimeStepRequest& b);
diff --git a/src/Time/TimeStepRequestProcessor.cpp b/src/Time/TimeStepRequestProcessor.cpp
new file mode 100644
index 000000000000..4e086af3cde7
--- /dev/null
+++ b/src/Time/TimeStepRequestProcessor.cpp
@@ -0,0 +1,226 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Time/TimeStepRequestProcessor.hpp"
+
+#include <algorithm>
+#include <optional>
+
+#include "Time/EvolutionOrdering.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Utilities/ErrorHandling/Assert.hpp"
+#include "Utilities/ErrorHandling/Error.hpp"
+#include "Utilities/Serialization/PupStlCpp17.hpp"
+
+TimeStepRequestProcessor::TimeStepRequestProcessor(const bool time_runs_forward)
+    : time_runs_forward_(time_runs_forward) {
+  const double inf = evolution_less<double>{time_runs_forward}.infinity();
+  step_size_request_ = inf;
+  step_end_request_ = inf;
+  next_step_size_request_ = inf;
+  next_step_end_request_ = inf;
+  step_size_hard_limit_ = inf;
+  step_end_hard_limit_ = inf;
+}
+
+std::optional<double> TimeStepRequestProcessor::new_step_size_goal() const {
+  return step_size_goal_;
+}
+
+double TimeStepRequestProcessor::step_size(const double step_start,
+                                           const double step_size_goal) const {
+  const evolution_less<double> smaller{time_runs_forward_};
+
+  const double goal = step_size_goal_.value_or(step_size_goal);
+  const double size_from_end = step_end_request_ - step_start;
+
+  if (can_use_larger_limit_) {
+    // Both limits are from the same request
+    const double request = std::max(step_size_request_, size_from_end, smaller);
+    if (not(smaller(goal, request) or
+            smaller(next_step_size_request_, request) or
+            smaller(next_step_end_request_ - step_start, request))) {
+      return request;
+    }
+  }
+
+  return std::min({goal, step_size_request_, size_from_end}, smaller);
+}
+
+double TimeStepRequestProcessor::step_end(const double step_start,
+                                          const double step_size_goal) const {
+  const evolution_less<double> before{time_runs_forward_};
+
+  const double goal = step_start + step_size_goal_.value_or(step_size_goal);
+  const double end_from_size = step_start + step_size_request_;
+
+  if (can_use_larger_limit_) {
+    // Both limits are from the same request
+    const double request = std::max(step_end_request_, end_from_size, before);
+    if (not(before(goal, request) or
+            before(step_start + next_step_size_request_, request) or
+            before(next_step_end_request_, request))) {
+      return request;
+    }
+  }
+
+  return std::min({goal, step_end_request_, end_from_size}, before);
+}
+
+void TimeStepRequestProcessor::process(const TimeStepRequest& request) {
+  // Earlier-time and smaller-step are the same operation on doubles,
+  // but it's easier to read if they have different names.
+  const evolution_less<double> before{time_runs_forward_};
+  const evolution_less<double> smaller{time_runs_forward_};
+
+  ASSERT(not(request.size_goal.has_value() and
+             request.size.has_value() and
+             smaller(*request.size_goal, *request.size)),
+         "Requested a step size goal of " << *request.size_goal
+         << ", but a particular step size larger than that goal: "
+         << *request.size);
+
+  TimeStepRequestProcessor request_postprocessor(time_runs_forward_);
+  request_postprocessor.step_size_goal_ = request.size_goal;
+
+  request_postprocessor.step_size_request_ =
+      request.size.value_or(smaller.infinity());
+  request_postprocessor.step_end_request_ =
+      request.end.value_or(before.infinity());
+
+  request_postprocessor.can_use_larger_limit_ =
+      request.size.has_value() and request.end.has_value();
+
+  request_postprocessor.step_size_hard_limit_ =
+      request.size_hard_limit.value_or(smaller.infinity());
+  request_postprocessor.step_end_hard_limit_ =
+      request.end_hard_limit.value_or(before.infinity());
+
+  *this += request_postprocessor;
+}
+
+TimeStepRequestProcessor& TimeStepRequestProcessor::operator+=(
+    const TimeStepRequestProcessor& other) {
+  ASSERT(time_runs_forward_ == other.time_runs_forward_,
+         "Inconsistent time directions.");
+
+  // Earlier-time and smaller-step are the same operation on doubles,
+  // but it's easier to read if they have different names.
+  const evolution_less<double> before{time_runs_forward_};
+  const evolution_less<double> smaller{time_runs_forward_};
+
+  if (smaller(other.step_size_goal_.value_or(smaller.infinity()),
+              step_size_goal_.value_or(smaller.infinity()))) {
+    step_size_goal_ = other.step_size_goal_;
+  }
+
+  if (smaller(step_size_request_, other.step_size_request_)) {
+    next_step_size_request_ =
+        std::min(next_step_size_request_, other.step_size_request_, smaller);
+  } else if (smaller(other.step_size_request_, step_size_request_)) {
+    next_step_size_request_ =
+        std::min(step_size_request_, other.next_step_size_request_, smaller);
+  } else {
+    next_step_size_request_ = std::min(next_step_size_request_,
+                                       other.next_step_size_request_, smaller);
+  }
+  if (before(step_end_request_, other.step_end_request_)) {
+    next_step_end_request_ =
+        std::min(next_step_end_request_, other.step_end_request_, before);
+  } else if (before(other.step_end_request_, step_end_request_)) {
+    next_step_end_request_ =
+        std::min(step_end_request_, other.next_step_end_request_, before);
+  } else {
+    next_step_end_request_ =
+        std::min(next_step_end_request_, other.next_step_end_request_, before);
+  }
+
+  const double new_size_request =
+      std::min(step_size_request_, other.step_size_request_, smaller);
+  const double new_end_request =
+      std::min(step_end_request_, other.step_end_request_, before);
+  if ((new_size_request == step_size_request_) ==
+          (new_end_request == step_end_request_) and
+      (new_size_request == other.step_size_request_) ==
+          (new_end_request == other.step_end_request_)) {
+    if (new_size_request == step_size_request_) {
+      if (new_size_request == other.step_size_request_) {
+        can_use_larger_limit_ =
+            can_use_larger_limit_ and other.can_use_larger_limit_;
+      } else {
+        // use existing value
+      }
+    } else {
+      if (new_size_request == other.step_size_request_) {
+        can_use_larger_limit_ = other.can_use_larger_limit_;
+      } else {
+        can_use_larger_limit_ = false;
+      }
+    }
+  } else {
+    can_use_larger_limit_ = false;
+  }
+  step_size_request_ = new_size_request;
+  step_end_request_ = new_end_request;
+
+  step_size_hard_limit_ =
+      std::min(step_size_hard_limit_, other.step_size_hard_limit_, smaller);
+  step_end_hard_limit_ =
+      std::min(step_end_hard_limit_, other.step_end_hard_limit_, before);
+
+  return *this;
+}
+
+void TimeStepRequestProcessor::error_on_hard_limit(const double size,
+                                                   const double end) const {
+  // Earlier-time and smaller-step are the same operation on doubles,
+  // but it's easier to read if they have different names.
+  const evolution_less<double> before{time_runs_forward_};
+  const evolution_less<double> smaller{time_runs_forward_};
+
+  if (smaller(step_size_hard_limit_, size)) {
+    ERROR("Could not adjust step below "
+          << size << " to meet maximum step size " << step_size_hard_limit_);
+  }
+  if (before(step_end_hard_limit_, end)) {
+    ERROR("Could not adjust step to before "
+          << end << " to avoid exceeding time " << step_end_hard_limit_);
+  }
+}
+
+void TimeStepRequestProcessor::pup(PUP::er& p) {
+  p | time_runs_forward_;
+  p | step_size_goal_;
+  p | step_size_request_;
+  p | step_end_request_;
+  p | can_use_larger_limit_;
+  p | next_step_size_request_;
+  p | next_step_end_request_;
+  p | step_size_hard_limit_;
+  p | step_end_hard_limit_;
+}
+
+bool operator==(const TimeStepRequestProcessor& a,
+                const TimeStepRequestProcessor& b) {
+  return a.time_runs_forward_ == b.time_runs_forward_ and
+         a.step_size_goal_ == b.step_size_goal_ and
+         a.step_size_request_ == b.step_size_request_ and
+         a.step_end_request_ == b.step_end_request_ and
+         a.can_use_larger_limit_ == b.can_use_larger_limit_ and
+         a.next_step_size_request_ == b.next_step_size_request_ and
+         a.next_step_end_request_ == b.next_step_end_request_ and
+         a.step_size_hard_limit_ == b.step_size_hard_limit_ and
+         a.step_end_hard_limit_ == b.step_end_hard_limit_;
+}
+
+bool operator!=(const TimeStepRequestProcessor& a,
+                const TimeStepRequestProcessor& b) {
+  return not(a == b);
+}
+
+TimeStepRequestProcessor operator+(const TimeStepRequestProcessor& a,
+                                   const TimeStepRequestProcessor& b) {
+  auto result = a;
+  result += b;
+  return result;
+}
diff --git a/src/Time/TimeStepRequestProcessor.hpp b/src/Time/TimeStepRequestProcessor.hpp
new file mode 100644
index 000000000000..ee8b767422b3
--- /dev/null
+++ b/src/Time/TimeStepRequestProcessor.hpp
@@ -0,0 +1,71 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#pragma once
+
+#include <limits>
+#include <optional>
+
+/// \cond
+struct TimeStepRequest;
+namespace PUP {
+class er;
+}  // namespace PUP
+/// \endcond
+
+/// Combine TimeStepRequest objects to find a consensus step.  See
+/// that class for details.
+class TimeStepRequestProcessor {
+ public:
+  TimeStepRequestProcessor() = default;
+  explicit TimeStepRequestProcessor(bool time_runs_forward);
+
+  /// The new goal, if one was given.
+  std::optional<double> new_step_size_goal() const;
+
+  /// The new step.  Two versions are provided, as neither computing
+  /// the step size from the end or the end from the size is
+  /// guaranteed to be an exact operation on floating-point values,
+  /// and which quantity is fundamental varies between consumers.  The
+  /// \p step_size_goal is ignored if any requests have set a new
+  /// goal.
+  /// @{
+  double step_size(double step_start, double step_size_goal) const;
+  double step_end(double step_start, double step_size_goal) const;
+  /// @}
+
+  void process(const TimeStepRequest& request);
+
+  /// Merge the results from another object.
+  TimeStepRequestProcessor& operator+=(const TimeStepRequestProcessor& other);
+
+  /// ERROR if \p size and \p end do not satisfy the hard limits.
+  void error_on_hard_limit(double size, double end) const;
+
+  void pup(PUP::er& p);
+
+ private:
+  friend bool operator==(const TimeStepRequestProcessor& a,
+                         const TimeStepRequestProcessor& b);
+
+  bool time_runs_forward_ = false;
+
+  std::optional<double> step_size_goal_{};
+
+  double step_size_request_ = std::numeric_limits<double>::signaling_NaN();
+  double step_end_request_ = std::numeric_limits<double>::signaling_NaN();
+
+  bool can_use_larger_limit_ = false;
+  double next_step_size_request_ = std::numeric_limits<double>::signaling_NaN();
+  double next_step_end_request_ = std::numeric_limits<double>::signaling_NaN();
+
+  double step_size_hard_limit_ = std::numeric_limits<double>::signaling_NaN();
+  double step_end_hard_limit_ = std::numeric_limits<double>::signaling_NaN();
+};
+
+bool operator!=(const TimeStepRequestProcessor& a,
+                const TimeStepRequestProcessor& b);
+
+/// Combine the limits from two TimeStepRequestProcessor objects.
+TimeStepRequestProcessor operator+(const TimeStepRequestProcessor& a,
+                                   const TimeStepRequestProcessor& b);
diff --git a/src/Time/Triggers/Times.hpp b/src/Time/Triggers/Times.hpp
index 036b510132e5..a1c441ecc294 100644
--- a/src/Time/Triggers/Times.hpp
+++ b/src/Time/Triggers/Times.hpp
@@ -3,8 +3,8 @@
 
 #pragma once
 
-#include <cmath>
 #include <memory>
+#include <optional>
 #include <pup.h>
 #include <pup_stl.h>
 #include <utility>
@@ -13,15 +13,12 @@
 #include "Options/String.hpp"
 #include "ParallelAlgorithms/EventsAndTriggers/Trigger.hpp"
 #include "Time/TimeSequence.hpp"
-#include "Time/TimeStepId.hpp"
-#include "Time/Utilities.hpp"
 #include "Utilities/Serialization/CharmPupable.hpp"
 #include "Utilities/TMPL.hpp"
 
 /// \cond
 namespace Tags {
 struct Time;
-struct TimeStepId;
 }  // namespace Tags
 /// \endcond
 
@@ -47,16 +44,10 @@ class Times : public Trigger {
   explicit Times(std::unique_ptr<TimeSequence<double>> times)
       : times_(std::move(times)) {}
 
-  using argument_tags = tmpl::list<Tags::Time, Tags::TimeStepId>;
+  using argument_tags = tmpl::list<Tags::Time>;
 
-  bool operator()(const double now, const TimeStepId& time_id) const {
-    const auto& step_time = time_id.step_time();
-    // Trying to step to a given time might not get us exactly there
-    // because of rounding errors.
-    const double sloppiness = slab_rounding_error(step_time);
-
-    const auto nearby_time = times_->times_near(now)[1];
-    return nearby_time and std::abs(*nearby_time - now) < sloppiness;
+  bool operator()(const double now) const {
+    return times_->times_near(now)[1] == std::optional(now);
   }
 
   // NOLINTNEXTLINE(google-runtime-references)
diff --git a/support/Pipelines/Bbh/Inspiral.yaml b/support/Pipelines/Bbh/Inspiral.yaml
index 594e0b1d1135..e46773f0a97a 100644
--- a/support/Pipelines/Bbh/Inspiral.yaml
+++ b/support/Pipelines/Bbh/Inspiral.yaml
@@ -141,8 +141,9 @@ Evolution:
   # intervals in the EventsAndTriggers
   InitialSlabSize: 0.5
   StepChoosers:
-    - Increase:
+    - LimitIncrease:
         Factor: 2
+    - PreventRapidIncrease
     - ElementSizeCfl:
         SafetyFactor: 0.5
     - ErrorControl:
diff --git a/support/Pipelines/Bbh/Ringdown.yaml b/support/Pipelines/Bbh/Ringdown.yaml
index b9e2d66dab76..802f19423049 100644
--- a/support/Pipelines/Bbh/Ringdown.yaml
+++ b/support/Pipelines/Bbh/Ringdown.yaml
@@ -50,7 +50,7 @@ Evolution:
   # you would like more frequent output, consider using dense output.
   InitialSlabSize: 0.1
   StepChoosers:
-    - Increase:
+    - LimitIncrease:
         Factor: 2
     - ElementSizeCfl:
         SafetyFactor: 0.5
diff --git a/tests/InputFiles/Burgers/Step.yaml b/tests/InputFiles/Burgers/Step.yaml
index 0da1221adf87..6e9d1b03b482 100644
--- a/tests/InputFiles/Burgers/Step.yaml
+++ b/tests/InputFiles/Burgers/Step.yaml
@@ -89,7 +89,7 @@ EventsAndTriggers:
           StepChoosers:
             - Cfl:
                 SafetyFactor: 0.5
-            - Increase:
+            - LimitIncrease:
                 Factor: 2.0
 
 EventsAndDenseTriggers:
diff --git a/tests/InputFiles/Cce/AnalyticTestBouncingBlackHole.yaml b/tests/InputFiles/Cce/AnalyticTestBouncingBlackHole.yaml
index 2e050a47ec61..9f924b57f8d3 100644
--- a/tests/InputFiles/Cce/AnalyticTestBouncingBlackHole.yaml
+++ b/tests/InputFiles/Cce/AnalyticTestBouncingBlackHole.yaml
@@ -53,7 +53,7 @@ Cce:
         Order: 3
     StepChoosers:
       - Constant: 0.1
-      - Increase:
+      - LimitIncrease:
           Factor: 2
 
   LMax: 8
diff --git a/tests/InputFiles/Cce/AnalyticTestGaugeWave.yaml b/tests/InputFiles/Cce/AnalyticTestGaugeWave.yaml
index 82b4f6b3d3f6..0a3887c34d3d 100644
--- a/tests/InputFiles/Cce/AnalyticTestGaugeWave.yaml
+++ b/tests/InputFiles/Cce/AnalyticTestGaugeWave.yaml
@@ -53,7 +53,7 @@ Cce:
         Order: 3
     StepChoosers:
       - Constant: 0.4
-      - Increase:
+      - LimitIncrease:
           Factor: 2
 
   LMax: 8
diff --git a/tests/InputFiles/Cce/AnalyticTestLinearizedBondiSachs.yaml b/tests/InputFiles/Cce/AnalyticTestLinearizedBondiSachs.yaml
index 5bc004657557..89d77c77a690 100644
--- a/tests/InputFiles/Cce/AnalyticTestLinearizedBondiSachs.yaml
+++ b/tests/InputFiles/Cce/AnalyticTestLinearizedBondiSachs.yaml
@@ -53,7 +53,7 @@ Cce:
         Order: 3
     StepChoosers:
       - Constant: 0.4
-      - Increase:
+      - LimitIncrease:
           Factor: 2
 
   LMax: 8
diff --git a/tests/InputFiles/Cce/AnalyticTestRobinsonTrautman.yaml b/tests/InputFiles/Cce/AnalyticTestRobinsonTrautman.yaml
index e115a90e7edf..cb06cb3d7327 100644
--- a/tests/InputFiles/Cce/AnalyticTestRobinsonTrautman.yaml
+++ b/tests/InputFiles/Cce/AnalyticTestRobinsonTrautman.yaml
@@ -53,7 +53,7 @@ Cce:
         Order: 3
     StepChoosers:
       - Constant: 0.1
-      - Increase:
+      - LimitIncrease:
           Factor: 2
 
   LMax: 10
diff --git a/tests/InputFiles/Cce/AnalyticTestRotatingSchwarzschild.yaml b/tests/InputFiles/Cce/AnalyticTestRotatingSchwarzschild.yaml
index 6900011df76d..9c1522ccc9eb 100644
--- a/tests/InputFiles/Cce/AnalyticTestRotatingSchwarzschild.yaml
+++ b/tests/InputFiles/Cce/AnalyticTestRotatingSchwarzschild.yaml
@@ -53,7 +53,7 @@ Cce:
         Order: 3
     StepChoosers:
       - Constant: 0.2
-      - Increase:
+      - LimitIncrease:
           Factor: 2
 
   LMax: 8
diff --git a/tests/InputFiles/Cce/AnalyticTestTeukolskyWave.yaml b/tests/InputFiles/Cce/AnalyticTestTeukolskyWave.yaml
index 0eb541d8c884..a87d4a97650f 100644
--- a/tests/InputFiles/Cce/AnalyticTestTeukolskyWave.yaml
+++ b/tests/InputFiles/Cce/AnalyticTestTeukolskyWave.yaml
@@ -53,7 +53,7 @@ Cce:
         Order: 3
     StepChoosers:
       - Constant: 0.5
-      - Increase:
+      - LimitIncrease:
           Factor: 2
 
   LMax: 8
diff --git a/tests/InputFiles/Cce/CharacteristicExtract.yaml b/tests/InputFiles/Cce/CharacteristicExtract.yaml
index f2c7c1064dce..8f61454fdb50 100644
--- a/tests/InputFiles/Cce/CharacteristicExtract.yaml
+++ b/tests/InputFiles/Cce/CharacteristicExtract.yaml
@@ -52,7 +52,7 @@ Cce:
         Order: 3 # Going to higher order doesn't seem necessary for CCE
     StepChoosers:
       - Constant: 0.1 # Don't take steps bigger than 0.1M
-      - Increase:
+      - LimitIncrease:
           Factor: 2
       - ErrorControl(SwshVars):
           AbsoluteTolerance: 1e-8
diff --git a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml
index 0a69317103a3..203af53f3ae1 100644
--- a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml
+++ b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski1D.yaml
@@ -36,9 +36,9 @@ Evolution:
     AdamsBashforth:
       Order: 3
   StepChoosers:
-    - Constant: 0.05
-    - Increase:
+    - LimitIncrease:
         Factor: 2
+    - PreventRapidIncrease
     - Cfl:
         SafetyFactor: 0.2
 
diff --git a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml
index 790d8eea53e8..92202b32e275 100644
--- a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml
+++ b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski2D.yaml
@@ -36,9 +36,9 @@ Evolution:
     AdamsBashforth:
       Order: 3
   StepChoosers:
-    - Constant: 0.05
-    - Increase:
+    - LimitIncrease:
         Factor: 2
+    - PreventRapidIncrease
     - Cfl:
         SafetyFactor: 0.2
 
diff --git a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml
index 941a483abba9..a0b483a4354d 100644
--- a/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml
+++ b/tests/InputFiles/CurvedScalarWave/PlaneWaveMinkowski3D.yaml
@@ -51,9 +51,9 @@ Evolution:
     AdamsBashforth:
       Order: 3
   StepChoosers:
-    - Constant: 0.05
-    - Increase:
+    - LimitIncrease:
         Factor: 2
+    - PreventRapidIncrease
     - Cfl:
         SafetyFactor: 0.2
 
diff --git a/tests/InputFiles/GeneralizedHarmonic/CylindricalBinaryBlackHole.yaml b/tests/InputFiles/GeneralizedHarmonic/CylindricalBinaryBlackHole.yaml
index bc814a43243b..2981be8f271f 100644
--- a/tests/InputFiles/GeneralizedHarmonic/CylindricalBinaryBlackHole.yaml
+++ b/tests/InputFiles/GeneralizedHarmonic/CylindricalBinaryBlackHole.yaml
@@ -20,8 +20,9 @@ Evolution:
   InitialTimeStep: 0.0002
   InitialSlabSize: 0.25
   StepChoosers:
-    - Increase:
+    - LimitIncrease:
         Factor: 2
+    - PreventRapidIncrease
     - ElementSizeCfl:
         SafetyFactor: 0.5
     - ErrorControl:
diff --git a/tests/InputFiles/GeneralizedHarmonic/KerrSchild.yaml b/tests/InputFiles/GeneralizedHarmonic/KerrSchild.yaml
index 46b128c7f7dc..308928ed220b 100644
--- a/tests/InputFiles/GeneralizedHarmonic/KerrSchild.yaml
+++ b/tests/InputFiles/GeneralizedHarmonic/KerrSchild.yaml
@@ -33,7 +33,7 @@ Evolution:
   # like more frequent output, consider using dense output.
   InitialSlabSize: 0.001
   StepChoosers:
-    - Increase:
+    - LimitIncrease:
         Factor: 2
     - ElementSizeCfl:
         SafetyFactor: 0.5
diff --git a/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdBondiMichel.yaml b/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdBondiMichel.yaml
index a56e7e576b4f..fda569560ed6 100644
--- a/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdBondiMichel.yaml
+++ b/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdBondiMichel.yaml
@@ -147,7 +147,7 @@ EventsAndTriggers:
           StepChoosers:
             - Cfl:
                 SafetyFactor: 0.6
-            - Increase:
+            - LimitIncrease:
                 Factor: 1.5
   - Trigger:
       Slabs:
diff --git a/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdTovStar.yaml b/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdTovStar.yaml
index bd4ccbbd7017..aae253daed48 100644
--- a/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdTovStar.yaml
+++ b/tests/InputFiles/GrMhd/GhValenciaDivClean/GhMhdTovStar.yaml
@@ -181,7 +181,7 @@ EventsAndTriggers:
           StepChoosers:
             - Cfl:
                 SafetyFactor: 0.6
-            - Increase:
+            - LimitIncrease:
                 Factor: 1.5
   - Trigger:
       Slabs:
diff --git a/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml b/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml
index c626ca5e5bfd..a91e0bff6be4 100644
--- a/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml
+++ b/tests/InputFiles/GrMhd/ValenciaDivClean/FishboneMoncriefDisk.yaml
@@ -27,9 +27,9 @@ Evolution:
       Order: 3
   # StepChoosers are needed only for local time stepping
   # StepChoosers:
-  #   - Constant: 0.05
-  #   - Increase:
+  #   - LimitIncrease:
   #       Factor: 2
+  #   - PreventRapidIncrease
   #   - Cfl:
   #       SafetyFactor: 0.2
   # InitialSlabSize is only needed for local time stepping
@@ -157,8 +157,8 @@ EventsAndTriggers:
           # testing.
           DelayChange: 0
           StepChoosers:
-            - Constant: 0.05
-            - Increase:
+            - Maximum: 0.05
+            - LimitIncrease:
                 Factor: 2
             - Cfl:
                 SafetyFactor: 0.2
diff --git a/tests/InputFiles/NewtonianEuler/RiemannProblem1D.yaml b/tests/InputFiles/NewtonianEuler/RiemannProblem1D.yaml
index 5e30b6f8e6df..fd5e498768b2 100644
--- a/tests/InputFiles/NewtonianEuler/RiemannProblem1D.yaml
+++ b/tests/InputFiles/NewtonianEuler/RiemannProblem1D.yaml
@@ -104,7 +104,7 @@ EventsAndTriggers:
           # number has little qualitative effect on chosen step size,
           # as long as the initial step size is not too large for the
           # requested accuracy.
-          DelayChange: &slab_update_delay 10
+          DelayChange: 10
           StepChoosers:
             - ErrorControl:
                 AbsoluteTolerance: 1.0e-3
@@ -112,19 +112,12 @@ EventsAndTriggers:
                 MaxFactor: 10000.0
                 MinFactor: 0.0
                 SafetyFactor: 0.9
-  # These step choosers require no communication, so can be applied
-  # with a delay of 0 with no downside.  We don't want them to start
-  # increasing the slab size before the error control is active,
-  # though.
-  - Trigger:
-      SlabCompares:
-        Comparison: GreaterThanOrEqualTo
-        Value: *slab_update_delay
-    Events:
       - ChangeSlabSize:
+          # These step choosers require no communication, so can be
+          # applied with a delay of 0 with no downside.
           DelayChange: 0
           StepChoosers:
-            - Increase:
+            - LimitIncrease:
                 Factor: 2.0
             - PreventRapidIncrease
 
diff --git a/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml b/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml
index 7d083d2c1790..740afe084094 100644
--- a/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml
+++ b/tests/InputFiles/ScalarTensor/KerrSchildSphericalHarmonic.yaml
@@ -32,9 +32,9 @@ Evolution:
       Order: 3
   InitialSlabSize: 0.001
   StepChoosers:
-    - Constant: 0.01
-    - Increase:
+    - LimitIncrease:
         Factor: 2
+    - PreventRapidIncrease
     - Cfl:
         SafetyFactor: 0.2
 
diff --git a/tests/InputFiles/ScalarWave/PlaneWave3D.yaml b/tests/InputFiles/ScalarWave/PlaneWave3D.yaml
index 0c5d4141a5e1..60f71e929e36 100644
--- a/tests/InputFiles/ScalarWave/PlaneWave3D.yaml
+++ b/tests/InputFiles/ScalarWave/PlaneWave3D.yaml
@@ -82,8 +82,6 @@ EventsAndTriggers:
       - ChangeSlabSize:
           DelayChange: 0
           StepChoosers:
-            - Increase:
-                Factor: 1.1
             - StepToTimes:
                 Times:
                   Specified:
diff --git a/tests/Unit/Evolution/Initialization/Test_Evolution.cpp b/tests/Unit/Evolution/Initialization/Test_Evolution.cpp
index d5945b20d49b..3b0a4a8ed493 100644
--- a/tests/Unit/Evolution/Initialization/Test_Evolution.cpp
+++ b/tests/Unit/Evolution/Initialization/Test_Evolution.cpp
@@ -5,6 +5,7 @@
 
 #include <array>
 #include <cstddef>
+#include <limits>
 #include <memory>
 #include <unordered_map>
 #include <utility>
@@ -26,9 +27,10 @@
 #include "Parallel/Tags/ArrayIndex.hpp"
 #include "ParallelAlgorithms/Amr/Protocols/Projector.hpp"
 #include "Time/AdaptiveSteppingDiagnostics.hpp"
+#include "Time/ChangeSlabSize/Tags.hpp"
 #include "Time/ChooseLtsStepSize.hpp"
 #include "Time/Slab.hpp"
-#include "Time/StepChoosers/Increase.hpp"
+#include "Time/StepChoosers/LimitIncrease.hpp"
 #include "Time/Tags/AdaptiveSteppingDiagnostics.hpp"
 #include "Time/Tags/Time.hpp"
 #include "Time/Tags/TimeStep.hpp"
@@ -50,7 +52,7 @@ struct TestMetavariables {
       : tt::ConformsTo<Options::protocols::FactoryCreation> {
     using factory_classes = tmpl::map<tmpl::pair<
         StepChooser<StepChooserUse::LtsStep>,
-        tmpl::list<StepChoosers::Increase<StepChooserUse::LtsStep>>>>;
+        tmpl::list<StepChoosers::LimitIncrease<StepChooserUse::LtsStep>>>>;
   };
   using component_list = tmpl::list<>;
   using const_global_cache_tags =
@@ -83,11 +85,11 @@ void test_gts() {
           ::Tags::Time, Initialization::Tags::InitialTimeDelta,
           Initialization::Tags::InitialSlabSize<false>,
           ::Tags::Next<::Tags::TimeStepId>, ::Tags::TimeStep,
-          ::Tags::Next<::Tags::TimeStep>>,
+          ::Tags::Next<::Tags::TimeStep>, ::Tags::ChangeSlabSize::SlabSizeGoal>,
       tmpl::list<Parallel::Tags::FromGlobalCache<
           ::Tags::ConcreteTimeStepper<TimeStepper>>>>(
       &global_cache, initial_time, initial_dt, initial_slab_size, TimeStepId{},
-      TimeDelta{}, TimeDelta{});
+      TimeDelta{}, TimeDelta{}, std::numeric_limits<double>::signaling_NaN());
 
   db::mutate_apply<Initialization::TimeStepping<TestMetavariables<TimeStepper>,
                                                 TimeStepper>>(
@@ -98,6 +100,8 @@ void test_gts() {
   CHECK(db::get<::Tags::TimeStep>(box) == expected_time_step);
   CHECK(db::get<::Tags::Next<::Tags::TimeStep>>(box) ==
         expected_next_time_step);
+  CHECK(db::get<::Tags::ChangeSlabSize::SlabSizeGoal>(box) ==
+        initial_slab_size);
 }
 
 void test_lts() {
@@ -128,11 +132,11 @@ void test_lts() {
           ::Tags::Time, Initialization::Tags::InitialTimeDelta,
           Initialization::Tags::InitialSlabSize<true>,
           ::Tags::Next<::Tags::TimeStepId>, ::Tags::TimeStep,
-          ::Tags::Next<::Tags::TimeStep>>,
+          ::Tags::Next<::Tags::TimeStep>, ::Tags::ChangeSlabSize::SlabSizeGoal>,
       tmpl::list<Parallel::Tags::FromGlobalCache<
           ::Tags::ConcreteTimeStepper<LtsTimeStepper>>>>(
       &global_cache, initial_time, initial_dt, initial_slab_size, TimeStepId{},
-      TimeDelta{}, TimeDelta{});
+      TimeDelta{}, TimeDelta{}, std::numeric_limits<double>::signaling_NaN());
 
   db::mutate_apply<Initialization::TimeStepping<
       TestMetavariables<LtsTimeStepper>, LtsTimeStepper>>(make_not_null(&box));
@@ -142,18 +146,22 @@ void test_lts() {
   CHECK(db::get<::Tags::TimeStep>(box) == expected_time_step);
   CHECK(db::get<::Tags::Next<::Tags::TimeStep>>(box) ==
         expected_next_time_step);
+  CHECK(db::get<::Tags::ChangeSlabSize::SlabSizeGoal>(box) ==
+        initial_slab_size);
 }
 using items_type =
     tuples::TaggedTuple<Parallel::Tags::ArrayIndexImpl<ElementId<1>>,
                         ::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                         ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>,
-                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics>;
+                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics,
+                        ::Tags::ChangeSlabSize::SlabSizeGoal>;
 
 using parent_items_type =
     tuples::TaggedTuple<Parallel::Tags::ArrayIndexImpl<ElementId<1>>,
                         ::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                         ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>,
                         ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics,
+                        ::Tags::ChangeSlabSize::SlabSizeGoal,
                         ::amr::Tags::Info<1>>;
 
 template <typename DbTagList>
@@ -162,7 +170,8 @@ void check(const db::DataBox<DbTagList>& box,
            const TimeStepId& expected_next_time_step_id,
            const TimeDelta& expected_time_step,
            const TimeDelta& expected_next_time_step, const double expected_time,
-           const AdaptiveSteppingDiagnostics& expected_diagnostics) {
+           const AdaptiveSteppingDiagnostics& expected_diagnostics,
+           const double expected_slab_size_goal) {
   CHECK(db::get<::Tags::TimeStepId>(box) == expected_time_step_id);
   CHECK(db::get<::Tags::Next<::Tags::TimeStepId>>(box) ==
         expected_next_time_step_id);
@@ -172,6 +181,8 @@ void check(const db::DataBox<DbTagList>& box,
   CHECK(db::get<::Tags::Time>(box) == expected_time);
   CHECK(db::get<::Tags::AdaptiveSteppingDiagnostics>(box) ==
         expected_diagnostics);
+  CHECK(db::get<::Tags::ChangeSlabSize::SlabSizeGoal>(box) ==
+        expected_slab_size_goal);
 }
 
 void test_p_refine() {
@@ -188,20 +199,22 @@ void test_p_refine() {
                                      start + time_step};
   const double time = start.value();
   const AdaptiveSteppingDiagnostics diagnostics{7, 2, 13, 4, 5};
+  const double slab_size_goal = 1.34;
 
   auto box = db::create<
       db::AddSimpleTags<Parallel::Tags::ArrayIndexImpl<ElementId<1>>,
                         ::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                         ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>,
-                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics>>(
+                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics,
+                        ::Tags::ChangeSlabSize::SlabSizeGoal>>(
       element_id, time_step_id, next_time_step_id, time_step, next_time_step,
-      time, diagnostics);
+      time, diagnostics, slab_size_goal);
 
   db::mutate_apply<Initialization::ProjectTimeStepping<1>>(
       make_not_null(&box), std::make_pair(mesh, element));
 
   check(box, time_step_id, next_time_step_id, time_step, next_time_step, time,
-        diagnostics);
+        diagnostics, slab_size_goal);
 }
 
 void test_split() {
@@ -218,6 +231,7 @@ void test_split() {
                                      start + time_step};
   const double time = start.value();
   const AdaptiveSteppingDiagnostics diagnostics{7, 2, 13, 4, 5};
+  const double slab_size_goal = 1.34;
 
   const parent_items_type parent_items{
       parent_id,
@@ -227,35 +241,40 @@ void test_split() {
       next_time_step,
       time,
       diagnostics,
+      slab_size_goal,
       ::amr::Info<1>{std::array{::amr::Flag::Split}, Mesh<1>{}}};
 
   auto child_1_box = db::create<
       db::AddSimpleTags<Parallel::Tags::ArrayIndexImpl<ElementId<1>>,
                         ::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                         ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>,
-                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics>>(
+                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics,
+                        ::Tags::ChangeSlabSize::SlabSizeGoal>>(
       child_1_id, TimeStepId{}, TimeStepId{}, TimeDelta{}, TimeDelta{}, 0.0,
-      AdaptiveSteppingDiagnostics{});
+      AdaptiveSteppingDiagnostics{},
+      std::numeric_limits<double>::signaling_NaN());
 
   auto child_2_box = db::create<
       db::AddSimpleTags<Parallel::Tags::ArrayIndexImpl<ElementId<1>>,
                         ::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                         ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>,
-                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics>>(
+                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics,
+                        ::Tags::ChangeSlabSize::SlabSizeGoal>>(
       child_2_id, TimeStepId{}, TimeStepId{}, TimeDelta{}, TimeDelta{}, 0.0,
-      AdaptiveSteppingDiagnostics{});
+      AdaptiveSteppingDiagnostics{},
+      std::numeric_limits<double>::signaling_NaN());
 
   db::mutate_apply<Initialization::ProjectTimeStepping<1>>(
       make_not_null(&child_1_box), parent_items);
 
   check(child_1_box, time_step_id, next_time_step_id, time_step, next_time_step,
-        time, diagnostics);
+        time, diagnostics, slab_size_goal);
 
   db::mutate_apply<Initialization::ProjectTimeStepping<1>>(
       make_not_null(&child_2_box), parent_items);
 
   check(child_2_box, time_step_id, next_time_step_id, time_step, next_time_step,
-        time, AdaptiveSteppingDiagnostics{7, 2, 0, 0, 0});
+        time, AdaptiveSteppingDiagnostics{7, 2, 0, 0, 0}, slab_size_goal);
 }
 
 template <bool ForwardInTime>
@@ -274,6 +293,7 @@ void test_join() {
                                        start_1 + time_step_1};
   const double time_1 = start_1.value();
   const AdaptiveSteppingDiagnostics diagnostics_1{7, 2, 13, 4, 5};
+  const double slab_size_goal_1 = 1.34;
 
   const Slab slab_2(1., 1.5);
   const Time start_2{ForwardInTime ? slab_2.start() : slab_2.end()};
@@ -284,30 +304,34 @@ void test_join() {
                                        start_2 + time_step_2};
   const double time_2 = start_2.value();
   const AdaptiveSteppingDiagnostics diagnostics_2{7, 2, 27, 2, 8};
+  const double slab_size_goal_2 = slab_size_goal_1;
 
   std::unordered_map<ElementId<1>, items_type> children_items;
   children_items.emplace(
       child_1_id,
       items_type{child_1_id, time_step_id_1, next_time_step_id_1, time_step_1,
-                 next_time_step_1, time_1, diagnostics_1});
+                 next_time_step_1, time_1, diagnostics_1, slab_size_goal_1});
   children_items.emplace(
       child_2_id,
       items_type{child_2_id, time_step_id_2, next_time_step_id_2, time_step_2,
-                 next_time_step_2, time_2, diagnostics_2});
+                 next_time_step_2, time_2, diagnostics_2, slab_size_goal_2});
 
   auto parent_box = db::create<
       db::AddSimpleTags<Parallel::Tags::ArrayIndexImpl<ElementId<1>>,
                         ::Tags::TimeStepId, ::Tags::Next<::Tags::TimeStepId>,
                         ::Tags::TimeStep, ::Tags::Next<::Tags::TimeStep>,
-                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics>>(
+                        ::Tags::Time, ::Tags::AdaptiveSteppingDiagnostics,
+                        ::Tags::ChangeSlabSize::SlabSizeGoal>>(
       parent_id, TimeStepId{}, TimeStepId{}, TimeDelta{}, TimeDelta{}, 0.0,
-      AdaptiveSteppingDiagnostics{});
+      AdaptiveSteppingDiagnostics{},
+      std::numeric_limits<double>::signaling_NaN());
 
   db::mutate_apply<Initialization::ProjectTimeStepping<1>>(
       make_not_null(&parent_box), children_items);
 
   check(parent_box, time_step_id_2, next_time_step_id_2, time_step_2,
-        next_time_step_2, time_2, AdaptiveSteppingDiagnostics{7, 2, 40, 6, 13});
+        next_time_step_2, time_2, AdaptiveSteppingDiagnostics{7, 2, 40, 6, 13},
+        slab_size_goal_2);
 }
 }  // namespace
 
diff --git a/tests/Unit/Time/Actions/Test_ChangeStepSize.cpp b/tests/Unit/Time/Actions/Test_ChangeStepSize.cpp
index ddf4273a42ec..00f00dc19f83 100644
--- a/tests/Unit/Time/Actions/Test_ChangeStepSize.cpp
+++ b/tests/Unit/Time/Actions/Test_ChangeStepSize.cpp
@@ -30,6 +30,7 @@
 #include "Time/Tags/TimeStepper.hpp"
 #include "Time/Time.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/TimeSteppers/AdamsBashforth.hpp"
 #include "Time/TimeSteppers/LtsTimeStepper.hpp"
 #include "Utilities/Gsl.hpp"
@@ -57,11 +58,12 @@ struct StepRejector : public StepChooser<StepChooserUse::LtsStep> {
   explicit StepRejector(CkMigrateMessage* /*unused*/) {}
   StepRejector() = default;
 
-  std::pair<double, bool> operator()(const double last_step_magnitude) const {
-    return {last_step_magnitude, false};
+  std::pair<TimeStepRequest, bool> operator()(const double last_step) const {
+    return {{.size_goal = last_step}, false};
   }
 
   bool uses_local_data() const override { return false; }
+  bool can_be_delayed() const override { return true; }
 
   void pup(PUP::er& /*p*/) override {}
 };
diff --git a/tests/Unit/Time/CMakeLists.txt b/tests/Unit/Time/CMakeLists.txt
index d10b3b2f0a26..a8b94e826082 100644
--- a/tests/Unit/Time/CMakeLists.txt
+++ b/tests/Unit/Time/CMakeLists.txt
@@ -18,6 +18,8 @@ set(LIBRARY_SOURCES
   Test_Time.cpp
   Test_TimeSequence.cpp
   Test_TimeStepId.cpp
+  Test_TimeStepRequest.cpp
+  Test_TimeStepRequestProcessor.cpp
   Test_Utilities.cpp
   )
 
diff --git a/tests/Unit/Time/ChangeSlabSize/Test_Action.cpp b/tests/Unit/Time/ChangeSlabSize/Test_Action.cpp
index f262f67ec50a..0fa00fd3a6b3 100644
--- a/tests/Unit/Time/ChangeSlabSize/Test_Action.cpp
+++ b/tests/Unit/Time/ChangeSlabSize/Test_Action.cpp
@@ -5,10 +5,10 @@
 
 #include <cstdint>
 #include <initializer_list>
+#include <map>
 #include <memory>
 #include <string>
-#include <unordered_map>
-#include <unordered_set>
+#include <vector>
 
 #include "DataStructures/DataBox/DataBox.hpp"
 #include "DataStructures/DataBox/Tag.hpp"
@@ -26,6 +26,8 @@
 #include "Time/Tags/TimeStepper.hpp"
 #include "Time/Time.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Time/TimeStepRequestProcessor.hpp"
 #include "Time/TimeSteppers/Rk3HesthavenSsp.hpp"
 #include "Time/TimeSteppers/TimeStepper.hpp"
 #include "Utilities/Gsl.hpp"
@@ -63,7 +65,8 @@ struct Component {
   using simple_tags =
       tmpl::list<Tags::TimeStepId, Tags::Next<Tags::TimeStepId>, Tags::TimeStep,
                  Tags::Next<Tags::TimeStep>, Tags::HistoryEvolvedVariables<Var>,
-                 Tags::AdaptiveSteppingDiagnostics>;
+                 Tags::AdaptiveSteppingDiagnostics,
+                 ::Tags::ChangeSlabSize::SlabSizeGoal>;
   using compute_tags = time_stepper_ref_tags<TimeStepper>;
   using phase_dependent_action_list = tmpl::list<
       Parallel::PhaseActions<Parallel::Phase::Initialization,
@@ -86,6 +89,7 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
   auto& box = ActionTesting::get_databox<Component>(make_not_null(&runner), 0);
 
   for (const bool time_runs_forward : {true, false}) {
+    const double unit_step = time_runs_forward ? 1.0 : -1.0;
     Slab slab(1.5, 2.0);
     Time start_time;
 
@@ -108,19 +112,23 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
     };
 
     db::mutate<Tags::TimeStepId, Tags::Next<Tags::TimeStepId>, Tags::TimeStep,
-               Tags::Next<Tags::TimeStep>, Tags::AdaptiveSteppingDiagnostics>(
+               Tags::Next<Tags::TimeStep>, Tags::AdaptiveSteppingDiagnostics,
+               ::Tags::ChangeSlabSize::SlabSizeGoal>(
         [&get_step, &start_time, &time_runs_forward](
             const gsl::not_null<TimeStepId*> id,
             const gsl::not_null<TimeStepId*> next_id,
             const gsl::not_null<TimeDelta*> step,
             const gsl::not_null<TimeDelta*> next_step,
             const gsl::not_null<AdaptiveSteppingDiagnostics*> diags,
+            const gsl::not_null<double*> slab_size_goal,
             const TimeStepper& stepper) {
           *id = TimeStepId(time_runs_forward, 3, start_time);
           *step = get_step(*id);
           *next_step = get_step(*id);
           *next_id = stepper.next_time_id(*id, *step);
           *diags = AdaptiveSteppingDiagnostics{1, 2, 3, 4, 5};
+          // Step is slab/2 for test
+          *slab_size_goal = (2 * *step).value();
         },
         make_not_null(&box), db::get<Tags::TimeStepper<TimeStepper>>(box));
 
@@ -128,7 +136,8 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
     using NewSize = ::Tags::ChangeSlabSize::NewSlabSize;
 
     const auto check_box = [&box, &get_step](const TimeStepId& id,
-                                             const uint64_t changes) {
+                                             const uint64_t changes,
+                                             const double expected_goal) {
       CHECK(db::get<Tags::TimeStepId>(box) == id);
       CHECK(db::get<Tags::TimeStep>(box) == get_step(id));
       CHECK(db::get<Tags::Next<Tags::TimeStepId>>(box) ==
@@ -136,12 +145,28 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
                 db::get<Tags::TimeStepId>(box), db::get<Tags::TimeStep>(box)));
       CHECK(db::get<Tags::AdaptiveSteppingDiagnostics>(box) ==
             AdaptiveSteppingDiagnostics{1, 2 + changes, 3, 4, 5});
+      CHECK(db::get<::Tags::ChangeSlabSize::SlabSizeGoal>(box) ==
+            expected_goal);
     };
 
     // Nothing to do
     {
       runner.next_action<Component>(0);
-      check_box(TimeStepId(time_runs_forward, 3, start_time), 0);
+      check_box(TimeStepId(time_runs_forward, 3, start_time), 0,
+                ((time_runs_forward ? 1 : -1) * slab.duration()).value());
+    }
+
+    // Nothing to do, but not at the goal.
+    {
+      db::mutate<::Tags::ChangeSlabSize::SlabSizeGoal>(
+          [&unit_step](const gsl::not_null<double*> slab_size_goal) {
+            *slab_size_goal = 2.0 * unit_step;
+          },
+          make_not_null(&box));
+      runner.next_action<Component>(0);
+      resize_slab(2.0);
+      check_box(TimeStepId(time_runs_forward, 3, start_time), 1,
+                2.0 * unit_step);
     }
 
     // Simple case
@@ -155,19 +180,24 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
           make_not_null(&runner), 0));
       db::mutate<NewSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
-                  sizes) { (*sizes)[3].insert(1.0); },
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                  sizes) {
+            (*sizes)[3]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size = unit_step});
+          },
           make_not_null(&box));
 
       runner.next_action<Component>(0);
       resize_slab(1.0);
-      check_box(TimeStepId(time_runs_forward, 3, start_time), 1);
+      check_box(TimeStepId(time_runs_forward, 3, start_time), 2,
+                2.0 * unit_step);
       CHECK(db::get<ExpectedMessages>(box).empty());
       CHECK(db::get<NewSize>(box).empty());
       db::mutate<ExpectedMessages, NewSize>(
           [&](const gsl::not_null<std::map<int64_t, size_t>*> expected,
               const gsl::not_null<
-                  std::map<int64_t, std::unordered_multiset<double>>*>
+                  std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
                   sizes) {
             expected->clear();
             sizes->clear();
@@ -187,15 +217,23 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
           make_not_null(&runner), 0));
       db::mutate<NewSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
-                  sizes) { (*sizes)[3].insert(2.0); },
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                  sizes) {
+            (*sizes)[3]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 2.0 * unit_step});
+          },
           make_not_null(&box));
       REQUIRE_FALSE(ActionTesting::next_action_if_ready<Component>(
           make_not_null(&runner), 0));
       db::mutate<NewSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
-                  sizes) { (*sizes)[4].insert(0.5); },
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                  sizes) {
+            (*sizes)[4]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 0.5 * unit_step});
+          },
           make_not_null(&box));
       REQUIRE_FALSE(ActionTesting::next_action_if_ready<Component>(
           make_not_null(&runner), 0));
@@ -206,12 +244,17 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
           make_not_null(&box));
       db::mutate<NewSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
-                  sizes) { (*sizes)[3].insert(3.0); },
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
+                  sizes) {
+            (*sizes)[3]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 3.0 * unit_step});
+          },
           make_not_null(&box));
       runner.next_action<Component>(0);
       resize_slab(2.0);
-      check_box(TimeStepId(time_runs_forward, 3, start_time), 2);
+      check_box(TimeStepId(time_runs_forward, 3, start_time), 3,
+                2.0 * unit_step);
       CHECK(db::get<ExpectedMessages>(box).size() == 1);
       CHECK(db::get<ExpectedMessages>(box).count(4) == 1);
       CHECK(db::get<NewSize>(box).size() == 1);
@@ -219,7 +262,7 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
       db::mutate<ExpectedMessages, NewSize>(
           [&](const gsl::not_null<std::map<int64_t, size_t>*> expected,
               const gsl::not_null<
-                  std::map<int64_t, std::unordered_multiset<double>>*>
+                  std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
                   sizes) {
             expected->clear();
             sizes->clear();
@@ -247,25 +290,29 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
           },
           make_not_null(&box));
       runner.next_action<Component>(0);
-      check_box(initial_id, 2);
+      check_box(initial_id, 3, 2.0 * unit_step);
       CHECK(db::get<ExpectedMessages>(box).size() == 2);
       CHECK(db::get<ExpectedMessages>(box).count(3) == 1);
       CHECK(db::get<ExpectedMessages>(box).count(4) == 1);
       CHECK(db::get<NewSize>(box).empty());
       db::mutate<NewSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
                   sizes) {
-            (*sizes)[3].insert(0.1);
-            (*sizes)[4].insert(0.1);
+            (*sizes)[3]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 0.1 * unit_step});
+            (*sizes)[4]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 0.1 * unit_step});
           },
           make_not_null(&box));
       runner.next_action<Component>(0);
-      check_box(initial_id, 2);
+      check_box(initial_id, 3, 2.0 * unit_step);
       db::mutate<ExpectedMessages, NewSize>(
           [&](const gsl::not_null<std::map<int64_t, size_t>*> expected,
               const gsl::not_null<
-                  std::map<int64_t, std::unordered_multiset<double>>*>
+                  std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
                   sizes) {
             expected->clear();
             sizes->clear();
@@ -297,25 +344,29 @@ SPECTRE_TEST_CASE("Unit.Time.Actions.ChangeSlabSize", "[Unit][Time][Actions]") {
           },
           make_not_null(&box));
       runner.next_action<Component>(0);
-      check_box(initial_id, 2);
+      check_box(initial_id, 3, 2.0 * unit_step);
       CHECK(db::get<ExpectedMessages>(box).size() == 2);
       CHECK(db::get<ExpectedMessages>(box).count(3) == 1);
       CHECK(db::get<ExpectedMessages>(box).count(4) == 1);
       CHECK(db::get<NewSize>(box).empty());
       db::mutate<NewSize>(
           [&](const gsl::not_null<
-              std::map<int64_t, std::unordered_multiset<double>>*>
+              std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
                   sizes) {
-            (*sizes)[3].insert(0.1);
-            (*sizes)[4].insert(0.1);
+            (*sizes)[3]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 0.1 * unit_step});
+            (*sizes)[4]
+                .emplace_back(time_runs_forward)
+                .process(TimeStepRequest{.size_goal = 0.1 * unit_step});
           },
           make_not_null(&box));
       runner.next_action<Component>(0);
-      check_box(initial_id, 2);
+      check_box(initial_id, 3, 2.0 * unit_step);
       db::mutate<ExpectedMessages, NewSize>(
           [&](const gsl::not_null<std::map<int64_t, size_t>*> expected,
               const gsl::not_null<
-                  std::map<int64_t, std::unordered_multiset<double>>*>
+                  std::map<int64_t, std::vector<TimeStepRequestProcessor>>*>
                   sizes) {
             expected->clear();
             sizes->clear();
diff --git a/tests/Unit/Time/ChangeSlabSize/Test_Tags.cpp b/tests/Unit/Time/ChangeSlabSize/Test_Tags.cpp
index 9ddac39c4715..f14b3605f4fe 100644
--- a/tests/Unit/Time/ChangeSlabSize/Test_Tags.cpp
+++ b/tests/Unit/Time/ChangeSlabSize/Test_Tags.cpp
@@ -14,4 +14,6 @@ SPECTRE_TEST_CASE("Unit.Time.ChangeSlabSize.Tags", "[Unit][Time]") {
   TestHelpers::db::test_simple_tag<
       Tags::ChangeSlabSize::NumberOfExpectedMessages>(
       "NumberOfExpectedMessages");
+  TestHelpers::db::test_simple_tag<Tags::ChangeSlabSize::SlabSizeGoal>(
+      "SlabSizeGoal");
 }
diff --git a/tests/Unit/Time/StepChoosers/CMakeLists.txt b/tests/Unit/Time/StepChoosers/CMakeLists.txt
index 355cbc8cbec4..c01c86593086 100644
--- a/tests/Unit/Time/StepChoosers/CMakeLists.txt
+++ b/tests/Unit/Time/StepChoosers/CMakeLists.txt
@@ -8,7 +8,8 @@ set(LIBRARY_SOURCES
   StepChoosers/Test_Constant.cpp
   StepChoosers/Test_ElementSizeCfl.cpp
   StepChoosers/Test_ErrorControl.cpp
-  StepChoosers/Test_Increase.cpp
+  StepChoosers/Test_LimitIncrease.cpp
+  StepChoosers/Test_Maximum.cpp
   StepChoosers/Test_PreventRapidIncrease.cpp
   StepChoosers/Test_Random.cpp
   StepChoosers/Test_StepToTimes.cpp
diff --git a/tests/Unit/Time/StepChoosers/Test_ByBlock.cpp b/tests/Unit/Time/StepChoosers/Test_ByBlock.cpp
index 23af0e5fcf36..9e8fcdea6089 100644
--- a/tests/Unit/Time/StepChoosers/Test_ByBlock.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_ByBlock.cpp
@@ -18,6 +18,7 @@
 #include "Parallel/Tags/Metavariables.hpp"
 #include "Time/StepChoosers/ByBlock.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
 #include "Utilities/TMPL.hpp"
@@ -56,7 +57,8 @@ void test_by_block() {
         db::AddSimpleTags<Parallel::Tags::MetavariablesImpl<Metavariables>,
                           domain::Tags::Element<volume_dim>>>(Metavariables{},
                                                               element);
-    const double expected = 0.5 * static_cast<double>(block + 5);
+    const TimeStepRequest expected{.size_goal =
+                                       0.5 * static_cast<double>(block + 5)};
 
     CHECK(by_block(element, current_step) == std::make_pair(expected, true));
     CHECK(serialize_and_deserialize(by_block)(element, current_step) ==
diff --git a/tests/Unit/Time/StepChoosers/Test_Cfl.cpp b/tests/Unit/Time/StepChoosers/Test_Cfl.cpp
index 47b0bee7eb4e..082d1dc8770d 100644
--- a/tests/Unit/Time/StepChoosers/Test_Cfl.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_Cfl.cpp
@@ -26,6 +26,7 @@
 #include "Time/StepChoosers/Cfl.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/Tags/TimeStepper.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/TimeSteppers/AdamsBashforth.hpp"
 #include "Time/TimeSteppers/TimeStepper.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
@@ -110,16 +111,18 @@ std::pair<double, bool> get_suggestion(const size_t stepper_order,
 
   const double current_step = std::numeric_limits<double>::infinity();
   const auto result = cfl(grid_spacing, time_stepper, speed, current_step);
+  REQUIRE(result.first.size_goal.has_value());
+  CHECK(result.first == TimeStepRequest{.size_goal = result.first.size_goal});
   CHECK(serialize_and_deserialize(cfl)(grid_spacing, time_stepper, speed,
                                        current_step) == result);
   CHECK_FALSE(result.second);
   const auto accepted_step_result =
-      cfl(grid_spacing, time_stepper, speed, result.first * 0.7);
+      cfl(grid_spacing, time_stepper, speed, *result.first.size_goal * 0.7);
   CHECK(accepted_step_result.second);
   CHECK(cfl_base->desired_step(current_step, box) == result);
   CHECK(serialize_and_deserialize(cfl_base)->desired_step(current_step, box) ==
         result);
-  return result;
+  return {*result.first.size_goal, result.second};
 }
 
 template <typename Use>
diff --git a/tests/Unit/Time/StepChoosers/Test_Constant.cpp b/tests/Unit/Time/StepChoosers/Test_Constant.cpp
index c5a64ff0c3c5..d9240cb6ed11 100644
--- a/tests/Unit/Time/StepChoosers/Test_Constant.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_Constant.cpp
@@ -13,6 +13,7 @@
 #include "Options/Protocols/FactoryCreation.hpp"
 #include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
 #include "Utilities/TMPL.hpp"
@@ -38,21 +39,21 @@ void test_use() {
       db::AddSimpleTags<Parallel::Tags::MetavariablesImpl<Metavariables>>>(
       Metavariables{});
 
-  const StepChoosers::Constant<Use> constant{5.4};
+  // Sign of argument should be ignored.
+  const StepChoosers::Constant<Use> constant{-5.4};
   const std::unique_ptr<StepChooser<Use>> constant_base =
       std::make_unique<StepChoosers::Constant<Use>>(constant);
 
   const double current_step = std::numeric_limits<double>::infinity();
-  CHECK(constant(current_step) == std::make_pair(5.4, true));
-  CHECK(serialize_and_deserialize(constant)(current_step) ==
-        std::make_pair(5.4, true));
-  CHECK(constant_base->desired_step(current_step, box) ==
-        std::make_pair(5.4, true));
+  const std::pair<TimeStepRequest, bool> expected{{.size_goal = 5.4}, true};
+  CHECK(constant(current_step) == expected);
+  CHECK(serialize_and_deserialize(constant)(current_step) == expected);
+  CHECK(constant_base->desired_step(current_step, box) == expected);
   CHECK(serialize_and_deserialize(constant_base)
-            ->desired_step(current_step, box) == std::make_pair(5.4, true));
+            ->desired_step(current_step, box) == expected);
 
   TestHelpers::test_creation<std::unique_ptr<StepChooser<Use>>, Metavariables>(
-      "Constant: 5.4");
+      "Constant: -5.4");
 }
 }  // namespace
 
@@ -63,11 +64,4 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.Constant", "[Unit][Time]") {
   test_use<StepChooserUse::Slab>();
 
   CHECK(not StepChoosers::Constant<StepChooserUse::Slab>{}.uses_local_data());
-
-  CHECK_THROWS_WITH(
-      (TestHelpers::test_creation<
-          std::unique_ptr<StepChooser<StepChooserUse::Slab>>, Metavariables>(
-          "Constant: -5.4")),
-      Catch::Matchers::ContainsSubstring(
-          "Requested step magnitude should be positive"));
 }
diff --git a/tests/Unit/Time/StepChoosers/Test_ElementSizeCfl.cpp b/tests/Unit/Time/StepChoosers/Test_ElementSizeCfl.cpp
index 01ae03cecfd2..fc13eb6598f9 100644
--- a/tests/Unit/Time/StepChoosers/Test_ElementSizeCfl.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_ElementSizeCfl.cpp
@@ -31,6 +31,7 @@
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/Tags/Time.hpp"
 #include "Time/Tags/TimeStepper.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Time/TimeSteppers/AdamsBashforth.hpp"
 #include "Time/TimeSteppers/TimeStepper.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
@@ -109,18 +110,20 @@ std::pair<double, bool> get_suggestion(
   const auto& time_stepper = get<Tags::TimeStepper<TimeStepper>>(box);
 
   const double current_step = std::numeric_limits<double>::infinity();
-  const std::pair<double, bool> result =
+  const auto result =
       element_size_cfl(time_stepper, element_size, speed, current_step);
+  REQUIRE(result.first.size_goal.has_value());
+  CHECK(result.first == TimeStepRequest{.size_goal = result.first.size_goal});
   CHECK_FALSE(result.second);
-  const auto accepted_step_result =
-      element_size_cfl(time_stepper, element_size, speed, result.first * 0.7);
+  const auto accepted_step_result = element_size_cfl(
+      time_stepper, element_size, speed, *result.first.size_goal * 0.7);
   CHECK(accepted_step_result.second);
   CHECK(element_size_base->desired_step(current_step, box) == result);
   CHECK(serialize_and_deserialize(element_size_cfl)(
             time_stepper, element_size, speed, current_step) == result);
   CHECK(serialize_and_deserialize(element_size_base)
             ->desired_step(current_step, box) == result);
-  return result;
+  return {*result.first.size_goal, result.second};
 }
 }  // namespace
 
diff --git a/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp b/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp
index 222bc9defe68..677c6a9d5551 100644
--- a/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_ErrorControl.cpp
@@ -6,7 +6,6 @@
 #include <array>
 #include <cmath>
 #include <cstddef>
-#include <limits>
 #include <memory>
 #include <optional>
 #include <string>
@@ -31,7 +30,7 @@
 #include "Time/Slab.hpp"
 #include "Time/StepChoosers/Constant.hpp"
 #include "Time/StepChoosers/ErrorControl.hpp"
-#include "Time/StepChoosers/Increase.hpp"
+#include "Time/StepChoosers/LimitIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/StepperErrorEstimate.hpp"
 #include "Time/StepperErrorTolerances.hpp"
@@ -39,6 +38,7 @@
 #include "Time/Tags/StepChoosers.hpp"
 #include "Time/Tags/StepperErrorTolerances.hpp"
 #include "Time/Tags/StepperErrors.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/Gsl.hpp"
 #include "Utilities/Literals.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
@@ -75,7 +75,7 @@ template <bool WithErrorControl, bool WithAltErrorControl = false>
 struct Metavariables {
   template <typename Use>
   using step_choosers_without_error_control =
-      tmpl::list<StepChoosers::Increase<Use>, StepChoosers::Constant<Use>>;
+      tmpl::list<StepChoosers::LimitIncrease<Use>, StepChoosers::Constant<Use>>;
   template <typename Use>
   using step_choosers = tmpl::append<
       step_choosers_without_error_control<Use>,
@@ -107,7 +107,7 @@ struct Metavariables {
 using LtsErrorControl =
     StepChoosers::ErrorControl<StepChooserUse::LtsStep, EvolvedVariablesTag>;
 
-std::pair<double, bool> get_suggestion(
+std::pair<std::optional<double>, bool> get_suggestion(
     const LtsErrorControl& error_control,
     const std::optional<StepperErrorEstimate>& error,
     const std::optional<StepperErrorEstimate>& previous_error,
@@ -120,14 +120,15 @@ std::pair<double, bool> get_suggestion(
   const std::unique_ptr<StepChooser<StepChooserUse::LtsStep>>
       error_control_base = std::make_unique<LtsErrorControl>(error_control);
 
-  const std::pair<double, bool> result =
+  const auto result =
       error_control(std::array{previous_error, error}, previous_step);
+  CHECK(result.first == TimeStepRequest{.size_goal = result.first.size_goal});
   CHECK(error_control_base->desired_step(previous_step, box) == result);
   CHECK(serialize_and_deserialize(error_control)(
             std::array{previous_error, error}, previous_step) == result);
   CHECK(serialize_and_deserialize(error_control_base)
             ->desired_step(previous_step, box) == result);
-  return result;
+  return {result.first.size_goal, result.second};
 }
 }  // namespace
 
@@ -136,6 +137,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
 
   const std::vector<size_t> stepper_orders{2_st, 5_st};
   for (const bool time_runs_forward : {true, false}) {
+    const double unit_step = time_runs_forward ? 1.0 : -1.0;
     for (size_t stepper_order : stepper_orders) {
       CAPTURE(stepper_order);
       const auto step_errors = [&](const double error_time, const double error,
@@ -152,8 +154,8 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
       {
         INFO("No data available");
         const LtsErrorControl error_control{5.0e-4, 0.0, 2.0, 0.5, 0.95};
-        const auto result = get_suggestion(error_control, {}, {}, 1.0);
-        CHECK(result.first == std::numeric_limits<double>::infinity());
+        const auto result = get_suggestion(error_control, {}, {}, unit_step);
+        CHECK(not result.first.has_value());
         CHECK(result.second);
       }
       {
@@ -161,37 +163,43 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
         const LtsErrorControl error_control{5.0e-4, 1.0e-3, 2.0, 0.5, 0.95};
         CHECK(error_control.tolerances() ==
               StepperErrorTolerances{.absolute = 5.0e-4, .relative = 1.0e-3});
-        const auto first_result =
-            get_suggestion(error_control, {step_errors(0.0, 0.3)}, {}, 1.0);
-        CHECK(approx(first_result.first) ==
-              0.95 / pow(0.3, 1.0 / stepper_order));
+        const auto first_result = get_suggestion(
+            error_control, {step_errors(0.0, 0.3)}, {}, unit_step);
+        REQUIRE(first_result.first.has_value());
+        CHECK(approx(*first_result.first) ==
+              0.95 * unit_step / pow(0.3, 1.0 / stepper_order));
         CHECK(first_result.second);
         const auto second_result = get_suggestion(
-            error_control, {step_errors(0.0, 0.31, first_result.first)},
-            {step_errors(-1.0, 0.3)}, first_result.first);
-        CHECK(approx(second_result.first) ==
-              0.95 * first_result.first /
+            error_control, {step_errors(0.0, 0.31, abs(*first_result.first))},
+            {step_errors(-1.0, 0.3)}, *first_result.first);
+        REQUIRE(second_result.first.has_value());
+        CHECK(approx(*second_result.first) ==
+              0.95 * *first_result.first /
                   (pow(0.3, -0.4 / stepper_order) *
                    pow(0.31, 0.7 / stepper_order)));
         CHECK(second_result.second);
         // Check that the suggested step size is smaller if the error in
         // increasing faster.
         const auto adjusted_second_result = get_suggestion(
-            error_control, {step_errors(0.0, 0.31, first_result.first)},
-            {step_errors(-1.0, 0.1)}, first_result.first);
-        CHECK(adjusted_second_result.first < second_result.first);
+            error_control, {step_errors(0.0, 0.31, abs(*first_result.first))},
+            {step_errors(-1.0, 0.1)}, *first_result.first);
+        REQUIRE(adjusted_second_result.first.has_value());
+        CHECK(abs(*adjusted_second_result.first) < abs(*second_result.first));
       }
       {
         INFO("Test error control step failure");
         const LtsErrorControl error_control{4.0e-5, 4.0e-5, 2.0, 0.5, 0.95};
-        const auto result_start =
-            get_suggestion(error_control, {step_errors(0.0, 1.2)}, {}, 1.0);
-        const auto result_end =
-            get_suggestion(error_control, {step_errors(-1.0, 1.2)}, {}, 1.0);
+        const auto result_start = get_suggestion(
+            error_control, {step_errors(0.0, 1.2)}, {}, unit_step);
+        REQUIRE(result_start.first.has_value());
+        const auto result_end = get_suggestion(
+            error_control, {step_errors(-1.0, 1.2)}, {}, unit_step);
+        REQUIRE(result_end.first.has_value());
         const auto result_end2 = get_suggestion(
-            error_control, {step_errors(-1.0, 1.2)}, {}, result_end.first);
-        CHECK(approx(result_start.first) ==
-              0.95 / pow(1.2, 1.0 / stepper_order));
+            error_control, {step_errors(-1.0, 1.2)}, {}, *result_end.first);
+        REQUIRE(result_end2.first.has_value());
+        CHECK(approx(*result_start.first) ==
+              0.95 * unit_step / pow(1.2, 1.0 / stepper_order));
         CHECK(result_end.first == result_start.first);
         CHECK(result_end2.first == result_start.first);
         CHECK_FALSE(result_start.second);
@@ -201,16 +209,16 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
       {
         INFO("Test error control clamped minimum");
         const LtsErrorControl error_control{4.0e-5, 4.0e-5, 2.0, 0.9, 0.95};
-        const auto first_result =
-            get_suggestion(error_control, {step_errors(0.0, 10.0)}, {}, 1.0);
-        CHECK(first_result.first == 0.9);
+        const auto first_result = get_suggestion(
+            error_control, {step_errors(0.0, 10.0)}, {}, unit_step);
+        CHECK(first_result.first == std::optional(0.9 * unit_step));
       }
       {
         INFO("Test error control clamped maximum");
         const LtsErrorControl error_control{1.0e-1, 1.0e-1, 2.0, 0.5, 0.95};
-        const auto first_result =
-            get_suggestion(error_control, {step_errors(0.0, 0.01)}, {}, 1.0);
-        CHECK(first_result == std::make_pair(2.0, true));
+        const auto first_result = get_suggestion(
+            error_control, {step_errors(0.0, 0.01)}, {}, unit_step);
+        CHECK(first_result == std::pair(std::optional(2.0 * unit_step), true));
       }
     }
   }
@@ -267,7 +275,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
                   "    RelativeTolerance: 1.0e-4\n"
                   "    MaxFactor: 2.1\n"
                   "    MinFactor: 0.5\n"
-                  "- Increase:\n"
+                  "- LimitIncrease:\n"
                   "    Factor: 2\n"
                   "- Constant: 0.5");
         },
@@ -283,7 +291,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
           *choosers =
               TestHelpers::test_creation<typename Tags::StepChoosers::type,
                                          Metavariables<true, true>>(
-                  "- Increase:\n"
+                  "- LimitIncrease:\n"
                   "    Factor: 2\n"
                   "- Constant: 0.5");
         },
@@ -324,7 +332,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
                   "    RelativeTolerance: 1.0e-4\n"
                   "    MaxFactor: 1.1\n"
                   "    MinFactor: 0.1\n"
-                  "- Increase:\n"
+                  "- LimitIncrease:\n"
                   "    Factor: 2\n"
                   "- Constant: 0.5");
         },
@@ -352,7 +360,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
                   "    RelativeTolerance: 1.0e-8\n"
                   "    MaxFactor: 1.1\n"
                   "    MinFactor: 0.1\n"
-                  "- Increase:\n"
+                  "- LimitIncrease:\n"
                   "    Factor: 2\n"
                   "- Constant: 0.5");
         },
@@ -380,7 +388,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
                   "    RelativeTolerance: 1.0e-8\n"
                   "    MaxFactor: 1.1\n"
                   "    MinFactor: 0.1\n"
-                  "- Increase:\n"
+                  "- LimitIncrease:\n"
                   "    Factor: 2\n"
                   "- Constant: 0.5");
         },
@@ -415,7 +423,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
               "    - ChangeSlabSize:\n"
               "        DelayChange: 0\n"
               "        StepChoosers:\n"
-              "          - Increase:\n"
+              "          - LimitIncrease:\n"
               "              Factor: 2\n"
               "          - ErrorControl:\n"
               "              SafetyFactor: 0.95\n"
@@ -445,7 +453,7 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.ErrorControl", "[Unit][Time]") {
               "    - ChangeSlabSize:\n"
               "        DelayChange: 0\n"
               "        StepChoosers:\n"
-              "          - Increase:\n"
+              "          - LimitIncrease:\n"
               "              Factor: 2\n"
               "          - Constant: 0.5");
         },
diff --git a/tests/Unit/Time/StepChoosers/Test_Increase.cpp b/tests/Unit/Time/StepChoosers/Test_LimitIncrease.cpp
similarity index 64%
rename from tests/Unit/Time/StepChoosers/Test_Increase.cpp
rename to tests/Unit/Time/StepChoosers/Test_LimitIncrease.cpp
index 95e58028f9f7..fdfbd5272abc 100644
--- a/tests/Unit/Time/StepChoosers/Test_Increase.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_LimitIncrease.cpp
@@ -12,8 +12,9 @@
 #include "Framework/TestHelpers.hpp"
 #include "Options/Protocols/FactoryCreation.hpp"
 #include "Parallel/Tags/Metavariables.hpp"
-#include "Time/StepChoosers/Increase.hpp"
+#include "Time/StepChoosers/LimitIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
 #include "Utilities/TMPL.hpp"
@@ -25,35 +26,37 @@ struct Metavariables {
   struct factory_creation
       : tt::ConformsTo<Options::protocols::FactoryCreation> {
     using factory_classes = tmpl::map<
-        tmpl::pair<StepChooser<StepChooserUse::LtsStep>,
-                   tmpl::list<StepChoosers::Increase<StepChooserUse::LtsStep>>>,
-        tmpl::pair<StepChooser<StepChooserUse::Slab>,
-                   tmpl::list<StepChoosers::Increase<StepChooserUse::Slab>>>>;
+        tmpl::pair<
+            StepChooser<StepChooserUse::LtsStep>,
+            tmpl::list<StepChoosers::LimitIncrease<StepChooserUse::LtsStep>>>,
+        tmpl::pair<
+            StepChooser<StepChooserUse::Slab>,
+            tmpl::list<StepChoosers::LimitIncrease<StepChooserUse::Slab>>>>;
   };
   using component_list = tmpl::list<>;
 };
 }  // namespace
 
-SPECTRE_TEST_CASE("Unit.Time.StepChoosers.Increase", "[Unit][Time]") {
+SPECTRE_TEST_CASE("Unit.Time.StepChoosers.LimitIncrease", "[Unit][Time]") {
   register_factory_classes_with_charm<Metavariables>();
 
   auto box = db::create<
       db::AddSimpleTags<Parallel::Tags::MetavariablesImpl<Metavariables>>>(
       Metavariables{});
   const auto check = [&box](auto use, const double step,
-                            const double expected) {
+                            const double expected_size) {
     using Use = tmpl::type_from<decltype(use)>;
-    const StepChoosers::Increase<Use> increase{5.};
+    const StepChoosers::LimitIncrease<Use> increase{5.};
     const std::unique_ptr<StepChooser<Use>> increase_base =
-        std::make_unique<StepChoosers::Increase<Use>>(increase);
+        std::make_unique<StepChoosers::LimitIncrease<Use>>(increase);
 
-    CHECK(increase(step) == std::make_pair(expected, true));
-    CHECK(serialize_and_deserialize(increase)(step) ==
-          std::make_pair(expected, true));
-    CHECK(increase_base->desired_step(step, box) ==
-          std::make_pair(expected, true));
+    const std::pair<TimeStepRequest, bool> expected{{.size = expected_size},
+                                                    true};
+    CHECK(increase(step) == expected);
+    CHECK(serialize_and_deserialize(increase)(step) == expected);
+    CHECK(increase_base->desired_step(step, box) == expected);
     CHECK(serialize_and_deserialize(increase_base)->desired_step(step, box) ==
-          std::make_pair(expected, true));
+          expected);
   };
   check(tmpl::type_<StepChooserUse::LtsStep>{}, 0.25, 1.25);
   check(tmpl::type_<StepChooserUse::Slab>{}, 0.25, 1.25);
@@ -66,12 +69,13 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.Increase", "[Unit][Time]") {
 
   TestHelpers::test_creation<
       std::unique_ptr<StepChooser<StepChooserUse::LtsStep>>, Metavariables>(
-      "Increase:\n"
+      "LimitIncrease:\n"
       "  Factor: 5.0");
   TestHelpers::test_creation<std::unique_ptr<StepChooser<StepChooserUse::Slab>>,
                              Metavariables>(
-      "Increase:\n"
+      "LimitIncrease:\n"
       "  Factor: 5.0");
 
-  CHECK(not StepChoosers::Increase<StepChooserUse::Slab>{}.uses_local_data());
+  CHECK(not StepChoosers::LimitIncrease<StepChooserUse::Slab>{}
+                .uses_local_data());
 }
diff --git a/tests/Unit/Time/StepChoosers/Test_Maximum.cpp b/tests/Unit/Time/StepChoosers/Test_Maximum.cpp
new file mode 100644
index 000000000000..c87d2d1bb6d6
--- /dev/null
+++ b/tests/Unit/Time/StepChoosers/Test_Maximum.cpp
@@ -0,0 +1,65 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Framework/TestingFramework.hpp"
+
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "DataStructures/DataBox/DataBox.hpp"
+#include "Framework/TestCreation.hpp"
+#include "Framework/TestHelpers.hpp"
+#include "Options/Protocols/FactoryCreation.hpp"
+#include "Time/StepChoosers/Maximum.hpp"
+#include "Time/StepChoosers/StepChooser.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Utilities/ProtocolHelpers.hpp"
+#include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
+#include "Utilities/TMPL.hpp"
+
+namespace {
+struct Metavariables {
+  struct factory_creation
+      : tt::ConformsTo<Options::protocols::FactoryCreation> {
+    using factory_classes = tmpl::map<
+        tmpl::pair<StepChooser<StepChooserUse::LtsStep>,
+                   tmpl::list<StepChoosers::Maximum<StepChooserUse::LtsStep>>>,
+        tmpl::pair<StepChooser<StepChooserUse::Slab>,
+                   tmpl::list<StepChoosers::Maximum<StepChooserUse::Slab>>>>;
+  };
+  using component_list = tmpl::list<>;
+};
+
+template <typename Use>
+void test_use() {
+  auto box = db::create<
+      db::AddSimpleTags<Parallel::Tags::MetavariablesImpl<Metavariables>>>(
+      Metavariables{});
+
+  // Sign of argument should be ignored.
+  const StepChoosers::Maximum<Use> maximum{-5.4};
+  const std::unique_ptr<StepChooser<Use>> maximum_base =
+      std::make_unique<StepChoosers::Maximum<Use>>(maximum);
+
+  const double current_step = std::numeric_limits<double>::infinity();
+  const std::pair<TimeStepRequest, bool> expected{{.size = 5.4}, true};
+  CHECK(maximum(current_step) == expected);
+  CHECK(serialize_and_deserialize(maximum)(current_step) == expected);
+  CHECK(maximum_base->desired_step(current_step, box) == expected);
+  CHECK(serialize_and_deserialize(maximum_base)
+            ->desired_step(current_step, box) == expected);
+
+  TestHelpers::test_creation<std::unique_ptr<StepChooser<Use>>, Metavariables>(
+      "Maximum: 5.4");
+}
+}  // namespace
+
+SPECTRE_TEST_CASE("Unit.Time.StepChoosers.Maximum", "[Unit][Time]") {
+  register_factory_classes_with_charm<Metavariables>();
+
+  test_use<StepChooserUse::LtsStep>();
+  test_use<StepChooserUse::Slab>();
+
+  CHECK(not StepChoosers::Maximum<StepChooserUse::Slab>{}.uses_local_data());
+}
diff --git a/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp b/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
index ea0da0e5b09b..c0df6dae9c2b 100644
--- a/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_PreventRapidIncrease.cpp
@@ -9,6 +9,7 @@
 #include <initializer_list>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <utility>
 #include <vector>
 
@@ -24,6 +25,7 @@
 #include "Time/Tags/HistoryEvolvedVariables.hpp"
 #include "Time/Time.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
 #include "Utilities/StdHelpers.hpp"
@@ -55,13 +57,15 @@ void check_case(const Frac& expected_frac, const std::vector<Frac>& times) {
   CAPTURE(expected_frac);
 
   const Slab slab(0.25, 1.5);
-  const double expected = expected_frac == -1
-                              ? std::numeric_limits<double>::infinity()
-                              : (expected_frac * slab.duration()).value();
-
   for (const auto& direction : {1, -1}) {
     CAPTURE(direction);
 
+    const std::optional<double> expected_size =
+        expected_frac == -1
+            ? std::nullopt
+            : std::optional(
+                  (direction * expected_frac * slab.duration()).value());
+
     const auto make_time_id = [&direction, &slab, &times](const size_t i) {
       Frac frac = -direction * times[i];
       int64_t slab_number = 0;
@@ -100,28 +104,27 @@ void check_case(const Frac& expected_frac, const std::vector<Frac>& times) {
       gts_history.insert_initial(make_gts_time_id(i), 0.0, 0.0);
     }
 
-    const auto check = [&expected](auto use, const auto& box,
-                                   const Time& current_time) {
+    const auto check = [&direction, &expected_size](auto use, const auto& box,
+                                                    const Time& current_time) {
       using Use = tmpl::type_from<decltype(use)>;
       const auto& history = db::get<history_tag>(box);
       const double current_step =
           history.size() > 0
-              ? abs(current_time - history.back().time_step_id.step_time())
-                    .value()
-              : std::numeric_limits<double>::infinity();
+              ? (current_time - history.back().time_step_id.step_time()).value()
+              : direction * std::numeric_limits<double>::infinity();
 
       const StepChoosers::PreventRapidIncrease<Use> relax{};
       const std::unique_ptr<StepChooser<Use>> relax_base =
           std::make_unique<StepChoosers::PreventRapidIncrease<Use>>(relax);
 
-      CHECK(relax(history, current_step) == std::make_pair(expected, true));
+      const std::pair<TimeStepRequest, bool> expected{{.size = expected_size},
+                                                      true};
+      CHECK(relax(history, current_step) == expected);
       CHECK(serialize_and_deserialize(relax)(history, current_step) ==
-            std::make_pair(expected, true));
-      CHECK(relax_base->desired_step(current_step, box) ==
-            std::make_pair(expected, true));
+            expected);
+      CHECK(relax_base->desired_step(current_step, box) == expected);
       CHECK(serialize_and_deserialize(relax_base)
-                ->desired_step(current_step, box) ==
-            std::make_pair(expected, true));
+                ->desired_step(current_step, box) == expected);
     };
 
     {
@@ -165,8 +168,7 @@ void check_substep_methods() {
                             (slab.start() + slab.duration() / 2).value()),
                  0.0, 0.0);
   const StepChoosers::PreventRapidIncrease<StepChooserUse::Slab> relax{};
-  CHECK(relax(history, 3.14) ==
-        std::make_pair(std::numeric_limits<double>::infinity(), true));
+  CHECK(relax(history, 3.14) == std::pair(TimeStepRequest{}, true));
 }
 }  // namespace
 
@@ -176,15 +178,16 @@ SPECTRE_TEST_CASE("Unit.Time.StepChoosers.PreventRapidIncrease",
 
   // -1 indicates no expected restriction
   check_case(-1, {0});
-  check_case(-1, {{2, 5}});
-  check_case(-1, {0, {2, 5}});
-  check_case(-1, {{1, 5}, {2, 5}, {3, 5}});
-  check_case(-1, {{4, 5}, {5, 5}, {6, 5}});
-  check_case({1, 5}, {{4, 5}, {5, 5}, {7, 5}});
-  check_case({2, 5}, {{3, 5}, {5, 5}, {6, 5}});
-  check_case(-1, {{1, 5}, {2, 5}, {3, 5}, {4, 5}});
-  check_case({2, 5}, {{0, 5}, {2, 5}, {3, 5}, {4, 5}});
-  check_case({1, 20}, {{1, 5}, {1, 4}, {3, 5}, {4, 5}});
+  check_case(-1, {{5, 8}});
+  check_case(-1, {0, {5, 8}});
+  check_case(-1, {{4, 8}, {5, 8}, {6, 8}});
+  check_case(-1, {{7, 8}, {8, 8}, {9, 8}});
+  check_case(-1, {{7, 8}, {8, 8}, {10, 8}});
+  check_case({1, 8}, {{7, 8}, {8, 8}, {17, 16}});
+  check_case({2, 8}, {{6, 8}, {8, 8}, {9, 8}});
+  check_case(-1, {{4, 8}, {5, 8}, {6, 8}, {7, 8}});
+  check_case({2, 8}, {{3, 8}, {5, 8}, {6, 8}, {7, 8}});
+  check_case({1, 8}, {{4, 8}, {5, 8}, {7, 8}, {8, 8}});
 
   // Cause roundoff errors
   check_case(-1, {{1, 3}, {2, 3}, {3, 3}});
diff --git a/tests/Unit/Time/StepChoosers/Test_Random.cpp b/tests/Unit/Time/StepChoosers/Test_Random.cpp
index d109a87122a0..c896ca026cd1 100644
--- a/tests/Unit/Time/StepChoosers/Test_Random.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_Random.cpp
@@ -22,6 +22,7 @@
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/Tags/TimeStepId.hpp"
 #include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/MakeString.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
@@ -69,13 +70,15 @@ double get_suggestion(const double min, const double max, const size_t seed,
   CHECK(random.uses_local_data());
 
   const auto result = random(element, time_step_id, current_step);
+  REQUIRE(result.first.size_goal.has_value());
+  CHECK(result.first == TimeStepRequest{.size_goal = result.first.size_goal});
   // Should be deterministic
   CHECK(result == random(element, time_step_id, current_step));
 
   CHECK(result.second);
 
-  CHECK(result.first >= min);
-  CHECK(result.first <= max);
+  CHECK(*result.first.size_goal >= min);
+  CHECK(*result.first.size_goal <= max);
 
   CHECK(serialize_and_deserialize(random)(element, time_step_id,
                                           current_step) == result);
@@ -84,7 +87,7 @@ double get_suggestion(const double min, const double max, const size_t seed,
       serialize_and_deserialize(random_base)->desired_step(current_step, box) ==
       result);
 
-  return result.first;
+  return *result.first.size_goal;
 }
 
 template <typename Use>
diff --git a/tests/Unit/Time/StepChoosers/Test_StepToTimes.cpp b/tests/Unit/Time/StepChoosers/Test_StepToTimes.cpp
index 135602be4bf6..8cb997fb19c1 100644
--- a/tests/Unit/Time/StepChoosers/Test_StepToTimes.cpp
+++ b/tests/Unit/Time/StepChoosers/Test_StepToTimes.cpp
@@ -6,6 +6,7 @@
 #include <cmath>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <pup.h>
 #include <utility>
 #include <vector>
@@ -18,9 +19,9 @@
 #include "Time/Slab.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/StepChoosers/StepToTimes.hpp"
-#include "Time/Tags/TimeStepId.hpp"
+#include "Time/Tags/Time.hpp"
 #include "Time/TimeSequence.hpp"
-#include "Time/TimeStepId.hpp"
+#include "Time/TimeStepRequest.hpp"
 #include "Utilities/Algorithm.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
@@ -38,93 +39,89 @@ struct Metavariables {
   };
   using component_list = tmpl::list<>;
 };
-}  // namespace
-
-SPECTRE_TEST_CASE("Unit.Time.StepChoosers.StepToTimes", "[Unit][Time]") {
-  register_factory_classes_with_charm<Metavariables>();
 
-  const auto requested = [](const double now, std::vector<double> times,
-                            const double step) {
-    double result = -1.0;
-    const auto impl = [&result, &step](const TimeStepId& now_id,
-                                       const std::vector<double>& impl_times) {
-      CAPTURE(now_id);
-      CAPTURE(impl_times);
-      CAPTURE(step);
-
-      using Specified = TimeSequences::Specified<double>;
-      const StepChoosers::StepToTimes step_to_times(
-          std::make_unique<Specified>(impl_times));
-      const std::unique_ptr<StepChooser<StepChooserUse::Slab>>
-          step_to_times_base = std::make_unique<StepChoosers::StepToTimes>(
-              std::make_unique<Specified>(impl_times));
-
-      auto box = db::create<db::AddSimpleTags<
-          Parallel::Tags::MetavariablesImpl<Metavariables>, Tags::TimeStepId>>(
-          Metavariables{}, now_id);
-
-      const auto answer = step_to_times(now_id, step);
-      if (result == -1.0) {
-        result = answer.first;
-      } else {
-        CHECK(result == answer.first);
-      }
-      CHECK(step_to_times_base->desired_step(step, box) ==
-            std::make_pair(result, true));
-      CHECK(serialize_and_deserialize(step_to_times)(now_id, step) ==
-            std::make_pair(result, true));
-      CHECK(serialize_and_deserialize(step_to_times_base)
-                ->desired_step(step, box) == std::make_pair(result, true));
-    };
-    impl(TimeStepId(true, 0, Slab(now, now + 1.0).start()), times);
-    alg::for_each(times, [](double& x) { return x = -x; });
-    impl(TimeStepId(false, 0, Slab(-now, -now + 1.0).start()), times);
-    return result;
+void check_case(const double now, std::vector<double> times,
+                const std::optional<double>& expected_end) {
+  const auto impl = [](const double local_now, const double last_step,
+                       const std::vector<double>& impl_times) {
+    CAPTURE(local_now);
+    CAPTURE(impl_times);
+
+    using Specified = TimeSequences::Specified<double>;
+    const StepChoosers::StepToTimes step_to_times(
+        std::make_unique<Specified>(impl_times));
+    const std::unique_ptr<StepChooser<StepChooserUse::Slab>>
+        step_to_times_base = std::make_unique<StepChoosers::StepToTimes>(
+            std::make_unique<Specified>(impl_times));
+
+    auto box = db::create<db::AddSimpleTags<
+        Parallel::Tags::MetavariablesImpl<Metavariables>, Tags::Time>>(
+        Metavariables{}, local_now);
+
+    const auto answer = step_to_times(local_now, last_step);
+    CHECK(answer.second);
+
+    const auto& request = answer.first;
+    CHECK(request.end == request.end_hard_limit);
+    REQUIRE(request.size.has_value() == request.end.has_value());
+    CHECK(not request.size_goal.has_value());
+    CHECK(not request.size_hard_limit.has_value());
+
+    CHECK(step_to_times_base->desired_step(last_step, box) == answer);
+    CHECK(serialize_and_deserialize(step_to_times)(local_now, last_step) ==
+          answer);
+    CHECK(serialize_and_deserialize(step_to_times_base)
+              ->desired_step(last_step, box) == answer);
+    return request.end.has_value()
+               ? std::optional(std::pair(*request.end, *request.size))
+               : std::nullopt;
   };
-
-  static constexpr double infinity = std::numeric_limits<double>::infinity();
-
-  CHECK(requested(3.0, {}, infinity) == infinity);
-  CHECK(requested(3.0, {1.0}, infinity) == infinity);
-  CHECK(requested(3.0, {3.0}, infinity) == infinity);
-  CHECK(requested(3.0, {5.0}, infinity) == 2.0);
-  {
-    const double request = requested(3.0, {5.0}, 1.0);
-    CHECK(request > 1.0);
-    CHECK(request < 2.0);
-  }
-  {
-    const double request = requested(3.0, {5.0}, 1.9375);
-    CHECK(request > 1.0);
-    CHECK(request < 1.9375);
+  const auto result = impl(now, 1.0, times);
+  alg::for_each(times, [](double& x) { return x = -x; });
+  const auto backwards_result = impl(-now, -1.0, times);
+  CHECK(backwards_result.has_value() == result.has_value());
+  if (result.has_value()) {
+    CHECK(backwards_result ==
+          std::optional(std::pair(-result->first, -result->second)));
   }
-  {
-    const double request = requested(3.0, {5.0}, 1.0625);
-    CHECK(request > 1.0);
-    CHECK(request < 2.0);
+
+  CHECK(result.has_value() == expected_end.has_value());
+  if (expected_end.has_value()) {
+    CHECK(result == std::optional(std::pair(
+                        *expected_end, 2.0 / 3.0 * (*expected_end - now))));
   }
+}
+}  // namespace
+
+SPECTRE_TEST_CASE("Unit.Time.StepChoosers.StepToTimes", "[Unit][Time]") {
+  register_factory_classes_with_charm<Metavariables>();
 
-  const auto one_five_check = [&requested](const std::vector<double>& times) {
-    CHECK(requested(0.0, times, infinity) == 1.0);
-    CHECK(requested(1.0, times, infinity) == 4.0);
-    CHECK(requested(2.0, times, infinity) == 3.0);
-    CHECK(requested(5.0, times, infinity) == infinity);
-    CHECK(requested(7.0, times, infinity) == infinity);
+  check_case(3.0, {}, {});
+  check_case(3.0, {1.0}, {});
+  check_case(3.0, {3.0}, {});
+  check_case(3.0, {5.0}, {5.0});
+
+  const auto one_five_check = [](const std::vector<double>& times) {
+    check_case(0.0, times, {1.0});
+    check_case(1.0, times, {5.0});
+    check_case(2.0, times, {5.0});
+    check_case(5.0, times, {});
+    check_case(7.0, times, {});
   };
 
   one_five_check({1.0, 5.0});
   one_five_check({5.0, 1.0});
   one_five_check({1.0, 5.0, 1.0, 5.0, 1.0, 5.0});
 
-  const auto check_rounding = [&requested](const double start,
-                                           const double step) {
+  const auto check_rounding = [](const double start, const double step) {
     CAPTURE(start);
     CAPTURE(step);
-    auto scaled_approx = Approx::custom().scale(std::abs(start));
-    CHECK(requested(std::nextafter(start, +infinity), {start, start + step},
-                    infinity) == scaled_approx(step));
-    CHECK(requested(std::nextafter(start, -infinity), {start, start + step},
-                    infinity) == scaled_approx(step));
+    static constexpr double infinity = std::numeric_limits<double>::infinity();
+    check_case(std::nextafter(start, -infinity), {start, start + step},
+               {start});
+    check_case(start, {start, start + step}, {start + step});
+    check_case(std::nextafter(start, +infinity), {start, start + step},
+               {start + step});
   };
 
   check_rounding(0.0, 1.0);
diff --git a/tests/Unit/Time/Test_TakeStep.cpp b/tests/Unit/Time/Test_TakeStep.cpp
index 5346107ab0d4..49904089235c 100644
--- a/tests/Unit/Time/Test_TakeStep.cpp
+++ b/tests/Unit/Time/Test_TakeStep.cpp
@@ -21,7 +21,7 @@
 #include "Time/ChooseLtsStepSize.hpp"
 #include "Time/Slab.hpp"
 #include "Time/StepChoosers/Cfl.hpp"
-#include "Time/StepChoosers/Increase.hpp"
+#include "Time/StepChoosers/LimitIncrease.hpp"
 #include "Time/StepChoosers/StepChooser.hpp"
 #include "Time/StepperErrorTolerances.hpp"
 #include "Time/Tags/AdaptiveSteppingDiagnostics.hpp"
@@ -68,12 +68,11 @@ struct Metavariables {
 
   struct factory_creation
       : tt::ConformsTo<Options::protocols::FactoryCreation> {
-    using factory_classes = tmpl::map<
-        tmpl::pair<StepChooser<StepChooserUse::LtsStep>,
-                   tmpl::list<StepChoosers::Increase<StepChooserUse::LtsStep>,
-                              StepChoosers::Cfl<
-                                  StepChooserUse::LtsStep, Frame::Inertial,
-                                  typename Metavariables::system>>>>;
+    using factory_classes = tmpl::map<tmpl::pair<
+        StepChooser<StepChooserUse::LtsStep>,
+        tmpl::list<StepChoosers::LimitIncrease<StepChooserUse::LtsStep>,
+                   StepChoosers::Cfl<StepChooserUse::LtsStep, Frame::Inertial,
+                                     typename Metavariables::system>>>>;
   };
 
   using component_list = tmpl::list<>;
@@ -140,7 +139,8 @@ void test_lts() {
   std::vector<std::unique_ptr<StepChooser<StepChooserUse::LtsStep>>>
       step_choosers;
   step_choosers.emplace_back(
-      std::make_unique<StepChoosers::Increase<StepChooserUse::LtsStep>>(2.0));
+      std::make_unique<StepChoosers::LimitIncrease<StepChooserUse::LtsStep>>(
+          2.0));
   step_choosers.emplace_back(
       std::make_unique<
           StepChoosers::Cfl<StepChooserUse::LtsStep, Frame::Inertial,
diff --git a/tests/Unit/Time/Test_TimeStepRequest.cpp b/tests/Unit/Time/Test_TimeStepRequest.cpp
new file mode 100644
index 000000000000..6608d9659db4
--- /dev/null
+++ b/tests/Unit/Time/Test_TimeStepRequest.cpp
@@ -0,0 +1,34 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Framework/TestingFramework.hpp"
+
+#include <optional>
+
+#include "Framework/TestHelpers.hpp"
+#include "Time/TimeStepRequest.hpp"
+
+namespace {
+void check_eq(std::optional<double> TimeStepRequest::* const field) {
+  const TimeStepRequest request{{1.0}, {2.0}, {3.0}, {4.0}, {5.0}};
+  auto request2 = request;
+  (request2.*field).reset();
+  CHECK(request != request2);
+  CHECK_FALSE(request == request2);
+}
+
+SPECTRE_TEST_CASE("Unit.Time.TimeStepRequest", "[Unit][Time]") {
+  CHECK(TimeStepRequest{{1.0}, {2.0}, {3.0}, {4.0}, {5.0}} ==
+        TimeStepRequest{{1.0}, {2.0}, {3.0}, {4.0}, {5.0}});
+  CHECK_FALSE(TimeStepRequest{{1.0}, {2.0}, {3.0}, {4.0}, {5.0}} !=
+              TimeStepRequest{{1.0}, {2.0}, {3.0}, {4.0}, {5.0}});
+
+  check_eq(&TimeStepRequest::size_goal);
+  check_eq(&TimeStepRequest::size);
+  check_eq(&TimeStepRequest::end);
+  check_eq(&TimeStepRequest::size_hard_limit);
+  check_eq(&TimeStepRequest::end_hard_limit);
+
+  test_serialization(TimeStepRequest{{1.0}, {2.0}, {3.0}, {4.0}, {5.0}});
+}
+}  // namespace
diff --git a/tests/Unit/Time/Test_TimeStepRequestProcessor.cpp b/tests/Unit/Time/Test_TimeStepRequestProcessor.cpp
new file mode 100644
index 000000000000..ea8a5679fb0a
--- /dev/null
+++ b/tests/Unit/Time/Test_TimeStepRequestProcessor.cpp
@@ -0,0 +1,345 @@
+// Distributed under the MIT License.
+// See LICENSE.txt for details.
+
+#include "Framework/TestingFramework.hpp"
+
+#include <algorithm>
+#include <cstddef>
+#include <optional>
+#include <vector>
+
+#include "Framework/TestHelpers.hpp"
+#include "Time/TimeStepRequest.hpp"
+#include "Time/TimeStepRequestProcessor.hpp"
+#include "Utilities/Literals.hpp"
+#include "Utilities/Numeric.hpp"
+
+namespace {
+// Test processing requests in all orders, with different subsets
+// combined first.
+void test_permutations_roundoff(const std::vector<TimeStepRequest>& requests,
+                                const double start, const double goal,
+                                const std::optional<double>& expected_goal,
+                                const double expected_step,
+                                const double expected_end) {
+  std::vector<size_t> ordering(requests.size());
+  alg::iota(ordering, 0_st);
+  std::vector<size_t> partition{};
+  partition.reserve(requests.size());
+  do {
+    partition.clear();
+    partition.push_back(requests.size());
+    for (;;) {
+      {
+        TimeStepRequestProcessor processor(goal > 0.0);
+        TimeStepRequestProcessor processor2(goal > 0.0);
+        size_t index = 0;
+        for (const size_t partition_element : partition) {
+          TimeStepRequestProcessor element_processor(goal > 0.0);
+          for (size_t i = 0; i < partition_element; ++i) {
+            element_processor.process(requests[ordering[index]]);
+            ++index;
+          }
+          processor2 = processor + element_processor;
+          processor += serialize_and_deserialize(element_processor);
+          CHECK(processor == processor2);
+          CHECK_FALSE(processor != processor2);
+        }
+        CHECK(processor.new_step_size_goal() == expected_goal);
+        CHECK(processor.step_size(start, goal) == expected_step);
+        CHECK(processor.step_end(start, goal) == expected_end);
+        CHECK(processor2.new_step_size_goal() == expected_goal);
+        CHECK(processor2.step_size(start, goal) == expected_step);
+        CHECK(processor2.step_end(start, goal) == expected_end);
+      }
+
+      if (requests.empty() or partition.size() == requests.size()) {
+        break;
+      }
+      size_t trailing_ones = 0;
+      while (partition.back() == 1) {
+        ++trailing_ones;
+        partition.pop_back();
+      }
+      --partition.back();
+      partition.push_back(trailing_ones + 1);
+    }
+  } while (std::next_permutation(ordering.begin(), ordering.end()));
+}
+
+// Test processing requests in all orders, with different subsets
+// combined first.  This version computes the step end from the step
+// size, so only works for the non-roundoff-sensitive tests, but it
+// removes a lot of redundancy in those.
+void test_permutations(const std::vector<TimeStepRequest>& requests,
+                       const double start, const double goal,
+                       const std::optional<double>& expected_goal,
+                       const double expected_step) {
+  test_permutations_roundoff(requests, start, goal, expected_goal,
+                             expected_step, start + expected_step);
+}
+
+void test_with_roundoff(const double start, const double step,
+                        const double end) {
+  CAPTURE(start);
+  CAPTURE(step);
+  CAPTURE(end);
+  test_permutations_roundoff({}, start, step, {}, step, start + step);
+
+  test_permutations_roundoff({{.size_goal = step}}, start, 0.5 * step, {step},
+                             step, start + step);
+  test_permutations_roundoff({{.size = step}}, start, 2.0 * step, {}, step,
+                             start + step);
+  test_permutations_roundoff({{.end = end}}, start, 2.0 * step, {}, end - start,
+                             end);
+
+  test_permutations_roundoff({{.size_goal = 0.5 * step}}, start, step,
+                             {0.5 * step}, 0.5 * step, start + 0.5 * step);
+  test_permutations_roundoff({{.size = 0.5 * step}}, start, step, {},
+                             0.5 * step, start + 0.5 * step);
+  test_permutations_roundoff({{.size_goal = 2.0 * step}}, start, step,
+                             {2.0 * step}, 2.0 * step, start + 2.0 * step);
+  test_permutations_roundoff({{.size = 2.0 * step}}, start, step, {}, step,
+                             start + step);
+
+  const double far_end = end + 0.5 * step;
+  const double close_end = start + 0.5 * step;
+  test_permutations_roundoff({{.end = close_end}}, start, step, {},
+                             close_end - start, close_end);
+  test_permutations_roundoff({{.end = far_end}}, start, step, {}, step,
+                             start + step);
+
+  // Test using the looser limit when two are given.
+  test_permutations_roundoff({{.size = step, .end = start + 0.5 * step}}, start,
+                             2.0 * step, {}, step, start + step);
+  test_permutations_roundoff({{.size = 0.5 * step, .end = end}}, start,
+                             2.0 * step, {}, end - start, end);
+}
+
+void test_processor(const bool time_runs_forward) {
+  const double time_sign = time_runs_forward ? 1.0 : -1.0;
+
+  {
+    const double start = 2.0 * time_sign;
+    const double end = 5.0 * time_sign;
+    const double step = end - start;
+    // Ignore roundoff subtleties for this part of the test.
+    CHECK(start + step == end);
+
+    {
+      TimeStepRequestProcessor processor(time_runs_forward);
+      CHECK(processor == TimeStepRequestProcessor(time_runs_forward));
+      CHECK_FALSE(processor != TimeStepRequestProcessor(time_runs_forward));
+      CHECK(processor != TimeStepRequestProcessor(not time_runs_forward));
+      CHECK_FALSE(processor == TimeStepRequestProcessor(not time_runs_forward));
+      processor.process({.end = end});
+      CHECK(processor != TimeStepRequestProcessor(time_runs_forward));
+      CHECK_FALSE(processor == TimeStepRequestProcessor(time_runs_forward));
+    }
+
+    // No requests.
+    test_permutations({}, start, step, {}, step);
+    test_permutations({{}}, start, step, {}, step);
+    test_permutations({{}, {}}, start, step, {}, step);
+
+    // Simple goal setting requests.
+    test_permutations({{.size_goal = 0.5 * step}}, start, step, {0.5 * step},
+                      0.5 * step);
+    test_permutations({{.size_goal = 2.0 * step}}, start, step, {2.0 * step},
+                      2.0 * step);
+
+    // Simple step size requests.
+    test_permutations({{.size = 0.5 * step}}, start, step, {}, 0.5 * step);
+    test_permutations({{.size = 2.0 * step}}, start, step, {}, step);
+
+    // Simple step end requests.
+    test_permutations({{.end = start + 0.5 * step}}, start, step, {},
+                      0.5 * step);
+    test_permutations({{.end = start + 2.0 * step}}, start, step, {}, step);
+
+    // Multiple requests of the same type.
+    test_permutations({{.size_goal = 0.5 * step}, {.size_goal = 0.25 * step}},
+                      start, step, {0.25 * step}, 0.25 * step);
+    test_permutations({{.size = 0.5 * step}, {.size = 0.25 * step}}, start,
+                      step, {}, 0.25 * step);
+    test_permutations(
+        {{.end = start + 0.5 * step}, {.end = start + 0.25 * step}}, start,
+        step, {}, 0.25 * step);
+
+    // Multiple requests of different types.
+    // size_goal wins
+    test_permutations({{.size_goal = 0.5 * step}, {.size = 0.6 * step}}, start,
+                      step, {0.5 * step}, 0.5 * step);
+    test_permutations({{.size_goal = 0.5 * step}, {.end = start + 0.6 * step}},
+                      start, step, {0.5 * step}, 0.5 * step);
+    test_permutations({{.size_goal = 0.5 * step},
+                       {.size = 0.6 * step},
+                       {.end = start + 0.6 * step}},
+                      start, step, {0.5 * step}, 0.5 * step);
+    // size wins
+    test_permutations({{.size_goal = 0.6 * step}, {.size = 0.5 * step}}, start,
+                      step, {0.6 * step}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step}, {.end = start + 0.6 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size_goal = 0.6 * step},
+                       {.size = 0.5 * step},
+                       {.end = start + 0.6 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+    // end wins
+    test_permutations({{.size_goal = 0.6 * step}, {.end = start + 0.5 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step}, {.end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size_goal = 0.6 * step},
+                       {.size = 0.6 * step},
+                       {.end = start + 0.5 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+
+    // Requests with both .size and .end are fulfilled if either is
+    // used without adjustment.
+    test_permutations({{.size_goal = 0.6 * step,
+                        .size = 0.4 * step,
+                        .end = start + 0.5 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+    test_permutations({{.size_goal = 0.6 * step,
+                        .size = 0.5 * step,
+                        .end = start + 0.4 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+    test_permutations({{.size = 0.4 * step, .end = start + 0.5 * step}}, start,
+                      step, {}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step, .end = start + 0.4 * step}}, start,
+                      step, {}, 0.5 * step);
+    // .size_goal doesn't participate in that.
+    test_permutations({{.size_goal = 0.5 * step, .end = start + 0.6 * step}},
+                      start, step, {0.5 * step}, 0.5 * step);
+    test_permutations({{.size_goal = 0.6 * step, .end = start + 0.5 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+
+    // Repeats don't affect the result.
+    test_permutations({{.size = 0.4 * step, .end = start + 0.5 * step},
+                       {.size = 0.4 * step, .end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step, .end = start + 0.4 * step},
+                       {.size = 0.5 * step, .end = start + 0.4 * step}},
+                      start, step, {}, 0.5 * step);
+
+    // Less stringent requirements don't affect that, either.
+    test_permutations(
+        {{.size = 0.4 * step, .end = start + 0.5 * step}, {.size = 0.6 * step}},
+        start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.4 * step, .end = start + 0.5 * step},
+                       {.end = start + 0.6 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations(
+        {{.size = 0.5 * step, .end = start + 0.4 * step}, {.size = 0.6 * step}},
+        start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step, .end = start + 0.4 * step},
+                       {.end = start + 0.6 * step}},
+                      start, step, {}, 0.5 * step);
+
+    // Requests with both .size and .end usually must satisfy both in
+    // other cases.
+    test_permutations({{.size = 0.5 * step, .end = start + 0.6 * step},
+                       {.size = 0.55 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step, .end = start + 0.5 * step},
+                       {.size = 0.55 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step, .end = start + 0.6 * step},
+                       {.end = start + 0.55 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step, .end = start + 0.5 * step},
+                       {.end = start + 0.55 * step}},
+                      start, step, {}, 0.5 * step);
+
+    // Including when other requests partially duplicate them.
+    test_permutations(
+        {{.size = 0.5 * step, .end = start + 0.6 * step}, {.size = 0.5 * step}},
+        start, step, {}, 0.5 * step);
+    test_permutations(
+        {{.size = 0.6 * step, .end = start + 0.5 * step}, {.size = 0.5 * step}},
+        start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step, .end = start + 0.6 * step},
+                       {.end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step, .end = start + 0.5 * step},
+                       {.end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.5 * step, .end = start + 0.6 * step},
+                       {.size = 0.5 * step},
+                       {.end = start + 0.6 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step, .end = start + 0.5 * step},
+                       {.size = 0.6 * step},
+                       {.end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+
+    // And when multiple different ones occur.
+    test_permutations({{.size = 0.7 * step, .end = start + 0.6 * step},
+                       {.size = 0.65 * step, .end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.7 * step, .end = start + 0.6 * step},
+                       {.size = 0.5 * step, .end = start + 0.65 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step, .end = start + 0.7 * step},
+                       {.size = 0.65 * step, .end = start + 0.5 * step}},
+                      start, step, {}, 0.5 * step);
+    test_permutations({{.size = 0.6 * step, .end = start + 0.7 * step},
+                       {.size = 0.5 * step, .end = start + 0.65 * step}},
+                      start, step, {}, 0.5 * step);
+
+    // Test with several entries.
+    test_permutations({{.size_goal = 0.6 * step, .size = 0.5 * step},
+                       {.size_goal = 0.7 * step},
+                       {.size = 0.6 * step},
+                       {.end = start + 0.6 * step},
+                       {.end = start + 0.7 * step}},
+                      start, step, {0.6 * step}, 0.5 * step);
+
+    // Hard limits don't affect the suggestion
+    test_permutations({{.size_hard_limit = 0.5 * step}}, start, step, {}, step);
+    test_permutations({{.end_hard_limit = start + 0.5 * step}}, start, step, {},
+                      step);
+
+    {
+      TimeStepRequestProcessor processor(step > 0.0);
+      processor.process({.size_hard_limit = step, .end_hard_limit = end});
+      processor.error_on_hard_limit(0.9 * step, start);
+      processor.error_on_hard_limit(step, end);
+      CHECK_THROWS_WITH(
+          processor.error_on_hard_limit(1.1 * step, end),
+          Catch::Matchers::ContainsSubstring("Could not adjust step below ") and
+              Catch::Matchers::ContainsSubstring(
+                  " to meet maximum step size "));
+      CHECK_THROWS_WITH(
+          processor.error_on_hard_limit(step, start + 1.1 * step),
+          Catch::Matchers::ContainsSubstring(
+              "Could not adjust step to before ") and
+              Catch::Matchers::ContainsSubstring(" to avoid exceeding time "));
+    }
+  }
+
+  {
+    const double start = -1.0e20 * time_sign;
+    const double end = 1.0 * time_sign;
+    const double step = 1.0e20 * time_sign;
+    CHECK(end - start == step);
+    CHECK(start + step != end);
+    test_with_roundoff(start, step, end);
+  }
+
+  {
+    const double start = 1.0 * time_sign;
+    const double end = (1.0 + 1.0e-10) * time_sign;
+    const double step = (1.0e-10 + 1.0e-20) * time_sign;
+    CHECK(end - start != step);
+    CHECK(start + step == end);
+    test_with_roundoff(start, step, end);
+  }
+}
+
+SPECTRE_TEST_CASE("Unit.Time.TimeStepRequestProcessor", "[Unit][Time]") {
+  test_processor(true);
+  test_processor(false);
+}
+}  // namespace
diff --git a/tests/Unit/Time/Triggers/Test_Times.cpp b/tests/Unit/Time/Triggers/Test_Times.cpp
index 40b20d98c0c7..9223ad629fdd 100644
--- a/tests/Unit/Time/Triggers/Test_Times.cpp
+++ b/tests/Unit/Time/Triggers/Test_Times.cpp
@@ -3,12 +3,7 @@
 
 #include "Framework/TestingFramework.hpp"
 
-#include <cmath>
-#include <initializer_list>
-#include <limits>
 #include <memory>
-#include <pup.h>
-#include <pup_stl.h>
 #include <vector>
 
 #include "DataStructures/DataBox/DataBox.hpp"
@@ -17,11 +12,8 @@
 #include "Options/Protocols/FactoryCreation.hpp"
 #include "Parallel/Tags/Metavariables.hpp"
 #include "ParallelAlgorithms/EventsAndTriggers/Trigger.hpp"
-#include "Time/Slab.hpp"
 #include "Time/Tags/Time.hpp"
-#include "Time/Tags/TimeStepId.hpp"
 #include "Time/TimeSequence.hpp"
-#include "Time/TimeStepId.hpp"
 #include "Time/Triggers/Times.hpp"
 #include "Utilities/ProtocolHelpers.hpp"
 #include "Utilities/Serialization/RegisterDerivedClassesWithCharm.hpp"
@@ -43,46 +35,27 @@ struct Metavariables {
 SPECTRE_TEST_CASE("Unit.Time.Triggers.Times", "[Unit][Time]") {
   register_factory_classes_with_charm<Metavariables>();
 
-  const auto check = [](const double time, const double slab_size,
+  const auto check = [](const double time,
                         const std::vector<double>& trigger_times,
                         const bool expected) {
     CAPTURE(time);
-    CAPTURE(slab_size);
     CAPTURE(trigger_times);
-    const auto slab = Slab::with_duration_from_start(0.8 * time, slab_size);
-    // None of the arguments here should matter, except that they are
-    // based on the correct slab.
-    const TimeStepId time_id(false, 12, slab.start() + slab.duration() / 13);
-
     const std::unique_ptr<Trigger> trigger = std::make_unique<Triggers::Times>(
         std::make_unique<TimeSequences::Specified<double>>(trigger_times));
     const auto sent_trigger = serialize_and_deserialize(trigger);
 
-    const auto box = db::create<
-        db::AddSimpleTags<Parallel::Tags::MetavariablesImpl<Metavariables>,
-                          Tags::TimeStepId, Tags::Time>>(
-        Metavariables{}, time_id, time);
+    const auto box = db::create<db::AddSimpleTags<
+        Parallel::Tags::MetavariablesImpl<Metavariables>, Tags::Time>>(
+        Metavariables{}, time);
     CHECK(trigger->is_triggered(box) == expected);
     CHECK(sent_trigger->is_triggered(box) == expected);
   };
 
-  static constexpr double infinity = std::numeric_limits<double>::infinity();
-
-  check(1.0, 1.0, {}, false);
-  check(1.0, 1.0, {1.0}, true);
-  check(1.0, 1.0, {2.0}, false);
-  check(1.0, 1.0, {0.0, 1.0, 2.0}, true);
-  check(1.0, 1.0, {2.0, 1.0, 0.0}, true);
-  check(std::nextafter(1.0, +infinity), 1.0, {0.0, 1.0, 2.0}, true);
-  check(std::nextafter(1.0, -infinity), 1.0, {0.0, 1.0, 2.0}, true);
-
-  check(1.0e5, 1.0, {1.0e5}, true);
-  check(std::nextafter(1.0e5, +infinity), 1.0, {1.0e5}, true);
-  check(std::nextafter(1.0e5, -infinity), 1.0, {1.0e5}, true);
-
-  const double inaccurate_1 = 1.0 + 1.0e5 - std::nextafter(1.0e5, -infinity);
-  check(inaccurate_1, 1.0, {1.0}, false);
-  check(inaccurate_1, 1.0e5, {1.0}, true);
+  check(1.0, {}, false);
+  check(1.0, {1.0}, true);
+  check(1.0, {2.0}, false);
+  check(1.0, {0.0, 1.0, 2.0}, true);
+  check(1.0, {2.0, 1.0, 0.0}, true);
 
   TestHelpers::test_creation<std::unique_ptr<Trigger>, Metavariables>(
       "Times:\n"