diff --git a/quiche/common/quiche_feature_flags_list.h b/quiche/common/quiche_feature_flags_list.h
index f3c8c18..9a01830 100755
--- a/quiche/common/quiche_feature_flags_list.h
+++ b/quiche/common/quiche_feature_flags_list.h
@@ -53,7 +53,6 @@
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_test_peer_addr_change_after_normalize, false, false, "If true, QuicConnection::ProcessValidatedPacket will use normalized address to test peer address changes.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_testonly_default_false, false, false, "A testonly reloadable flag that will always default to false.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_testonly_default_true, true, true, "A testonly reloadable flag that will always default to true.")
-QUICHE_FLAG(bool, quiche_reloadable_flag_quic_use_alarm_multiplexer, true, true, "Manages all of the connection alarms via QuicAlarmMultiplexer.")
 QUICHE_FLAG(bool, quiche_reloadable_flag_quic_use_received_client_addresses_cache, true, true, "If true, use a LRU cache to record client addresses of packets received on server's original address.")
 QUICHE_FLAG(bool, quiche_restart_flag_quic_support_release_time_for_gso, false, false, "If true, QuicGsoBatchWriter will support release time if it is available and the process has the permission to do so.")
 QUICHE_FLAG(bool, quiche_restart_flag_quic_testonly_default_false, false, false, "A testonly restart flag that will always default to false.")
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index 8a9b785..c68a452 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -38,6 +38,7 @@
 #include "quiche/quic/core/frames/quic_reset_stream_at_frame.h"
 #include "quiche/quic/core/quic_bandwidth.h"
 #include "quiche/quic/core/quic_config.h"
+#include "quiche/quic/core/quic_connection_alarms.h"
 #include "quiche/quic/core/quic_connection_id.h"
 #include "quiche/quic/core/quic_constants.h"
 #include "quiche/quic/core/quic_error_codes.h"
@@ -188,7 +189,7 @@
       pending_retransmission_alarm_(false),
       defer_send_in_response_to_packets_(false),
       arena_(),
-      alarms_(this, *alarm_factory_, arena_),
+      alarms_(this, arena_, *alarm_factory_),
       visitor_(nullptr),
       debug_visitor_(nullptr),
       packet_creator_(server_connection_id, &framer_, random_generator_, this),
@@ -214,12 +215,16 @@
       processing_ack_frame_(false),
       supports_release_time_(false),
       release_time_into_future_(QuicTime::Delta::Zero()),
-      blackhole_detector_(this, alarms_.network_blackhole_detector_alarm()),
-      idle_network_detector_(this, clock_->ApproximateNow(),
-                             alarms_.idle_network_detector_alarm()),
+      blackhole_detector_(
+          this,
+          QuicAlarmProxy(&alarms_, QuicAlarmSlot::kNetworkBlackholeDetector)),
+      idle_network_detector_(
+          this, clock_->ApproximateNow(),
+          QuicAlarmProxy(&alarms_, QuicAlarmSlot::kIdleNetworkDetector)),
       path_validator_(alarm_factory_, &arena_, this, random_generator_, clock_,
                       &context_),
-      ping_manager_(perspective, this, alarms_.ping_alarm()),
+      ping_manager_(perspective, this,
+                    QuicAlarmProxy(&alarms_, QuicAlarmSlot::kPing)),
       multi_port_probing_interval_(kDefaultMultiPortProbingInterval),
       connection_id_generator_(generator),
       received_client_addresses_cache_(kMaxReceivedClientAddressSize) {
@@ -1130,7 +1135,9 @@
   }
 }
 
-bool QuicConnection::HasPendingAcks() const { return ack_alarm().IsSet(); }
+bool QuicConnection::HasPendingAcks() const {
+  return alarms_.IsSet(QuicAlarmSlot::kAck);
+}
 
 void QuicConnection::OnUserAgentIdKnown(const std::string& /*user_agent_id*/) {
   sent_packet_manager_.OnUserAgentIdKnown();
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index b295e59..a005ef0 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -2170,44 +2170,31 @@
 
   void GenerateNewOutgoingFlowLabel();
 
-  QuicAlarmProxy ack_alarm() { return alarms_.ack_alarm(); }
-  QuicAlarmProxy retransmission_alarm() {
-    return alarms_.retransmission_alarm();
+  QuicAlarmProxy ack_alarm() {
+    return QuicAlarmProxy(&alarms_, QuicAlarmSlot::kAck);
   }
-  QuicAlarmProxy send_alarm() { return alarms_.send_alarm(); }
-  QuicAlarmProxy mtu_discovery_alarm() { return alarms_.mtu_discovery_alarm(); }
+  QuicAlarmProxy retransmission_alarm() {
+    return QuicAlarmProxy(&alarms_, QuicAlarmSlot::kRetransmission);
+  }
+  QuicAlarmProxy send_alarm() {
+    return QuicAlarmProxy(&alarms_, QuicAlarmSlot::kSend);
+  }
+  QuicAlarmProxy mtu_discovery_alarm() {
+    return QuicAlarmProxy(&alarms_, QuicAlarmSlot::kMtuDiscovery);
+  }
   QuicAlarmProxy process_undecryptable_packets_alarm() {
-    return alarms_.process_undecryptable_packets_alarm();
+    return QuicAlarmProxy(&alarms_,
+                          QuicAlarmSlot::kProcessUndecryptablePackets);
   }
   QuicAlarmProxy discard_previous_one_rtt_keys_alarm() {
-    return alarms_.discard_previous_one_rtt_keys_alarm();
+    return QuicAlarmProxy(&alarms_, QuicAlarmSlot::kDiscardPreviousOneRttKeys);
   }
   QuicAlarmProxy discard_zero_rtt_decryption_keys_alarm() {
-    return alarms_.discard_zero_rtt_decryption_keys_alarm();
+    return QuicAlarmProxy(&alarms_,
+                          QuicAlarmSlot::kDiscardZeroRttDecryptionKeys);
   }
   QuicAlarmProxy multi_port_probing_alarm() {
-    return alarms_.multi_port_probing_alarm();
-  }
-
-  QuicConstAlarmProxy ack_alarm() const { return alarms_.ack_alarm(); }
-  QuicConstAlarmProxy retransmission_alarm() const {
-    return alarms_.retransmission_alarm();
-  }
-  QuicConstAlarmProxy send_alarm() const { return alarms_.send_alarm(); }
-  QuicConstAlarmProxy mtu_discovery_alarm() const {
-    return alarms_.mtu_discovery_alarm();
-  }
-  QuicConstAlarmProxy process_undecryptable_packets_alarm() const {
-    return alarms_.process_undecryptable_packets_alarm();
-  }
-  QuicConstAlarmProxy discard_previous_one_rtt_keys_alarm() const {
-    return alarms_.discard_previous_one_rtt_keys_alarm();
-  }
-  QuicConstAlarmProxy discard_zero_rtt_decryption_keys_alarm() const {
-    return alarms_.discard_zero_rtt_decryption_keys_alarm();
-  }
-  QuicConstAlarmProxy multi_port_probing_alarm() const {
-    return alarms_.multi_port_probing_alarm();
+    return QuicAlarmProxy(&alarms_, QuicAlarmSlot::kMultiPortProbing);
   }
 
   QuicConnectionContext context_;
@@ -2337,7 +2324,7 @@
   QuicConnectionArena arena_;
 
   // Alarms used by the connection.
-  QuicConnectionAlarms alarms_;
+  QuicAlarmMultiplexer alarms_;
 
   // Neither visitor is owned by this class.
   QuicConnectionVisitorInterface* visitor_;
diff --git a/quiche/quic/core/quic_connection_alarms.cc b/quiche/quic/core/quic_connection_alarms.cc
index f588574..1741111 100644
--- a/quiche/quic/core/quic_connection_alarms.cc
+++ b/quiche/quic/core/quic_connection_alarms.cc
@@ -20,7 +20,6 @@
 #include "quiche/quic/core/quic_connection_context.h"
 #include "quiche/quic/core/quic_one_block_arena.h"
 #include "quiche/quic/core/quic_time.h"
-#include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_flags.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_logging.h"
@@ -399,42 +398,4 @@
   later_alarm_->PermanentCancel();
 }
 
-QuicConnectionAlarmHolder::QuicConnectionAlarmHolder(
-    QuicConnectionAlarmsDelegate* delegate, QuicAlarmFactory& alarm_factory,
-    QuicConnectionArena& arena)
-    : ack_alarm_(alarm_factory.CreateAlarm(
-          arena.New<AckAlarmDelegate>(delegate), &arena)),
-      retransmission_alarm_(alarm_factory.CreateAlarm(
-          arena.New<RetransmissionAlarmDelegate>(delegate), &arena)),
-      send_alarm_(alarm_factory.CreateAlarm(
-          arena.New<SendAlarmDelegate>(delegate), &arena)),
-      mtu_discovery_alarm_(alarm_factory.CreateAlarm(
-          arena.New<MtuDiscoveryAlarmDelegate>(delegate), &arena)),
-      process_undecryptable_packets_alarm_(alarm_factory.CreateAlarm(
-          arena.New<ProcessUndecryptablePacketsAlarmDelegate>(delegate),
-          &arena)),
-      discard_previous_one_rtt_keys_alarm_(alarm_factory.CreateAlarm(
-          arena.New<DiscardPreviousOneRttKeysAlarmDelegate>(delegate), &arena)),
-      discard_zero_rtt_decryption_keys_alarm_(alarm_factory.CreateAlarm(
-          arena.New<DiscardZeroRttDecryptionKeysAlarmDelegate>(delegate),
-          &arena)),
-      multi_port_probing_alarm_(alarm_factory.CreateAlarm(
-          arena.New<MultiPortProbingAlarmDelegate>(delegate), &arena)),
-      idle_network_detector_alarm_(alarm_factory.CreateAlarm(
-          arena.New<IdleDetectorAlarmDelegate>(delegate), &arena)),
-      network_blackhole_detector_alarm_(alarm_factory.CreateAlarm(
-          arena.New<NetworkBlackholeDetectorAlarmDelegate>(delegate), &arena)),
-      ping_alarm_(alarm_factory.CreateAlarm(
-          arena.New<PingAlarmDelegate>(delegate), &arena)) {}
-
-QuicConnectionAlarms::QuicConnectionAlarms(
-    QuicConnectionAlarmsDelegate* delegate, QuicAlarmFactory& alarm_factory,
-    QuicConnectionArena& arena)
-    : use_multiplexer_(GetQuicReloadableFlag(quic_use_alarm_multiplexer)) {
-  if (use_multiplexer_) {
-    multiplexer_.emplace(delegate, arena, alarm_factory);
-  } else {
-    holder_.emplace(delegate, alarm_factory, arena);
-  }
-}
 }  // namespace quic
diff --git a/quiche/quic/core/quic_connection_alarms.h b/quiche/quic/core/quic_connection_alarms.h
index a8e45d5..31ecbb3 100644
--- a/quiche/quic/core/quic_connection_alarms.h
+++ b/quiche/quic/core/quic_connection_alarms.h
@@ -8,9 +8,7 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <optional>
 #include <string>
-#include <variant>
 
 #include "absl/base/nullability.h"
 #include "quiche/quic/core/quic_alarm.h"
@@ -88,52 +86,6 @@
 // alarms that QuicConnection has by reducing all of those alarms to just two.
 class QUICHE_EXPORT QuicAlarmMultiplexer {
  public:
-  // Proxy classes that allow an individual alarm to be accessed via
-  // a QuicAlarm-compatible API.
-  class AlarmProxy {
-   public:
-    AlarmProxy(QuicAlarmMultiplexer* multiplexer, QuicAlarmSlot slot)
-        : multiplexer_(multiplexer), slot_(slot) {}
-
-    bool IsSet() const { return multiplexer_->IsSet(slot_); }
-    QuicTime deadline() const { return multiplexer_->GetDeadline(slot_); }
-    bool IsPermanentlyCancelled() const {
-      return multiplexer_->IsPermanentlyCancelled();
-    }
-
-    void Set(QuicTime new_deadline) { multiplexer_->Set(slot_, new_deadline); }
-    void Update(QuicTime new_deadline, QuicTime::Delta granularity) {
-      multiplexer_->Update(slot_, new_deadline, granularity);
-    }
-    void Cancel() { multiplexer_->Cancel(slot_); }
-
-    void PermanentCancel() {}
-
-   private:
-    friend class ::quic::test::QuicConnectionAlarmsPeer;
-
-    QuicAlarmMultiplexer* multiplexer_;
-    QuicAlarmSlot slot_;
-  };
-
-  // Proxy classes that allow an individual alarm to be accessed via
-  // a QuicAlarm-compatible API.
-  class ConstAlarmProxy {
-   public:
-    ConstAlarmProxy(const QuicAlarmMultiplexer* multiplexer, QuicAlarmSlot slot)
-        : multiplexer_(multiplexer), slot_(slot) {}
-
-    bool IsSet() const { return multiplexer_->IsSet(slot_); }
-    QuicTime deadline() const { return multiplexer_->GetDeadline(slot_); }
-    bool IsPermanentlyCancelled() const {
-      return multiplexer_->IsPermanentlyCancelled();
-    }
-
-   private:
-    const QuicAlarmMultiplexer* multiplexer_;
-    QuicAlarmSlot slot_;
-  };
-
   static constexpr size_t kNumberOfSlots =
       static_cast<size_t>(QuicAlarmSlot::kSlotCount);
 
@@ -225,439 +177,34 @@
   bool defer_updates_of_underlying_alarms_ = false;
 };
 
-class QUICHE_EXPORT QuicConnectionAlarmHolder {
+// Proxy classes that allow an individual alarm to be accessed via
+// a QuicAlarm-compatible API.
+class QUICHE_EXPORT QuicAlarmProxy {
  public:
-  // Provides a QuicAlarm-like interface to an alarm contained within
-  // QuicConnectionAlarms.
-  class AlarmProxy {
-   public:
-    explicit AlarmProxy(absl::Nonnull<QuicAlarm*> alarm) : alarm_(alarm) {}
+  QuicAlarmProxy(QuicAlarmMultiplexer* multiplexer, QuicAlarmSlot slot)
+      : multiplexer_(multiplexer), slot_(slot) {}
 
-    bool IsSet() const { return alarm_->IsSet(); }
-    QuicTime deadline() const { return alarm_->deadline(); }
-    bool IsPermanentlyCancelled() const {
-      return alarm_->IsPermanentlyCancelled();
-    }
+  bool IsSet() const { return multiplexer_->IsSet(slot_); }
+  QuicTime deadline() const { return multiplexer_->GetDeadline(slot_); }
+  bool IsPermanentlyCancelled() const {
+    return multiplexer_->IsPermanentlyCancelled();
+  }
 
-    void Set(QuicTime new_deadline) { alarm_->Set(new_deadline); }
-    void Update(QuicTime new_deadline, QuicTime::Delta granularity) {
-      alarm_->Update(new_deadline, granularity);
-    }
-    void Cancel() { alarm_->Cancel(); }
-    void PermanentCancel() { alarm_->PermanentCancel(); }
+  void Set(QuicTime new_deadline) { multiplexer_->Set(slot_, new_deadline); }
+  void Update(QuicTime new_deadline, QuicTime::Delta granularity) {
+    multiplexer_->Update(slot_, new_deadline, granularity);
+  }
+  void Cancel() { multiplexer_->Cancel(slot_); }
 
-   private:
-    friend class ::quic::test::QuicConnectionAlarmsPeer;
-
-    absl::Nonnull<QuicAlarm*> alarm_;
-  };
-
-  // Provides a QuicAlarm-like interface to an alarm contained within
-  // QuicConnectionAlarms.
-  class ConstAlarmProxy {
-   public:
-    explicit ConstAlarmProxy(const QuicAlarm* alarm) : alarm_(alarm) {}
-
-    bool IsSet() const { return alarm_->IsSet(); }
-    QuicTime deadline() const { return alarm_->deadline(); }
-    bool IsPermanentlyCancelled() const {
-      return alarm_->IsPermanentlyCancelled();
-    }
-
-   private:
-    friend class ::quic::test::QuicConnectionAlarmsPeer;
-
-    const QuicAlarm* alarm_;
-  };
-
-  QuicConnectionAlarmHolder(QuicConnectionAlarmsDelegate* delegate,
-                            QuicAlarmFactory& alarm_factory,
-                            QuicConnectionArena& arena);
-
-  AlarmProxy ack_alarm() { return AlarmProxy(ack_alarm_.get()); }
-  AlarmProxy retransmission_alarm() {
-    return AlarmProxy(retransmission_alarm_.get());
-  }
-  AlarmProxy send_alarm() { return AlarmProxy(send_alarm_.get()); }
-  AlarmProxy mtu_discovery_alarm() {
-    return AlarmProxy(mtu_discovery_alarm_.get());
-  }
-  AlarmProxy process_undecryptable_packets_alarm() {
-    return AlarmProxy(process_undecryptable_packets_alarm_.get());
-  }
-  AlarmProxy discard_previous_one_rtt_keys_alarm() {
-    return AlarmProxy(discard_previous_one_rtt_keys_alarm_.get());
-  }
-  AlarmProxy discard_zero_rtt_decryption_keys_alarm() {
-    return AlarmProxy(discard_zero_rtt_decryption_keys_alarm_.get());
-  }
-  AlarmProxy multi_port_probing_alarm() {
-    return AlarmProxy(multi_port_probing_alarm_.get());
-  }
-  AlarmProxy idle_network_detector_alarm() {
-    return AlarmProxy(idle_network_detector_alarm_.get());
-  }
-  AlarmProxy network_blackhole_detector_alarm() {
-    return AlarmProxy(network_blackhole_detector_alarm_.get());
-  }
-  AlarmProxy ping_alarm() { return AlarmProxy(ping_alarm_.get()); }
-
-  ConstAlarmProxy ack_alarm() const {
-    return ConstAlarmProxy(ack_alarm_.get());
-  }
-  ConstAlarmProxy retransmission_alarm() const {
-    return ConstAlarmProxy(retransmission_alarm_.get());
-  }
-  ConstAlarmProxy send_alarm() const {
-    return ConstAlarmProxy(send_alarm_.get());
-  }
-  ConstAlarmProxy mtu_discovery_alarm() const {
-    return ConstAlarmProxy(mtu_discovery_alarm_.get());
-  }
-  ConstAlarmProxy process_undecryptable_packets_alarm() const {
-    return ConstAlarmProxy(process_undecryptable_packets_alarm_.get());
-  }
-  ConstAlarmProxy discard_previous_one_rtt_keys_alarm() const {
-    return ConstAlarmProxy(discard_previous_one_rtt_keys_alarm_.get());
-  }
-  ConstAlarmProxy discard_zero_rtt_decryption_keys_alarm() const {
-    return ConstAlarmProxy(discard_zero_rtt_decryption_keys_alarm_.get());
-  }
-  ConstAlarmProxy multi_port_probing_alarm() const {
-    return ConstAlarmProxy(multi_port_probing_alarm_.get());
-  }
-  ConstAlarmProxy idle_network_detector_alarm() const {
-    return ConstAlarmProxy(idle_network_detector_alarm_.get());
-  }
-  ConstAlarmProxy network_blackhole_detector_alarm() const {
-    return ConstAlarmProxy(network_blackhole_detector_alarm_.get());
-  }
-  ConstAlarmProxy ping_alarm() const {
-    return ConstAlarmProxy(ping_alarm_.get());
-  }
+  void PermanentCancel() {}
 
  private:
-  // An alarm that fires when an ACK should be sent to the peer.
-  QuicArenaScopedPtr<QuicAlarm> ack_alarm_;
-  // An alarm that fires when a packet needs to be retransmitted.
-  QuicArenaScopedPtr<QuicAlarm> retransmission_alarm_;
-  // An alarm that is scheduled when the SentPacketManager requires a delay
-  // before sending packets and fires when the packet may be sent.
-  QuicArenaScopedPtr<QuicAlarm> send_alarm_;
-  // An alarm that fires when an MTU probe should be sent.
-  QuicArenaScopedPtr<QuicAlarm> mtu_discovery_alarm_;
-  // An alarm that fires to process undecryptable packets when new decryption
-  // keys are available.
-  QuicArenaScopedPtr<QuicAlarm> process_undecryptable_packets_alarm_;
-  // An alarm that fires to discard keys for the previous key phase some time
-  // after a key update has completed.
-  QuicArenaScopedPtr<QuicAlarm> discard_previous_one_rtt_keys_alarm_;
-  // An alarm that fires to discard 0-RTT decryption keys some time after the
-  // first 1-RTT packet has been decrypted. Only used on server connections with
-  // TLS handshaker.
-  QuicArenaScopedPtr<QuicAlarm> discard_zero_rtt_decryption_keys_alarm_;
-  // An alarm that fires to keep probing the multi-port path.
-  QuicArenaScopedPtr<QuicAlarm> multi_port_probing_alarm_;
-  // An alarm for QuicIdleNetworkDetector.
-  QuicArenaScopedPtr<QuicAlarm> idle_network_detector_alarm_;
-  // An alarm for QuicNetworkBlackholeDetection.
-  QuicArenaScopedPtr<QuicAlarm> network_blackhole_detector_alarm_;
-  // An alarm for QuicPingManager.
-  QuicArenaScopedPtr<QuicAlarm> ping_alarm_;
+  friend class ::quic::test::QuicConnectionAlarmsPeer;
+
+  QuicAlarmMultiplexer* multiplexer_;
+  QuicAlarmSlot slot_;
 };
 
-// A class for holding all QuicAlarms belonging to a single connection.
-// Dispatches all calls to either QuicConnectionAlarmHolder of
-// QuicAlarmMultiplexer.
-class QUICHE_EXPORT QuicConnectionAlarms {
- public:
-  // Wraps a ConstAlarmProxy provided by either QuicConnectionAlarmHolder or
-  // QuicAlarmMultiplexer.
-  class ConstAlarmProxy {
-   public:
-    explicit ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy alarm)
-        : alarm_(alarm) {}
-    explicit ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy alarm)
-        : alarm_(alarm) {}
-
-    bool IsSet() const {
-      return std::visit([](auto& alarm) { return alarm.IsSet(); }, alarm_);
-    }
-    QuicTime deadline() const {
-      return std::visit([](auto& alarm) { return alarm.deadline(); }, alarm_);
-    }
-    bool IsPermanentlyCancelled() const {
-      return std::visit(
-          [](auto& alarm) { return alarm.IsPermanentlyCancelled(); }, alarm_);
-    }
-
-   private:
-    friend class ::quic::test::QuicConnectionAlarmsPeer;
-
-    std::variant<QuicConnectionAlarmHolder::ConstAlarmProxy,
-                 QuicAlarmMultiplexer::ConstAlarmProxy>
-        alarm_;
-  };
-
-  // Wraps an AlarmProxy provided by either QuicConnectionAlarmHolder or
-  // QuicAlarmMultiplexer.
-  class AlarmProxy {
-   public:
-    explicit AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy alarm)
-        : alarm_(alarm) {}
-    explicit AlarmProxy(QuicAlarmMultiplexer::AlarmProxy alarm)
-        : alarm_(alarm) {}
-
-    bool IsSet() const {
-      return std::visit([](auto& alarm) { return alarm.IsSet(); }, alarm_);
-    }
-    QuicTime deadline() const {
-      return std::visit([](auto& alarm) { return alarm.deadline(); }, alarm_);
-    }
-    bool IsPermanentlyCancelled() const {
-      return std::visit(
-          [](auto& alarm) { return alarm.IsPermanentlyCancelled(); }, alarm_);
-    }
-
-    void Set(QuicTime new_deadline) {
-      std::visit([&](auto& alarm) { alarm.Set(new_deadline); }, alarm_);
-    }
-    void Update(QuicTime new_deadline, QuicTime::Delta granularity) {
-      std::visit([&](auto& alarm) { alarm.Update(new_deadline, granularity); },
-                 alarm_);
-    }
-    void Cancel() {
-      std::visit([&](auto& alarm) { alarm.Cancel(); }, alarm_);
-    }
-    void PermanentCancel() {
-      std::visit([&](auto& alarm) { alarm.PermanentCancel(); }, alarm_);
-    }
-
-   private:
-    friend class ::quic::test::QuicConnectionAlarmsPeer;
-
-    std::variant<QuicConnectionAlarmHolder::AlarmProxy,
-                 QuicAlarmMultiplexer::AlarmProxy>
-        alarm_;
-  };
-
-  QuicConnectionAlarms(QuicConnectionAlarmsDelegate* delegate,
-                       QuicAlarmFactory& alarm_factory,
-                       QuicConnectionArena& arena);
-
-  AlarmProxy ack_alarm() {
-    if (use_multiplexer_) {
-      return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(&*multiplexer_,
-                                                         QuicAlarmSlot::kAck));
-    }
-    return AlarmProxy(
-        QuicConnectionAlarmHolder::AlarmProxy(holder_->ack_alarm()));
-  }
-  ConstAlarmProxy ack_alarm() const {
-    if (use_multiplexer_) {
-      return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kAck));
-    }
-    return ConstAlarmProxy(
-        QuicConnectionAlarmHolder::ConstAlarmProxy(holder_->ack_alarm()));
-  }
-
-  AlarmProxy retransmission_alarm() {
-    if (use_multiplexer_) {
-      return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kRetransmission));
-    }
-    return AlarmProxy(
-        QuicConnectionAlarmHolder::AlarmProxy(holder_->retransmission_alarm()));
-  }
-  ConstAlarmProxy retransmission_alarm() const {
-    if (use_multiplexer_) {
-      return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kRetransmission));
-    }
-    return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
-        holder_->retransmission_alarm()));
-  }
-
-  AlarmProxy send_alarm() {
-    if (use_multiplexer_) {
-      return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(&*multiplexer_,
-                                                         QuicAlarmSlot::kSend));
-    }
-    return AlarmProxy(
-        QuicConnectionAlarmHolder::AlarmProxy(holder_->send_alarm()));
-  }
-  ConstAlarmProxy send_alarm() const {
-    if (use_multiplexer_) {
-      return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kSend));
-    }
-    return ConstAlarmProxy(
-        QuicConnectionAlarmHolder::ConstAlarmProxy(holder_->send_alarm()));
-  }
-
-  AlarmProxy mtu_discovery_alarm() {
-    if (use_multiplexer_) {
-      return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kMtuDiscovery));
-    }
-    return AlarmProxy(
-        QuicConnectionAlarmHolder::AlarmProxy(holder_->mtu_discovery_alarm()));
-  }
-  ConstAlarmProxy mtu_discovery_alarm() const {
-    if (use_multiplexer_) {
-      return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kMtuDiscovery));
-    }
-    return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
-        holder_->mtu_discovery_alarm()));
-  }
-
-  AlarmProxy process_undecryptable_packets_alarm() {
-    if (use_multiplexer_) {
-      return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kProcessUndecryptablePackets));
-    }
-    return AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy(
-        holder_->process_undecryptable_packets_alarm()));
-  }
-  ConstAlarmProxy process_undecryptable_packets_alarm() const {
-    if (use_multiplexer_) {
-      return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kProcessUndecryptablePackets));
-    }
-    return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
-        holder_->process_undecryptable_packets_alarm()));
-  }
-
-  AlarmProxy discard_previous_one_rtt_keys_alarm() {
-    if (use_multiplexer_) {
-      return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kDiscardPreviousOneRttKeys));
-    }
-    return AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy(
-        holder_->discard_previous_one_rtt_keys_alarm()));
-  }
-  ConstAlarmProxy discard_previous_one_rtt_keys_alarm() const {
-    if (use_multiplexer_) {
-      return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kDiscardPreviousOneRttKeys));
-    }
-    return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
-        holder_->discard_previous_one_rtt_keys_alarm()));
-  }
-
-  AlarmProxy discard_zero_rtt_decryption_keys_alarm() {
-    if (use_multiplexer_) {
-      return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kDiscardZeroRttDecryptionKeys));
-    }
-    return AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy(
-        holder_->discard_zero_rtt_decryption_keys_alarm()));
-  }
-  ConstAlarmProxy discard_zero_rtt_decryption_keys_alarm() const {
-    if (use_multiplexer_) {
-      return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kDiscardZeroRttDecryptionKeys));
-    }
-    return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
-        holder_->discard_zero_rtt_decryption_keys_alarm()));
-  }
-
-  AlarmProxy multi_port_probing_alarm() {
-    if (use_multiplexer_) {
-      return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kMultiPortProbing));
-    }
-    return AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy(
-        holder_->multi_port_probing_alarm()));
-  }
-  ConstAlarmProxy multi_port_probing_alarm() const {
-    if (use_multiplexer_) {
-      return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kMultiPortProbing));
-    }
-    return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
-        holder_->multi_port_probing_alarm()));
-  }
-
-  AlarmProxy idle_network_detector_alarm() {
-    if (use_multiplexer_) {
-      return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kIdleNetworkDetector));
-    }
-    return AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy(
-        holder_->idle_network_detector_alarm()));
-  }
-  ConstAlarmProxy idle_network_detector_alarm() const {
-    if (use_multiplexer_) {
-      return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kIdleNetworkDetector));
-    }
-    return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
-        holder_->idle_network_detector_alarm()));
-  }
-
-  AlarmProxy network_blackhole_detector_alarm() {
-    if (use_multiplexer_) {
-      return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kNetworkBlackholeDetector));
-    }
-    return AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy(
-        holder_->network_blackhole_detector_alarm()));
-  }
-  ConstAlarmProxy network_blackhole_detector_alarm() const {
-    if (use_multiplexer_) {
-      return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kNetworkBlackholeDetector));
-    }
-    return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
-        holder_->network_blackhole_detector_alarm()));
-  }
-
-  AlarmProxy ping_alarm() {
-    if (use_multiplexer_) {
-      return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(&*multiplexer_,
-                                                         QuicAlarmSlot::kPing));
-    }
-    return AlarmProxy(
-        QuicConnectionAlarmHolder::AlarmProxy(holder_->ping_alarm()));
-  }
-  ConstAlarmProxy ping_alarm() const {
-    if (use_multiplexer_) {
-      return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
-          &*multiplexer_, QuicAlarmSlot::kPing));
-    }
-    return ConstAlarmProxy(
-        QuicConnectionAlarmHolder::ConstAlarmProxy(holder_->ping_alarm()));
-  }
-
-  void CancelAllAlarms() {
-    if (use_multiplexer_) {
-      multiplexer_->CancelAllAlarms();
-    }
-  }
-
-  void DeferUnderlyingAlarmScheduling() {
-    if (use_multiplexer_) {
-      multiplexer_->DeferUnderlyingAlarmScheduling();
-    }
-  }
-  void ResumeUnderlyingAlarmScheduling() {
-    if (use_multiplexer_) {
-      multiplexer_->ResumeUnderlyingAlarmScheduling();
-    }
-  }
-
- private:
-  std::optional<QuicConnectionAlarmHolder> holder_;
-  std::optional<QuicAlarmMultiplexer> multiplexer_;
-  const bool use_multiplexer_;
-};
-
-using QuicAlarmProxy = QuicConnectionAlarms::AlarmProxy;
-using QuicConstAlarmProxy = QuicConnectionAlarms::ConstAlarmProxy;
-
 }  // namespace quic
 
 #endif  // QUICHE_QUIC_CORE_QUIC_CONNECTION_ALARMS_H_
diff --git a/quiche/quic/core/quic_idle_network_detector_test.cc b/quiche/quic/core/quic_idle_network_detector_test.cc
index 458bc27..8896693 100644
--- a/quiche/quic/core/quic_idle_network_detector_test.cc
+++ b/quiche/quic/core/quic_idle_network_detector_test.cc
@@ -35,10 +35,10 @@
 class QuicIdleNetworkDetectorTest : public QuicTest {
  public:
   QuicIdleNetworkDetectorTest()
-      : alarms_(&connection_alarms_delegate_, alarm_factory_, arena_),
+      : alarms_(&connection_alarms_delegate_, arena_, alarm_factory_),
+        alarm_(&alarms_, QuicAlarmSlot::kIdleNetworkDetector),
         detector_(&delegate_, clock_.Now() + QuicTimeDelta::FromSeconds(1),
-                  alarms_.idle_network_detector_alarm()),
-        alarm_(alarms_.idle_network_detector_alarm()) {
+                  alarm_) {
     clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
     ON_CALL(connection_alarms_delegate_, OnIdleDetectorAlarm())
         .WillByDefault([&] { detector_.OnAlarm(); });
@@ -49,10 +49,10 @@
   MockConnectionAlarmsDelegate connection_alarms_delegate_;
   QuicConnectionArena arena_;
   MockAlarmFactory alarm_factory_;
-  QuicConnectionAlarms alarms_;
+  QuicAlarmMultiplexer alarms_;
+  QuicTestAlarmProxy alarm_;
   MockClock clock_;
   QuicIdleNetworkDetector detector_;
-  QuicTestAlarmProxy alarm_;
 };
 
 TEST_F(QuicIdleNetworkDetectorTest,
diff --git a/quiche/quic/core/quic_network_blackhole_detector_test.cc b/quiche/quic/core/quic_network_blackhole_detector_test.cc
index 7849ff2..5d5d15b 100644
--- a/quiche/quic/core/quic_network_blackhole_detector_test.cc
+++ b/quiche/quic/core/quic_network_blackhole_detector_test.cc
@@ -36,9 +36,9 @@
 class QuicNetworkBlackholeDetectorTest : public QuicTest {
  public:
   QuicNetworkBlackholeDetectorTest()
-      : alarms_(&connection_alarms_delegate_, alarm_factory_, arena_),
-        detector_(&delegate_, alarms_.network_blackhole_detector_alarm()),
-        alarm_(QuicNetworkBlackholeDetectorPeer::GetAlarm(&detector_)),
+      : alarms_(&connection_alarms_delegate_, arena_, alarm_factory_),
+        alarm_(&alarms_, QuicAlarmSlot::kNetworkBlackholeDetector),
+        detector_(&delegate_, alarm_),
         path_degrading_delay_(
             QuicTime::Delta::FromSeconds(kPathDegradingDelayInSeconds)),
         path_mtu_reduction_delay_(
@@ -61,11 +61,11 @@
   MockConnectionAlarmsDelegate connection_alarms_delegate_;
   QuicConnectionArena arena_;
   MockAlarmFactory alarm_factory_;
-  QuicConnectionAlarms alarms_;
+  QuicAlarmMultiplexer alarms_;
+  QuicTestAlarmProxy alarm_;
 
   QuicNetworkBlackholeDetector detector_;
 
-  QuicTestAlarmProxy alarm_;
   MockClock clock_;
   const QuicTime::Delta path_degrading_delay_;
   const QuicTime::Delta path_mtu_reduction_delay_;
diff --git a/quiche/quic/core/quic_one_block_arena.h b/quiche/quic/core/quic_one_block_arena.h
index 4dd9ba3..2b28904 100644
--- a/quiche/quic/core/quic_one_block_arena.h
+++ b/quiche/quic/core/quic_one_block_arena.h
@@ -68,9 +68,9 @@
   uint32_t offset_;
 };
 
-// QuicConnections currently use around 1KB of polymorphic types which would
+// QuicConnections currently use around 0.5kB of polymorphic types which would
 // ordinarily be on the heap. Instead, store them inline in an arena.
-using QuicConnectionArena = QuicOneBlockArena<1380>;
+using QuicConnectionArena = QuicOneBlockArena<320>;
 
 }  // namespace quic
 
diff --git a/quiche/quic/core/quic_ping_manager_test.cc b/quiche/quic/core/quic_ping_manager_test.cc
index 4b82224..e2a3155 100644
--- a/quiche/quic/core/quic_ping_manager_test.cc
+++ b/quiche/quic/core/quic_ping_manager_test.cc
@@ -16,10 +16,6 @@
 
 class QuicPingManagerPeer {
  public:
-  static QuicAlarmProxy GetAlarm(QuicPingManager* manager) {
-    return manager->alarm_;
-  }
-
   static void SetPerspective(QuicPingManager* manager,
                              Perspective perspective) {
     manager->perspective_ = perspective;
@@ -40,9 +36,9 @@
 class QuicPingManagerTest : public QuicTest {
  public:
   QuicPingManagerTest()
-      : alarms_(&connection_alarms_delegate_, alarm_factory_, arena_),
-        manager_(Perspective::IS_CLIENT, &delegate_, alarms_.ping_alarm()),
-        alarm_(QuicPingManagerPeer::GetAlarm(&manager_)) {
+      : alarms_(&connection_alarms_delegate_, arena_, alarm_factory_),
+        alarm_(&alarms_, QuicAlarmSlot::kPing),
+        manager_(Perspective::IS_CLIENT, &delegate_, alarm_) {
     clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
     ON_CALL(connection_alarms_delegate_, OnPingAlarm()).WillByDefault([&] {
       manager_.OnAlarm();
@@ -55,9 +51,9 @@
   MockClock clock_;
   QuicConnectionArena arena_;
   MockAlarmFactory alarm_factory_;
-  QuicConnectionAlarms alarms_;
-  QuicPingManager manager_;
+  QuicAlarmMultiplexer alarms_;
   QuicTestAlarmProxy alarm_;
+  QuicPingManager manager_;
 };
 
 TEST_F(QuicPingManagerTest, KeepAliveTimeout) {
diff --git a/quiche/quic/test_tools/quic_connection_peer.cc b/quiche/quic/test_tools/quic_connection_peer.cc
index e74ae4c..f5428d1 100644
--- a/quiche/quic/test_tools/quic_connection_peer.cc
+++ b/quiche/quic/test_tools/quic_connection_peer.cc
@@ -6,8 +6,6 @@
 
 #include <memory>
 #include <string>
-#include <variant>
-
 
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/congestion_control/send_algorithm_interface.h"
@@ -27,16 +25,7 @@
 
 // static
 void QuicConnectionAlarmsPeer::Fire(QuicAlarmProxy alarm) {
-  struct {
-    void operator()(QuicConnectionAlarmHolder::AlarmProxy alarm) {
-      auto* real_alarm = static_cast<TestAlarmFactory::TestAlarm*>(alarm.alarm_);
-      real_alarm->Fire();
-    }
-    void operator()(QuicAlarmMultiplexer::AlarmProxy alarm) {
-      alarm.multiplexer_->Fire(alarm.slot_);
-    }
-  } visitor;
-  std::visit(visitor, alarm.alarm_);
+  alarm.multiplexer_->Fire(alarm.slot_);
 }
 
 // static
@@ -140,47 +129,50 @@
 
 // static
 QuicAlarmProxy QuicConnectionPeer::GetAckAlarm(QuicConnection* connection) {
-  return connection->alarms_.ack_alarm();
+  return QuicAlarmProxy(&connection->alarms_, QuicAlarmSlot::kAck);
 }
 
 // static
 QuicAlarmProxy QuicConnectionPeer::GetPingAlarm(QuicConnection* connection) {
-  return connection->alarms_.ping_alarm();
+  return QuicAlarmProxy(&connection->alarms_, QuicAlarmSlot::kPing);
 }
 
 // static
 QuicAlarmProxy QuicConnectionPeer::GetRetransmissionAlarm(
     QuicConnection* connection) {
-  return connection->alarms_.retransmission_alarm();
+  return QuicAlarmProxy(&connection->alarms_, QuicAlarmSlot::kRetransmission);
 }
 
 // static
 QuicAlarmProxy QuicConnectionPeer::GetSendAlarm(QuicConnection* connection) {
-  return connection->alarms_.send_alarm();
+  return QuicAlarmProxy(&connection->alarms_, QuicAlarmSlot::kSend);
 }
 
 // static
 QuicAlarmProxy QuicConnectionPeer::GetMtuDiscoveryAlarm(
     QuicConnection* connection) {
-  return connection->alarms_.mtu_discovery_alarm();
+  return QuicAlarmProxy(&connection->alarms_, QuicAlarmSlot::kMtuDiscovery);
 }
 
 // static
 QuicAlarmProxy QuicConnectionPeer::GetProcessUndecryptablePacketsAlarm(
     QuicConnection* connection) {
-  return connection->alarms_.process_undecryptable_packets_alarm();
+  return QuicAlarmProxy(&connection->alarms_,
+                        QuicAlarmSlot::kProcessUndecryptablePackets);
 }
 
 // static
 QuicAlarmProxy QuicConnectionPeer::GetDiscardPreviousOneRttKeysAlarm(
     QuicConnection* connection) {
-  return connection->alarms_.discard_previous_one_rtt_keys_alarm();
+  return QuicAlarmProxy(&connection->alarms_,
+                        QuicAlarmSlot::kDiscardPreviousOneRttKeys);
 }
 
 // static
 QuicAlarmProxy QuicConnectionPeer::GetDiscardZeroRttDecryptionKeysAlarm(
     QuicConnection* connection) {
-  return connection->alarms_.discard_zero_rtt_decryption_keys_alarm();
+  return QuicAlarmProxy(&connection->alarms_,
+                        QuicAlarmSlot::kDiscardZeroRttDecryptionKeys);
 }
 
 // static
@@ -345,7 +337,8 @@
 // static
 QuicAlarmProxy QuicConnectionPeer::GetBlackholeDetectorAlarm(
     QuicConnection* connection) {
-  return connection->alarms_.network_blackhole_detector_alarm();
+  return QuicAlarmProxy(&connection->alarms_,
+                        QuicAlarmSlot::kNetworkBlackholeDetector);
 }
 
 // static
@@ -375,7 +368,8 @@
 // static
 QuicAlarmProxy QuicConnectionPeer::GetIdleNetworkDetectorAlarm(
     QuicConnection* connection) {
-  return connection->alarms_.idle_network_detector_alarm();
+  return QuicAlarmProxy(&connection->alarms_,
+                        QuicAlarmSlot::kIdleNetworkDetector);
 }
 
 // static
@@ -387,7 +381,7 @@
 // static
 QuicAlarmProxy QuicConnectionPeer::GetMultiPortProbingAlarm(
     QuicConnection* connection) {
-  return connection->alarms_.multi_port_probing_alarm();
+  return QuicAlarmProxy(&connection->alarms_, QuicAlarmSlot::kMultiPortProbing);
 }
 
 // static
diff --git a/quiche/quic/test_tools/quic_connection_peer.h b/quiche/quic/test_tools/quic_connection_peer.h
index 401d86a..06d8c97 100644
--- a/quiche/quic/test_tools/quic_connection_peer.h
+++ b/quiche/quic/test_tools/quic_connection_peer.h
@@ -40,6 +40,8 @@
 class QuicTestAlarmProxy : public QuicAlarmProxy {
  public:
   explicit QuicTestAlarmProxy(QuicAlarmProxy proxy) : QuicAlarmProxy(proxy) {}
+  QuicTestAlarmProxy(QuicAlarmMultiplexer* multiplexer, QuicAlarmSlot slot)
+      : QuicAlarmProxy(multiplexer, slot) {}
 
   void Fire() { QuicConnectionAlarmsPeer::Fire(*this); }