diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 16d7e5c..5f645bd 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -514,6 +514,11 @@
                        config.IdleNetworkTimeout());
     idle_timeout_connection_close_behavior_ =
         ConnectionCloseBehavior::SILENT_CLOSE;
+    if (GetQuicReloadableFlag(quic_add_silent_idle_timeout) &&
+        perspective_ == Perspective::IS_SERVER) {
+      idle_timeout_connection_close_behavior_ = ConnectionCloseBehavior::
+          SILENT_CLOSE_WITH_CONNECTION_CLOSE_PACKET_SERIALIZED;
+    }
     if (!ValidateConfigConnectionIds(config)) {
       return;
     }
@@ -2573,7 +2578,8 @@
           ? packet->fate
           : GetSerializedPacketFate(is_mtu_discovery, packet->encryption_level);
   // Termination packets are encrypted and saved, so don't exit early.
-  const bool is_termination_packet = IsTerminationPacket(*packet);
+  QuicErrorCode error_code = QUIC_NO_ERROR;
+  const bool is_termination_packet = IsTerminationPacket(*packet, &error_code);
   QuicPacketNumber packet_number = packet->packet_number;
   QuicPacketLength encrypted_length = packet->encrypted_length;
   // Termination packets are eventually owned by TimeWaitListManager.
@@ -2587,6 +2593,17 @@
     char* buffer_copy = CopyBuffer(*packet);
     termination_packets_->emplace_back(
         new QuicEncryptedPacket(buffer_copy, encrypted_length, true));
+    if (error_code == QUIC_SILENT_IDLE_TIMEOUT) {
+      QUIC_RELOADABLE_FLAG_COUNT(quic_add_silent_idle_timeout);
+      DCHECK_EQ(Perspective::IS_SERVER, perspective_);
+      // TODO(fayang): populate histogram indicating the time elapsed from this
+      // connection gets closed to following client packets get received.
+      QUIC_DVLOG(1) << ENDPOINT
+                    << "Added silent connection close to termination packets, "
+                       "num of termination packets: "
+                    << termination_packets_->size();
+      return true;
+    }
   }
 
   DCHECK_LE(encrypted_length, kMaxOutgoingPacketSize);
@@ -3772,12 +3789,14 @@
   }
 }
 
-bool QuicConnection::IsTerminationPacket(const SerializedPacket& packet) {
+bool QuicConnection::IsTerminationPacket(const SerializedPacket& packet,
+                                         QuicErrorCode* error_code) {
   if (packet.retransmittable_frames.empty()) {
     return false;
   }
   for (const QuicFrame& frame : packet.retransmittable_frames) {
     if (frame.type == CONNECTION_CLOSE_FRAME) {
+      *error_code = frame.connection_close_frame->quic_error_code;
       return true;
     }
   }
@@ -4715,7 +4734,12 @@
                     ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
-  CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, error_details,
+  QuicErrorCode error_code = QUIC_NETWORK_IDLE_TIMEOUT;
+  if (GetQuicReloadableFlag(quic_add_silent_idle_timeout) &&
+      perspective_ == Perspective::IS_SERVER) {
+    error_code = QUIC_SILENT_IDLE_TIMEOUT;
+  }
+  CloseConnection(error_code, error_details,
                   idle_timeout_connection_close_behavior_);
 }
 
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 50c6496..22693d2 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -1188,7 +1188,8 @@
   void MaybeSetMtuAlarm(QuicPacketNumber sent_packet_number);
 
   HasRetransmittableData IsRetransmittable(const SerializedPacket& packet);
-  bool IsTerminationPacket(const SerializedPacket& packet);
+  bool IsTerminationPacket(const SerializedPacket& packet,
+                           QuicErrorCode* error_code);
 
   // Set the size of the packet we are targeting while doing path MTU discovery.
   void SetMtuDiscoveryTarget(QuicByteCount target);
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 4d3189d..b39f606 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -11580,6 +11580,43 @@
   EXPECT_EQ(deadline, connection_.GetTimeoutAlarm()->deadline());
 }
 
+TEST_P(QuicConnectionTest, SilentIdleTimeout) {
+  set_perspective(Perspective::IS_SERVER);
+  QuicPacketCreatorPeer::SetSendVersionInPacket(creator_, false);
+  if (version().SupportsAntiAmplificationLimit()) {
+    QuicConnectionPeer::SetAddressValidated(&connection_);
+  }
+
+  QuicConfig config;
+  QuicConfigPeer::SetNegotiated(&config, true);
+  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+    QuicConfigPeer::SetReceivedOriginalConnectionId(
+        &config, connection_.connection_id());
+    QuicConfigPeer::SetReceivedInitialSourceConnectionId(&config,
+                                                         QuicConnectionId());
+  }
+  EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+  connection_.SetFromConfig(config);
+
+  EXPECT_TRUE(connection_.connected());
+  EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet());
+
+  EXPECT_CALL(visitor_,
+              OnConnectionClosed(_, ConnectionCloseSource::FROM_SELF));
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
+  connection_.GetTimeoutAlarm()->Fire();
+  if (GetQuicReloadableFlag(quic_add_silent_idle_timeout)) {
+    // Verify the connection close packets get serialized and added to
+    // termination packets list.
+    EXPECT_NE(nullptr,
+              QuicConnectionPeer::GetConnectionClosePacket(&connection_));
+  } else {
+    // Verify no connection close packet is serialized.
+    EXPECT_EQ(nullptr,
+              QuicConnectionPeer::GetConnectionClosePacket(&connection_));
+  }
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quic/core/quic_error_codes.cc b/quic/core/quic_error_codes.cc
index 7065363..cf153e3 100644
--- a/quic/core/quic_error_codes.cc
+++ b/quic/core/quic_error_codes.cc
@@ -228,6 +228,7 @@
     RETURN_STRING_LITERAL(QUIC_ZERO_RTT_UNRETRANSMITTABLE);
     RETURN_STRING_LITERAL(QUIC_ZERO_RTT_REJECTION_LIMIT_REDUCED);
     RETURN_STRING_LITERAL(QUIC_ZERO_RTT_RESUMPTION_LIMIT_REDUCED);
+    RETURN_STRING_LITERAL(QUIC_SILENT_IDLE_TIMEOUT);
 
     RETURN_STRING_LITERAL(QUIC_LAST_ERROR);
     // Intentionally have no default case, so we'll break the build
@@ -362,6 +363,8 @@
       return {true, static_cast<uint64_t>(PROTOCOL_VIOLATION)};
     case QUIC_NETWORK_IDLE_TIMEOUT:
       return {true, static_cast<uint64_t>(NO_IETF_QUIC_ERROR)};
+    case QUIC_SILENT_IDLE_TIMEOUT:
+      return {true, static_cast<uint64_t>(NO_IETF_QUIC_ERROR)};
     case QUIC_HANDSHAKE_TIMEOUT:
       return {true, static_cast<uint64_t>(NO_IETF_QUIC_ERROR)};
     case QUIC_ERROR_MIGRATING_ADDRESS:
diff --git a/quic/core/quic_error_codes.h b/quic/core/quic_error_codes.h
index 0c990c7..b57eaa7 100644
--- a/quic/core/quic_error_codes.h
+++ b/quic/core/quic_error_codes.h
@@ -489,8 +489,11 @@
   // This is the peer violating QUIC spec.
   QUIC_ZERO_RTT_RESUMPTION_LIMIT_REDUCED = 163,
 
+  // The connection silently timed out due to no network activity.
+  QUIC_SILENT_IDLE_TIMEOUT = 168,
+
   // No error. Used as bound while iterating.
-  QUIC_LAST_ERROR = 168,
+  QUIC_LAST_ERROR = 169,
 };
 // QuicErrorCodes is encoded as four octets on-the-wire when doing Google QUIC,
 // or a varint62 when doing IETF QUIC. Ensure that its value does not exceed
diff --git a/quic/core/quic_types.h b/quic/core/quic_types.h
index 3818dad..55c5046 100644
--- a/quic/core/quic_types.h
+++ b/quic/core/quic_types.h
@@ -211,6 +211,7 @@
 // Should a connection be closed silently or not.
 enum class ConnectionCloseBehavior {
   SILENT_CLOSE,
+  SILENT_CLOSE_WITH_CONNECTION_CLOSE_PACKET_SERIALIZED,
   SEND_CONNECTION_CLOSE_PACKET
 };