diff --git a/apps/factory/service.cc b/apps/factory/service.cc
index 4079781..71e968d 100644
--- a/apps/factory/service.cc
+++ b/apps/factory/service.cc
@@ -58,7 +58,7 @@
       break;
     case factory_Test_Type_BME688:
       PW_LOG_INFO("Configured for BME688 air sensor test");
-      air_sensor_->Init(*pubsub_, pw::chrono::VirtualSystemClock::RealClock());
+      air_sensor_->Init();
       break;
   }
 
diff --git a/apps/production/main.cc b/apps/production/main.cc
index 0cc951c..abc7157 100644
--- a/apps/production/main.cc
+++ b/apps/production/main.cc
@@ -40,7 +40,9 @@
 
 void InitEventTimers() {
   auto& pubsub = system::PubSub();
-  static EventTimers<0> event_timers(pubsub);
+  static EventTimers<2> event_timers(pubsub);
+  event_timers.AddEventTimer(StateManager::kSilenceAlarmsToken);
+  event_timers.AddEventTimer(StateManager::kThresholdModeToken);
   pubsub.SubscribeTo<TimerRequest>(
       [](TimerRequest request) { event_timers.OnTimerRequest(request); });
 }
@@ -91,26 +93,6 @@
   static AirSensor& air_sensor = sense::system::AirSensor();
   static sense::AirSensorService air_sensor_service;
   air_sensor_service.Init(system::GetWorker(), air_sensor);
-
-  // Publish LED values based on gas resistance samples.
-  system::PubSub().SubscribeTo<AirQuality>([](AirQuality event) {
-    system::PubSub().Publish(
-        LedValueAirQualityMode(AirSensor::GetLedValue(event.score)));
-  });
-
-  // Update the alarm threshold based on button presses.
-  system::PubSub().SubscribeTo<AirQualityThreshold>(
-      [](AirQualityThreshold event) {
-        system::AirSensor().SetThresholds(event.alarm, event.silence);
-      });
-
-  system::PubSub().SubscribeTo<AlarmSilenceRequest>(
-      [](AlarmSilenceRequest request) {
-        auto duration = pw::chrono::SystemClock::for_at_least(
-            std::chrono::seconds(request.seconds));
-        system::AirSensor().Silence(duration);
-      });
-
   pw::System().rpc_server().RegisterService(air_sensor_service);
 }
 
diff --git a/modules/air_sensor/BUILD.bazel b/modules/air_sensor/BUILD.bazel
index f3651b5..84da72d 100644
--- a/modules/air_sensor/BUILD.bazel
+++ b/modules/air_sensor/BUILD.bazel
@@ -30,9 +30,7 @@
         "@pigweed//pw_log",
     ],
     deps = [
-        "//modules/edge_detector:hysteresis_edge_detector",
         "//modules/pubsub:events",
-        "@pigweed//pw_chrono:system_clock",
         "@pigweed//pw_metric:metric",
         "@pigweed//pw_result",
         "@pigweed//pw_status",
@@ -59,9 +57,6 @@
     deps = [
         ":air_sensor",
         ":air_sensor_fake",
-        "//modules/pubsub:events",
-        "//modules/worker:test_worker",
-        "@pigweed//pw_chrono:simulated_system_clock",
         "@pigweed//pw_sync:timed_thread_notification",
         "@pigweed//pw_thread:test_thread_context",
         "@pigweed//pw_thread:thread",
diff --git a/modules/air_sensor/air_sensor.cc b/modules/air_sensor/air_sensor.cc
index ece66d0..221610b 100644
--- a/modules/air_sensor/air_sensor.cc
+++ b/modules/air_sensor/air_sensor.cc
@@ -45,10 +45,6 @@
   return LedValue(red, green, blue);
 }
 
-AirSensor::AirSensor() : edge_detector_(0, 0) {
-  SetThresholds(Score::kYellow, Score::kLightGreen);
-}
-
 float AirSensor::temperature() const {
   std::lock_guard lock(lock_);
   return temperature_.value();
@@ -74,37 +70,6 @@
   return score_.value();
 }
 
-pw::Status AirSensor::Init(PubSub& pubsub,
-                           pw::chrono::VirtualSystemClock& clock) {
-  pubsub_ = &pubsub;
-  clock_ = &clock;
-  return DoInit();
-}
-
-void AirSensor::SetThresholds(uint16_t alarm, uint16_t silence) {
-  std::lock_guard lock(lock_);
-  edge_detector_.set_low_and_high_thresholds(alarm, silence);
-  PW_LOG_INFO(
-      "Air quality thresholds set: alarm at %u, silence at %u", alarm, silence);
-  edge_detector_.Update(kMaxScore);
-}
-
-void AirSensor::SetThresholds(Score alarm, Score silence) {
-  SetThresholds(static_cast<uint16_t>(alarm), static_cast<uint16_t>(silence));
-}
-
-void AirSensor::Silence(pw::chrono::SystemClock::duration duration) {
-  // Set by `Init`.
-  PW_CHECK_NOTNULL(clock_);
-  PW_CHECK_NOTNULL(pubsub_);
-
-  {
-    std::lock_guard lock(lock_);
-    ignore_until_ = clock_->now() + duration;
-  }
-  pubsub_->Publish(AlarmStateChange{.alarm = false});
-}
-
 pw::Result<uint16_t> AirSensor::MeasureSync() {
   pw::sync::ThreadNotification notification;
   PW_TRY(Measure(notification));
@@ -117,14 +82,6 @@
                        float humidity,
                        float gas_resistance) {
   std::lock_guard lock(lock_);
-  // If the alarmed was silenced for some duration that has now elapsed, reset
-  // the edge detector to the highest value.
-  if (ignore_until_.has_value() && clock_ != nullptr &&
-      *ignore_until_ <= clock_->now()) {
-    ignore_until_.reset();
-    edge_detector_.Update(kMaxScore);
-  }
-
   // Record the sensor data.
   temperature_.Set(temperature);
   pressure_.Set(pressure);
@@ -158,20 +115,6 @@
   float score = ((quality - average) / stddev) + 3.f;
   score = std::min(std::max(score * 256.f, 0.f), static_cast<float>(kMaxScore));
   score_.Set(static_cast<uint32_t>(score));
-
-  // Check if a threshold was crossed.
-  if (pubsub_ != nullptr) {
-    switch (edge_detector_.Update(score_.value())) {
-      case Edge::kFalling:
-        pubsub_->Publish(AlarmStateChange{.alarm = true});
-        break;
-      case Edge::kRising:
-        pubsub_->Publish(AlarmStateChange{.alarm = false});
-        break;
-      case Edge::kNone:
-        break;
-    }
-  }
 }
 
 }  // namespace sense
diff --git a/modules/air_sensor/air_sensor.h b/modules/air_sensor/air_sensor.h
index 2cf864c..07f58bc 100644
--- a/modules/air_sensor/air_sensor.h
+++ b/modules/air_sensor/air_sensor.h
@@ -13,9 +13,7 @@
 // the License.
 #pragma once
 
-#include "modules/edge_detector/hysteresis_edge_detector.h"
 #include "modules/pubsub/pubsub_events.h"
-#include "pw_chrono/system_clock.h"
 #include "pw_metric/metric.h"
 #include "pw_result/result.h"
 #include "pw_status/status.h"
@@ -55,8 +53,6 @@
 
   static constexpr uint16_t kMaxScore = static_cast<uint16_t>(Score::kBlue);
   static constexpr uint16_t kAverageScore = static_cast<uint16_t>(Score::kCyan);
-  static constexpr uint16_t kDefaultTheshold =
-      static_cast<uint16_t>(Score::kYellow);
 
   static LedValue GetLedValue(uint16_t score);
 
@@ -78,15 +74,7 @@
   uint16_t score() const PW_LOCKS_EXCLUDED(lock_);
 
   /// Sets up the sensor.
-  pw::Status Init(PubSub& pubsub, pw::chrono::VirtualSystemClock& clock);
-
-  /// Sets the thresholds at which the air sensor will raise or silence an
-  /// alarm.
-  void SetThresholds(uint16_t alarm, uint16_t silence);
-  void SetThresholds(Score alarm, Score silence);
-
-  /// Silences the alarm until the given time has elapsed.
-  void Silence(pw::chrono::SystemClock::duration duration);
+  pw::Status Init() { return DoInit(); }
 
   /// Requests an air measurement.
   ///
@@ -105,7 +93,7 @@
   void LogMetrics() { metrics_.Dump(); }
 
  protected:
-  AirSensor();
+  AirSensor() = default;
 
   /// Records the results of an air measurement.
   void Update(float temperature,
@@ -125,29 +113,20 @@
 
   mutable pw::sync::InterruptSpinLock lock_;
 
-  // Thread safety: set by `Init`, `const` after that.
-  PubSub* pubsub_ = nullptr;
-  pw::chrono::VirtualSystemClock* clock_ = nullptr;
-
-  HysteresisEdgeDetector<uint16_t> edge_detector_ PW_GUARDED_BY(lock_);
-  std::optional<pw::chrono::SystemClock::time_point> ignore_until_
-      PW_GUARDED_BY(lock_);
-
   // Thread safety: metric values should be atomic.
   //
   // Currently, they are not due to a bug, so they are guarded by
   // `lock_`. Unfortunately it isn't possible to use a PW_GUARDED_BY annotation
   // on them.
-
   PW_METRIC_GROUP(metrics_, "air sensor");
 
-  // // Directly read values.
+  // Directly read values.
   PW_METRIC(metrics_, temperature_, "ambient temperature", kDefaultTemperature);
   PW_METRIC(metrics_, pressure_, "barometric pressure", kDefaultPressure);
   PW_METRIC(metrics_, humidity_, "relative humidity", kDefaultHumidity);
   PW_METRIC(metrics_, gas_resistance_, "gas resistance", kDefaultGasResistance);
 
-  // // Derived values.
+  // Derived values.
   PW_METRIC(metrics_, count_, "number of measurements", 0u);
   PW_METRIC(metrics_, quality_, "current air quality", 0.f);
   PW_METRIC(metrics_, average_, "average air quality", 0.f);
diff --git a/modules/air_sensor/air_sensor_test.cc b/modules/air_sensor/air_sensor_test.cc
index b2d769d..f9b28f5 100644
--- a/modules/air_sensor/air_sensor_test.cc
+++ b/modules/air_sensor/air_sensor_test.cc
@@ -15,11 +15,6 @@
 #include "modules/air_sensor/air_sensor.h"
 
 #include "modules/air_sensor/air_sensor_fake.h"
-#include "modules/pubsub/pubsub.h"
-#include "modules/pubsub/pubsub_events.h"
-#include "modules/worker/test_worker.h"
-#include "pw_chrono/simulated_system_clock.h"
-#include "pw_status/try.h"
 #include "pw_sync/timed_thread_notification.h"
 #include "pw_thread/test_thread_context.h"
 #include "pw_thread/thread.h"
@@ -30,25 +25,10 @@
 // Test fixtures.
 
 class AirSensorTest : public ::testing::Test {
- public:
-  AirSensorTest()
-      : ::testing::Test(),
-        pubsub_(worker_, event_queue_, subscribers_buffer_) {}
-
  protected:
   using Score = AirSensor::Score;
 
-  void SetUp() override {
-    air_sensor_.Init(pubsub_, clock_);
-    air_sensor_.SetThresholds(Score::kYellow, Score::kLightGreen);
-    pubsub_.SubscribeTo<AlarmStateChange>([this](AlarmStateChange event) {
-      {
-        std::lock_guard lock(alarm_lock_);
-        alarm_state_ = event.alarm;
-      }
-      response_.release();
-    });
-  }
+  void SetUp() override { air_sensor_.Init(); }
 
   void MeasureRepeated(size_t n) {
     for (size_t i = 0; i < n; ++i) {
@@ -65,34 +45,9 @@
     }
   }
 
-  pw::Status TriggerAlarm() {
-    air_sensor_.set_gas_resistance(AirSensor::kDefaultGasResistance / 10);
-    uint16_t score;
-    PW_TRY_ASSIGN(score, air_sensor_.MeasureSync());
-    auto threshold = static_cast<uint16_t>(Score::kYellow);
-    EXPECT_LT(score, threshold);
-    return score < threshold ? pw::OkStatus() : pw::Status::OutOfRange();
-  }
-
-  void TearDown() override { worker_.Stop(); }
-
-  bool alarm_state() {
-    std::lock_guard lock_(alarm_lock_);
-    return alarm_state_;
-  }
-
-  sense::TestWorker<> worker_;
-  pw::InlineDeque<Event, 4> event_queue_;
-  std::array<PubSub::Subscriber, 4> subscribers_buffer_;
-  PubSub pubsub_;
-  pw::chrono::SimulatedSystemClock clock_;
-
   AirSensorFake air_sensor_;
   pw::sync::TimedThreadNotification request_;
   pw::sync::TimedThreadNotification response_;
-
-  pw::sync::InterruptSpinLock alarm_lock_;
-  bool alarm_state_ PW_GUARDED_BY(alarm_lock_) = false;
 };
 
 // Unit tests.
@@ -188,95 +143,4 @@
   thread.join();
 }
 
-TEST_F(AirSensorTest, TriggerAlarm) {
-  MeasureRepeated(1000);
-  ASSERT_EQ(TriggerAlarm(), pw::OkStatus());
-  response_.acquire();
-  EXPECT_TRUE(alarm_state());
-}
-
-TEST_F(AirSensorTest, RecoverFromAlarm) {
-  MeasureRepeated(1000);
-  ASSERT_EQ(TriggerAlarm(), pw::OkStatus());
-  response_.acquire();
-  EXPECT_TRUE(alarm_state());
-
-  air_sensor_.set_gas_resistance(50000.f);
-  pw::Result<uint16_t> score = air_sensor_.MeasureSync();
-  ASSERT_EQ(score.status(), pw::OkStatus());
-  ASSERT_GT(*score, 640);
-  response_.acquire();
-  EXPECT_FALSE(alarm_state());
-}
-
-TEST_F(AirSensorTest, SilenceAlarm) {
-  MeasureRepeated(1000);
-  ASSERT_EQ(TriggerAlarm(), pw::OkStatus());
-  response_.acquire();
-  EXPECT_TRUE(alarm_state());
-
-  air_sensor_.Silence(
-      pw::chrono::SystemClock::for_at_least(std::chrono::hours(1)));
-  response_.acquire();
-  EXPECT_FALSE(alarm_state());
-}
-
-TEST_F(AirSensorTest, RetriggerAlarmLater) {
-  MeasureRepeated(1000);
-  ASSERT_EQ(TriggerAlarm(), pw::OkStatus());
-  response_.acquire();
-  EXPECT_TRUE(alarm_state());
-
-  auto duration =
-      pw::chrono::SystemClock::for_at_least(std::chrono::milliseconds(100));
-  air_sensor_.Silence(duration);
-  response_.acquire();
-  EXPECT_FALSE(alarm_state());
-
-  clock_.AdvanceTime(duration);
-  air_sensor_.MeasureSync().IgnoreError();
-  response_.acquire();
-  EXPECT_TRUE(alarm_state());
-}
-
-TEST_F(AirSensorTest, DelayAlarmWhenSilenced) {
-  MeasureRepeated(1000);
-
-  auto duration =
-      pw::chrono::SystemClock::for_at_least(std::chrono::milliseconds(100));
-  air_sensor_.Silence(duration);
-  response_.acquire();
-  EXPECT_FALSE(alarm_state());
-
-  auto start = clock_.now();
-  ASSERT_EQ(TriggerAlarm(), pw::OkStatus());
-
-  clock_.AdvanceTime(duration);
-  response_.acquire();
-  EXPECT_TRUE(alarm_state());
-
-  EXPECT_GE(clock_.now() - start, duration);
-}
-
-TEST_F(AirSensorTest, ChangeThresholdWhileSilenced) {
-  MeasureRepeated(1000);
-  ASSERT_EQ(TriggerAlarm(), pw::OkStatus());
-  response_.acquire();
-  EXPECT_TRUE(alarm_state());
-
-  auto duration =
-      pw::chrono::SystemClock::for_at_least(std::chrono::milliseconds(100));
-  air_sensor_.Silence(duration);
-  response_.acquire();
-  EXPECT_FALSE(alarm_state());
-
-  uint16_t score = air_sensor_.score();
-  air_sensor_.SetThresholds(score / 2,
-                            static_cast<uint16_t>(Score::kLightGreen));
-
-  // Alarm should not retrigger.
-  EXPECT_FALSE(response_.try_acquire_for(duration));
-  EXPECT_FALSE(alarm_state());
-}
-
 }  // namespace sense
diff --git a/modules/pubsub/pubsub.proto b/modules/pubsub/pubsub.proto
index 6e2d8b6..dc8adb7 100644
--- a/modules/pubsub/pubsub.proto
+++ b/modules/pubsub/pubsub.proto
@@ -39,11 +39,6 @@
   uint32 repeat = 2;
 }
 
-message AirQualityThreshold {
-  uint32 alarm = 1;
-  uint32 silence = 2;
-}
-
 message TimerRequest {
   uint32 token = 1;
   uint32 timeout_s = 2;
@@ -57,21 +52,17 @@
   // This definition must be kept up to date with
   // modules/pubsub/pubsub_events.h.
   oneof type {
-    bool alarm = 1;
-    bool button_a_pressed = 2;
-    bool button_b_pressed = 3;
-    bool button_x_pressed = 4;
-    bool button_y_pressed = 5;
-    bool proximity = 6;
-    uint32 proximity_level = 7;
-    uint32 air_quality = 8;
-    MorseCodeValue morse_code_value = 9;
-    LedValue led_value_air_quality = 10;
-    TimerRequest timer_request = 11;
-    TimerExpired timer_expired = 12;
-    morse_code.SendRequest morse_encode_request = 13;
-    AirQualityThreshold air_quality_threshold = 14;
-    uint32 alarm_silence = 15;
-    float ambient_light_lux = 16;
+    bool button_a_pressed = 1;
+    bool button_b_pressed = 2;
+    bool button_x_pressed = 3;
+    bool button_y_pressed = 4;
+    bool proximity = 5;
+    uint32 proximity_level = 6;
+    uint32 air_quality = 7;
+    MorseCodeValue morse_code_value = 8;
+    TimerRequest timer_request = 9;
+    TimerExpired timer_expired = 10;
+    morse_code.SendRequest morse_encode_request = 11;
+    float ambient_light_lux = 12;
   }
 }
diff --git a/modules/pubsub/pubsub_events.h b/modules/pubsub/pubsub_events.h
index 9efd3bf..404bddf 100644
--- a/modules/pubsub/pubsub_events.h
+++ b/modules/pubsub/pubsub_events.h
@@ -20,11 +20,6 @@
 
 namespace sense {
 
-// VOC / CO2 crossed over the threshold.
-struct AlarmStateChange {
-  bool alarm;
-};
-
 // Base for button state changes.
 class ButtonStateChange {
  public:
@@ -78,20 +73,6 @@
   uint16_t score;
 };
 
-/// Air quality thresholds.
-///
-/// When the score falls below `alarm`, the air sensor will trigger an alarm.
-/// When the score rises above `silence`, the air sensor will silence the alarm.
-struct AirQualityThreshold {
-  uint16_t alarm;
-  uint16_t silence;
-};
-
-/// Request to suppress alarms for some time, regardless of air quality score.
-struct AlarmSilenceRequest {
-  uint16_t seconds;
-};
-
 class LedValue {
  public:
   explicit constexpr LedValue(uint8_t r, uint8_t g, uint8_t b)
@@ -110,12 +91,6 @@
   uint8_t b_;
 };
 
-class LedValueAirQualityMode : public LedValue {
- public:
-  using LedValue::LedValue;
-  explicit LedValueAirQualityMode(const LedValue& parent) : LedValue(parent) {}
-};
-
 struct TimerRequest {
   uint32_t token;
   uint16_t timeout_s;
@@ -137,39 +112,31 @@
 
 // This definition must be kept up to date with modules/pubsub/pubsub.proto and
 // the EventType enum.
-using Event = std::variant<AlarmStateChange,
-                           AlarmSilenceRequest,
-                           ButtonA,
+using Event = std::variant<ButtonA,
                            ButtonB,
                            ButtonX,
                            ButtonY,
-                           LedValueAirQualityMode,
                            TimerRequest,
                            TimerExpired,
                            ProximityStateChange,
                            ProximitySample,
                            AmbientLightSample,
                            AirQuality,
-                           AirQualityThreshold,
                            MorseEncodeRequest,
                            MorseCodeValue>;
 
 // Index versions of Event variants, to support finding the event
 enum EventType : size_t {
-  kAlarmStateChange,
-  kAlarmSilenceRequest,
   kButtonA,
   kButtonB,
   kButtonX,
   kButtonY,
-  kLedValueAirQualityMode,
   kTimerRequest,
   kTimerExpired,
   kProximityStateChange,
   kProximitySample,
   kAmbientLightSample,
   kAirQuality,
-  kAirQualityThreshold,
   kMorseEncodeRequest,
   kMorseCodeValue,
   kLastEventType = kMorseCodeValue,
diff --git a/modules/pubsub/service.cc b/modules/pubsub/service.cc
index 13b3321..8d992c0 100644
--- a/modules/pubsub/service.cc
+++ b/modules/pubsub/service.cc
@@ -20,25 +20,10 @@
 namespace sense {
 namespace {
 
-pubsub_LedValue LedValueToProto(const LedValue& value) {
-  pubsub_LedValue proto;
-  proto.r = value.r();
-  proto.g = value.g();
-  proto.b = value.b();
-  return proto;
-}
-
-LedValue LedValueFromProto(const pubsub_LedValue& proto) {
-  return LedValue(proto.r, proto.g, proto.b);
-}
-
 pubsub_Event EventToProto(const Event& event) {
   pubsub_Event proto = pubsub_Event_init_default;
 
-  if (std::holds_alternative<AlarmStateChange>(event)) {
-    proto.which_type = pubsub_Event_alarm_tag;
-    proto.type.alarm = std::get<AlarmStateChange>(event).alarm;
-  } else if (std::holds_alternative<ButtonA>(event)) {
+  if (std::holds_alternative<ButtonA>(event)) {
     proto.which_type = pubsub_Event_button_a_pressed_tag;
     proto.type.button_a_pressed = std::get<ButtonA>(event).pressed();
   } else if (std::holds_alternative<ButtonB>(event)) {
@@ -50,10 +35,6 @@
   } else if (std::holds_alternative<ButtonY>(event)) {
     proto.which_type = pubsub_Event_button_y_pressed_tag;
     proto.type.button_y_pressed = std::get<ButtonY>(event).pressed();
-  } else if (std::holds_alternative<LedValueAirQualityMode>(event)) {
-    proto.which_type = pubsub_Event_led_value_air_quality_tag;
-    proto.type.led_value_air_quality =
-        LedValueToProto(std::get<LedValueAirQualityMode>(event));
   } else if (std::holds_alternative<TimerRequest>(event)) {
     proto.which_type = pubsub_Event_timer_request_tag;
     auto& timer_request = std::get<TimerRequest>(event);
@@ -76,14 +57,6 @@
   } else if (std::holds_alternative<AirQuality>(event)) {
     proto.which_type = pubsub_Event_air_quality_tag;
     proto.type.air_quality = std::get<AirQuality>(event).score;
-  } else if (std::holds_alternative<AirQualityThreshold>(event)) {
-    proto.which_type = pubsub_Event_air_quality_threshold_tag;
-    auto& air_quality_threshold = std::get<AirQualityThreshold>(event);
-    proto.type.air_quality_threshold.alarm = air_quality_threshold.alarm;
-    proto.type.air_quality_threshold.silence = air_quality_threshold.silence;
-  } else if (std::holds_alternative<AlarmSilenceRequest>(event)) {
-    proto.which_type = pubsub_Event_alarm_silence_tag;
-    proto.type.alarm_silence = std::get<AlarmSilenceRequest>(event).seconds;
   } else if (std::holds_alternative<MorseEncodeRequest>(event)) {
     proto.which_type = pubsub_Event_morse_encode_request_tag;
     const auto& morse = std::get<MorseEncodeRequest>(event);
@@ -104,8 +77,6 @@
 
 pw::Result<Event> ProtoToEvent(const pubsub_Event& proto) {
   switch (proto.which_type) {
-    case pubsub_Event_alarm_tag:
-      return AlarmStateChange{.alarm = proto.type.alarm};
     case pubsub_Event_button_a_pressed_tag:
       return ButtonA(proto.type.button_a_pressed);
     case pubsub_Event_button_b_pressed_tag:
@@ -129,16 +100,10 @@
           .turn_on = proto.type.morse_code_value.turn_on,
           .message_finished = proto.type.morse_code_value.message_finished,
       };
-    case pubsub_Event_led_value_air_quality_tag:
-      return LedValueAirQualityMode(
-          LedValueFromProto(proto.type.led_value_air_quality));
     case pubsub_Event_proximity_tag:
       return ProximityStateChange{.proximity = proto.type.proximity};
     case pubsub_Event_air_quality_tag:
       return AirQuality{.score = static_cast<uint16_t>(proto.type.air_quality)};
-    case pubsub_Event_alarm_silence_tag:
-      return AlarmSilenceRequest{
-          .seconds = static_cast<uint16_t>(proto.type.alarm_silence)};
     default:
       return pw::Status::Unimplemented();
   }
diff --git a/modules/sampling_thread/sampling_thread.cc b/modules/sampling_thread/sampling_thread.cc
index 9f0c4e1..3cffd05 100644
--- a/modules/sampling_thread/sampling_thread.cc
+++ b/modules/sampling_thread/sampling_thread.cc
@@ -67,12 +67,9 @@
 
 // Reads sensor samples in a loop and publishes PubSub events for them.
 void SamplingLoop() {
-  auto& pubsub = system::PubSub();
-  auto& clock = pw::chrono::VirtualSystemClock::RealClock();
-
   PW_CHECK_OK(system::AmbientLightSensor().Enable());
   PW_CHECK_OK(system::ProximitySensor().Enable());
-  PW_CHECK_OK(system::AirSensor().Init(pubsub, clock));
+  PW_CHECK_OK(system::AirSensor().Init());
 
   SystemClock::time_point deadline = SystemClock::now();
 
diff --git a/modules/state_manager/BUILD.bazel b/modules/state_manager/BUILD.bazel
index 18d398a..20ea034 100644
--- a/modules/state_manager/BUILD.bazel
+++ b/modules/state_manager/BUILD.bazel
@@ -25,12 +25,11 @@
     deps = [
         ":common_base_union",
         "//modules/air_sensor",
+        "//modules/edge_detector:hysteresis_edge_detector",
         "//modules/led:polychrome_led",
         "//modules/pubsub:events",
-        "//modules/stats:simple_moving_average",
         "//modules/worker",
         "@pigweed//pw_assert",
-        "@pigweed//pw_chrono:system_timer",
         "@pigweed//pw_string:string",
     ],
 )
diff --git a/modules/state_manager/state_manager.cc b/modules/state_manager/state_manager.cc
index cb38e4e..9e93851 100644
--- a/modules/state_manager/state_manager.cc
+++ b/modules/state_manager/state_manager.cc
@@ -22,6 +22,17 @@
 
 namespace sense {
 
+template <typename T>
+static void AddAndSmoothExponentially(std::optional<T>& aggregate,
+                                      T next_value) {
+  static constexpr T kDecayFactor = T(4);
+  if (!aggregate.has_value()) {
+    aggregate = next_value;
+  } else {
+    *aggregate += (next_value - *aggregate) / kDecayFactor;
+  }
+}
+
 void LedOutputStateMachine::UpdateLed(uint8_t red,
                                       uint8_t green,
                                       uint8_t blue,
@@ -43,20 +54,17 @@
 }
 
 StateManager::StateManager(PubSub& pubsub, PolychromeLed& led)
-    : pubsub_(&pubsub),
+    : edge_detector_(alarm_threshold_, alarm_threshold_ + kThresholdIncrement),
+      pubsub_(&pubsub),
       led_(led, brightness_),
-      state_(*this),
-      demo_mode_timer_([this](auto) { state_.get().DemoModeTimerExpired(); }) {
+      state_(*this) {
   pubsub_->Subscribe([this](Event event) { Update(event); });
 }
 
 void StateManager::Update(Event event) {
   switch (static_cast<EventType>(event.index())) {
     case kAirQuality:
-      last_air_quality_score_ = std::get<AirQuality>(event).score;
-      break;
-    case kAlarmStateChange:
-      state_.get().AlarmStateChanged(std::get<AlarmStateChange>(event).alarm);
+      UpdateAirQuality(std::get<AirQuality>(event).score);
       break;
     case kButtonA:
       HandleButtonPress(std::get<ButtonA>(event).pressed(),
@@ -74,9 +82,8 @@
       HandleButtonPress(std::get<ButtonY>(event).pressed(),
                         &State::ButtonYReleased);
       break;
-    case kLedValueAirQualityMode:
-      state_.get().AirQualityModeLedValue(
-          std::get<LedValueAirQualityMode>(event));
+    case kTimerExpired:
+      state_.get().OnTimerExpired(std::get<TimerExpired>(event));
       break;
     case kMorseCodeValue:
       state_.get().MorseCodeEdge(std::get<MorseCodeValue>(event));
@@ -86,11 +93,8 @@
       state_.get().AmbientLightUpdate();
       break;
     case kTimerRequest:
-    case kTimerExpired:
-    case kProximitySample:
-    case kAlarmSilenceRequest:
-    case kAirQualityThreshold:
     case kMorseEncodeRequest:
+    case kProximitySample:
     case kProximityStateChange:
       break;  // ignore these events
   }
@@ -105,77 +109,114 @@
   }
 }
 
+void StateManager::DisplayThreshold() {
+  led_.SetColor(AirSensor::GetLedValue(alarm_threshold_));
+  pubsub_->Publish(TimerRequest{
+      .token = kThresholdModeToken,
+      .timeout_s = kThresholdModeTimeout,
+  });
+}
+
+void StateManager::IncrementThreshold() {
+  if (alarm_threshold_ < kMaxThreshold) {
+    SetAlarmThreshold(alarm_threshold_ + kThresholdIncrement);
+  }
+  DisplayThreshold();
+}
+
+void StateManager::DecrementThreshold() {
+  if (alarm_threshold_ > 0) {
+    SetAlarmThreshold(alarm_threshold_ - kThresholdIncrement);
+  }
+  DisplayThreshold();
+}
+
+void StateManager::SetAlarmThreshold(uint16_t alarm_threshold) {
+  alarm_threshold_ = alarm_threshold;
+  auto silence_threshold =
+      static_cast<uint16_t>(alarm_threshold_ + kThresholdIncrement);
+  edge_detector_.set_low_and_high_thresholds(alarm_threshold_,
+                                             silence_threshold);
+  PW_LOG_INFO("Air quality thresholds set: alarm at %u, silence at %u",
+              alarm_threshold_,
+              silence_threshold);
+  edge_detector_.Update(AirSensor::kMaxScore);
+}
+
+void StateManager::UpdateAirQuality(uint16_t score) {
+  AddAndSmoothExponentially(air_quality_, score);
+  state_.get().OnLedValue(AirSensor::GetLedValue(*air_quality_));
+  if (alarm_silenced_) {
+    return;
+  }
+  switch (edge_detector_.Update(*air_quality_)) {
+    case Edge::kFalling:
+      alarm_ = true;
+      break;
+    case Edge::kRising:
+      alarm_ = false;
+      break;
+    case Edge::kNone:
+      return;
+  }
+  ResetMode();
+}
+
+void StateManager::SilenceAlarms() {
+  alarm_ = false;
+  alarm_silenced_ = true;
+  edge_detector_.Update(AirSensor::kMaxScore);
+  pubsub_->Publish(TimerRequest{
+      .token = kSilenceAlarmsToken,
+      .timeout_s = kSilenceAlarmsTimeout,
+  });
+  ResetMode();
+}
+
+void StateManager::ResetMode() {
+  if (alarm_) {
+    SetState<AirQualityAlarmMode>();
+  } else {
+    SetState<AirQualityMode>();
+  }
+}
+
 void StateManager::StartMorseReadout(bool repeat) {
+  if (!air_quality_.has_value()) {
+    return;
+  }
   pw::Status status = pw::string::FormatOverwrite(
-      air_quality_score_string_, "%hu", last_air_quality_score_);
+      air_quality_score_string_, "%hu", *air_quality_);
   PW_CHECK_OK(status);
   pubsub_->Publish(MorseEncodeRequest{.message = air_quality_score_string_,
                                       .repeat = repeat ? 0u : 1u});
-  PW_LOG_INFO("Current air quality score: %hu", last_air_quality_score_);
-}
-
-void StateManager::DisplayThreshold() {
-  led_.SetColor(AirSensor::GetLedValue(current_threshold_));
-}
-
-void StateManager::IncrementThreshold(
-    pw::chrono::SystemClock::duration timeout) {
-  demo_mode_timer_.Cancel();
-  uint16_t candidate_threshold = current_threshold_ + kThresholdIncrement;
-  current_threshold_ =
-      candidate_threshold < kMaxThreshold ? candidate_threshold : kMaxThreshold;
-  pubsub_->Publish(AirQualityThreshold{
-      .alarm = current_threshold_,
-      .silence =
-          static_cast<uint16_t>(current_threshold_ + kThresholdIncrement),
-  });
-  DisplayThreshold();
-  demo_mode_timer_.InvokeAfter(timeout);
-}
-
-void StateManager::DecrementThreshold(
-    pw::chrono::SystemClock::duration timeout) {
-  demo_mode_timer_.Cancel();
-  if (current_threshold_ > 0) {
-    current_threshold_ -= kThresholdIncrement;
-  }
-  pubsub_->Publish(AirQualityThreshold{
-      .alarm = current_threshold_,
-      .silence =
-          static_cast<uint16_t>(current_threshold_ + kThresholdIncrement),
-  });
-  DisplayThreshold();
-  demo_mode_timer_.InvokeAfter(timeout);
+  PW_LOG_INFO("Current air quality score: %hu", *air_quality_);
 }
 
 void StateManager::UpdateAverageAmbientLight(float ambient_light_sample_lux) {
-  static constexpr float kDecayFactor = 0.25;
-  if (std::isnan(ambient_light_lux_)) {
-    ambient_light_lux_ = ambient_light_sample_lux;
-  } else {
-    ambient_light_lux_ +=
-        (ambient_light_sample_lux - ambient_light_lux_) * kDecayFactor;
-  }
+  AddAndSmoothExponentially(ambient_light_lux_, ambient_light_sample_lux);
 }
 
 void StateManager::UpdateBrightnessFromAmbientLight() {
   static constexpr float kMinLux = 40.f;
   static constexpr float kMaxLux = 3000.f;
-
-  if (ambient_light_lux_ < kMinLux) {
+  if (!ambient_light_lux_.has_value()) {
+    return;
+  }
+  if (*ambient_light_lux_ < kMinLux) {
     brightness_ = kMinBrightness;
-  } else if (ambient_light_lux_ > kMaxLux) {
+  } else if (*ambient_light_lux_ > kMaxLux) {
     brightness_ = kMaxBrightness;
   } else {
     constexpr float kBrightnessRange = kMaxBrightness - kMinBrightness;
     brightness_ = static_cast<uint8_t>(
-        std::lround((ambient_light_lux_ - kMinLux) / (kMaxLux - kMinLux) *
+        std::lround((*ambient_light_lux_ - kMinLux) / (kMaxLux - kMinLux) *
                     kBrightnessRange) +
         kMinBrightness);
   }
 
   PW_LOG_DEBUG(
-      "Ambient light: mean=%.1f, led=%hhu", ambient_light_lux_, brightness_);
+      "Ambient light: mean=%.1f, led=%hhu", *ambient_light_lux_, brightness_);
 
   led_.SetBrightness(brightness_);
 }
diff --git a/modules/state_manager/state_manager.h b/modules/state_manager/state_manager.h
index e3fd8c4..5a28f27 100644
--- a/modules/state_manager/state_manager.h
+++ b/modules/state_manager/state_manager.h
@@ -16,11 +16,10 @@
 #include <cmath>
 
 #include "modules/air_sensor/air_sensor.h"
+#include "modules/edge_detector/hysteresis_edge_detector.h"
 #include "modules/led/polychrome_led.h"
 #include "modules/pubsub/pubsub_events.h"
 #include "modules/state_manager/common_base_union.h"
-#include "modules/stats/simple_moving_average.h"
-#include "pw_chrono/system_timer.h"
 #include "pw_string/string.h"
 
 namespace sense {
@@ -84,21 +83,27 @@
 // thread.
 class StateManager {
  public:
+  using TimerToken = ::pw::tokenizer::Token;
+
+  static constexpr TimerToken kSilenceAlarmsToken =
+      PW_TOKENIZE_STRING("re-enable alarms");
+  static constexpr uint16_t kSilenceAlarmsTimeout = 60;
+
+  static constexpr TimerToken kThresholdModeToken =
+      PW_TOKENIZE_STRING("exit threshold mode");
+  static constexpr uint16_t kThresholdModeTimeout = 3;
+
+  static constexpr uint16_t kThresholdIncrement = 128;
+  static constexpr uint16_t kMaxThreshold = 768;
+
   StateManager(PubSub& pubsub, PolychromeLed& led);
 
  private:
-  /// How long to show demo modes before returning to the regular AQI monitor.
-  static constexpr pw::chrono::SystemClock::duration kDemoModeTimeout =
-      std::chrono::seconds(30);
-
   // LED brightness varies based on ambient light readings.
   static constexpr uint8_t kMinBrightness = 20;
   static constexpr uint8_t kDefaultBrightness = 160;
   static constexpr uint8_t kMaxBrightness = 255;
 
-  static constexpr uint16_t kThresholdIncrement = 128;
-  static constexpr uint16_t kMaxThreshold = 768;
-
   // Represents a state in the Sense app state machine.
   class State {
    public:
@@ -112,41 +117,36 @@
     // Name of the state for logging.
     const char* name() const { return name_; }
 
-    // Events for handling alarms.
-    virtual void AlarmStateChanged(bool alarm) {
-      if (manager_.alarmed_ == alarm) {
-        return;
-      }
-      manager_.alarmed_ = alarm;
-      if (alarm) {
-        manager_.SetState<AirQualityAlarmMode>();
-      } else {
-        manager_.SetState<AirQualityMode>();
-      }
-    }
-
-    // Events for releasing buttons.
+    // Events for releasing buttons. By default, 'A' and 'B' change to
+    // threshold mode, while 'X' and 'Y' change to monitoring mode.
     virtual void ButtonAReleased() {
       manager_.SetState<AirQualityThresholdMode>();
     }
     virtual void ButtonBReleased() {
       manager_.SetState<AirQualityThresholdMode>();
     }
-    virtual void ButtonXReleased() {}
-    virtual void ButtonYReleased() {}
+    virtual void ButtonXReleased() { manager_.ResetMode(); }
+    virtual void ButtonYReleased() { manager_.ResetMode(); }
 
     // Ambient light sensor updates determine LED brightess by default.
     virtual void AmbientLightUpdate() {
       manager().UpdateBrightnessFromAmbientLight();
     }
 
-    // Events for requested LED values from other components.
-    virtual void AirQualityModeLedValue(const LedValue&) {}
+    // Update the LED color by default.
+    virtual void OnLedValue(const LedValue& value) {
+      manager().led_.SetColor(value);
+    }
 
+    // Ignore Morse code edges by default.
     virtual void MorseCodeEdge(const MorseCodeValue&) {}
 
-    // Demo mode returns to air quality mode after a specified time.
-    virtual void DemoModeTimerExpired() {}
+    // Mode returns to air quality mode after a specified time.
+    virtual void OnTimerExpired(const TimerExpired& timer) {
+      if (timer.token == kSilenceAlarmsToken) {
+        manager().alarm_silenced_ = false;
+      }
+    }
 
    protected:
     StateManager& manager() { return manager_; }
@@ -156,51 +156,32 @@
     const char* name_;
   };
 
-  // Base class for all demo states to handle button behavior and timer.
-  class TimeoutState : public State {
-   public:
-    TimeoutState(StateManager& manager,
-                 const char* name,
-                 pw::chrono::SystemClock::duration timeout)
-        : State(manager, name) {
-      manager.demo_mode_timer_.InvokeAfter(timeout);
-    }
-
-    void ButtonYReleased() override { manager().SetState<MorseReadout>(); }
-
-    void DemoModeTimerExpired() override {
-      manager().SetState<AirQualityMode>();
-    }
-  };
-
   class AirQualityMode final : public State {
    public:
     AirQualityMode(StateManager& manager) : State(manager, "AirQualityMode") {}
 
     void ButtonYReleased() override { manager().SetState<MorseReadout>(); }
-
-    void AirQualityModeLedValue(const LedValue& value) override {
-      manager().led_.SetColor(value);
-    }
   };
 
-  class AirQualityThresholdMode final : public TimeoutState {
+  class AirQualityThresholdMode final : public State {
    public:
-    static constexpr auto kThresholdModeTimeout =
-        pw::chrono::SystemClock::for_at_least(std::chrono::seconds(3));
-
     AirQualityThresholdMode(StateManager& manager)
-        : TimeoutState(
-              manager, "AirQualityThresholdMode", kThresholdModeTimeout) {
+        : State(manager, "AirQualityThresholdMode") {
       manager.DisplayThreshold();
     }
 
-    void ButtonAReleased() override {
-      manager().IncrementThreshold(kThresholdModeTimeout);
-    }
+    void ButtonAReleased() override { manager().IncrementThreshold(); }
 
-    void ButtonBReleased() override {
-      manager().DecrementThreshold(kThresholdModeTimeout);
+    void ButtonBReleased() override { manager().DecrementThreshold(); }
+
+    void OnLedValue(const LedValue&) override {}
+
+    void OnTimerExpired(const TimerExpired& timer) override {
+      if (timer.token == kThresholdModeToken) {
+        manager().ResetMode();
+      } else {
+        State::OnTimerExpired(timer);
+      }
     }
   };
 
@@ -211,12 +192,10 @@
       manager.StartMorseReadout(/* repeat: */ true);
     }
 
-    void ButtonYReleased() override {
-      manager().pubsub_->Publish(AlarmSilenceRequest{.seconds = 60});
-    }
-    void AirQualityModeLedValue(const LedValue& value) override {
-      manager().led_.SetColor(value);
-    }
+    void ButtonXReleased() override { manager().SilenceAlarms(); }
+
+    void ButtonYReleased() override {}
+
     void MorseCodeEdge(const MorseCodeValue& value) override {
       manager().led_.SetBrightness(value.turn_on ? manager().brightness_ : 0);
     }
@@ -228,15 +207,10 @@
       manager.StartMorseReadout(/* repeat: */ false);
     }
 
-    void ButtonYReleased() override { manager().SetState<AirQualityMode>(); }
-
-    void AirQualityModeLedValue(const LedValue& value) override {
-      manager().led_.SetColor(value);
-    }
     void MorseCodeEdge(const MorseCodeValue& value) override {
       manager().led_.SetBrightness(value.turn_on ? manager().brightness_ : 0);
       if (value.message_finished) {
-        manager().SetState<AirQualityMode>();
+        manager().ResetMode();
       }
     }
   };
@@ -248,35 +222,46 @@
 
   template <typename StateType>
   void SetState() {
-    demo_mode_timer_.Cancel();  // always reset the timer
     const char* old_state = state_.get().name();
     state_.emplace<StateType>(*this);
     LogStateChange(old_state);
   }
 
-  void LogStateChange(const char* old_state) const;
-
-  void StartMorseReadout(bool repeat);
+  void ResetMode();
 
   void DisplayThreshold();
 
-  void IncrementThreshold(pw::chrono::SystemClock::duration timeout);
+  void IncrementThreshold();
 
-  void DecrementThreshold(pw::chrono::SystemClock::duration timeout);
+  void DecrementThreshold();
+
+  void SetAlarmThreshold(uint16_t alarm_threshold);
+
+  void UpdateAirQuality(uint16_t score);
+
+  void SilenceAlarms();
+
+  void StartMorseReadout(bool repeat);
 
   void UpdateAverageAmbientLight(float ambient_light_sample_lux);
 
   // Recalculates the brightness level when the ambient light changes.
   void UpdateBrightnessFromAmbientLight();
 
-  bool alarmed_ = false;
-  IntegerSimpleMovingAverager<uint16_t, 5> prox_samples_;
-  float ambient_light_lux_ = NAN;  // exponential moving averaged mean lux
-  uint8_t brightness_ = kDefaultBrightness;
-  uint16_t current_threshold_ = AirSensor::kDefaultTheshold;
-  uint16_t last_air_quality_score_ = AirSensor::kAverageScore;
+  void LogStateChange(const char* old_state) const;
+
+  std::optional<uint16_t> air_quality_;
   pw::InlineString<4> air_quality_score_string_;
 
+  bool alarm_ = false;
+  bool alarm_silenced_ = false;
+  uint16_t alarm_threshold_ = static_cast<uint16_t>(AirSensor::Score::kYellow);
+  HysteresisEdgeDetector<uint16_t> edge_detector_;
+
+  uint8_t brightness_ = kDefaultBrightness;
+  std::optional<float>
+      ambient_light_lux_;  // exponential moving averaged mean lux
+
   PubSub* pubsub_;
   LedOutputStateMachine led_;
 
@@ -286,8 +271,6 @@
                   AirQualityAlarmMode,
                   MorseReadout>
       state_;
-
-  pw::chrono::SystemTimer demo_mode_timer_;
 };
 
 }  // namespace sense