diff --git a/quic/core/quic_stream_id_manager.cc b/quic/core/quic_stream_id_manager.cc
index ba31dec..5cde890 100644
--- a/quic/core/quic_stream_id_manager.cc
+++ b/quic/core/quic_stream_id_manager.cc
@@ -55,6 +55,14 @@
         " exceeds incoming max stream ", incoming_advertised_max_streams_);
     return false;
   }
+  if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
+    QUIC_RELOADABLE_FLAG_COUNT(quic_stop_sending_duplicate_max_streams);
+    DCHECK_LE(incoming_advertised_max_streams_, incoming_actual_max_streams_);
+    if (incoming_advertised_max_streams_ == incoming_actual_max_streams_) {
+      // We have told peer about current max.
+      return true;
+    }
+  }
   if (frame.stream_count < incoming_actual_max_streams_) {
     // Peer thinks it's blocked on a stream count that is less than our current
     // max. Inform the peer of the correct stream count.
@@ -104,6 +112,10 @@
 }
 
 void QuicStreamIdManager::SendMaxStreamsFrame() {
+  if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
+    QUIC_BUG_IF(incoming_advertised_max_streams_ >=
+                incoming_actual_max_streams_);
+  }
   incoming_advertised_max_streams_ = incoming_actual_max_streams_;
   delegate_->SendMaxStreams(incoming_advertised_max_streams_, unidirectional_);
 }
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index 2179ba2..689d411 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -139,13 +139,18 @@
 }
 
 // Check the case of the stream count in a STREAMS_BLOCKED frame is less than
-// the count most recently advertised in a MAX_STREAMS frame. This should cause
-// a MAX_STREAMS frame with the most recently advertised count to be sent.
+// the count most recently advertised in a MAX_STREAMS frame.
 TEST_P(QuicStreamIdManagerTest, ProcessStreamsBlockedOk) {
   QuicStreamCount stream_count =
       stream_id_manager_.incoming_initial_max_open_streams();
   QuicStreamsBlockedFrame frame(0, stream_count - 1, IsUnidirectional());
-  EXPECT_CALL(delegate_, SendMaxStreams(stream_count, IsUnidirectional()));
+  if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
+    // We have notified peer about current max.
+    EXPECT_CALL(delegate_, SendMaxStreams(stream_count, IsUnidirectional()))
+        .Times(0);
+  } else {
+    EXPECT_CALL(delegate_, SendMaxStreams(stream_count, IsUnidirectional()));
+  }
   std::string error_details;
   EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
 }
@@ -398,7 +403,12 @@
   // Check that receipt of a STREAMS BLOCKED with stream-count = 0 invokes a
   // MAX STREAMS, count = 123, when the MaxOpen... is set to 123.
   EXPECT_CALL(delegate_, SendMaxStreams(123u, IsUnidirectional()));
-  stream_id_manager_.SetMaxOpenIncomingStreams(123);
+  if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
+    QuicStreamIdManagerPeer::set_incoming_actual_max_streams(
+        &stream_id_manager_, 123);
+  } else {
+    stream_id_manager_.SetMaxOpenIncomingStreams(123);
+  }
   frame.stream_count = 0;
   EXPECT_TRUE(stream_id_manager_.OnStreamsBlockedFrame(frame, &error_details));
 }
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index 7cae0a6..b3dfedc 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -287,18 +287,32 @@
 
   QuicStreamsBlockedFrame frame(kInvalidControlFrameId, stream_count,
                                 /*unidirectional=*/false);
-  EXPECT_CALL(delegate_,
-              SendMaxStreams(manager_.max_incoming_bidirectional_streams(),
-                             frame.unidirectional));
+  if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
+    EXPECT_CALL(delegate_,
+                SendMaxStreams(manager_.max_incoming_bidirectional_streams(),
+                               frame.unidirectional))
+        .Times(0);
+  } else {
+    EXPECT_CALL(delegate_,
+                SendMaxStreams(manager_.max_incoming_bidirectional_streams(),
+                               frame.unidirectional));
+  }
   EXPECT_TRUE(manager_.OnStreamsBlockedFrame(frame, nullptr));
 
   stream_count = manager_.advertised_max_incoming_unidirectional_streams() - 1;
   frame.stream_count = stream_count;
   frame.unidirectional = true;
 
-  EXPECT_CALL(delegate_,
-              SendMaxStreams(manager_.max_incoming_unidirectional_streams(),
-                             frame.unidirectional));
+  if (GetQuicReloadableFlag(quic_stop_sending_duplicate_max_streams)) {
+    EXPECT_CALL(delegate_,
+                SendMaxStreams(manager_.max_incoming_unidirectional_streams(),
+                               frame.unidirectional))
+        .Times(0);
+  } else {
+    EXPECT_CALL(delegate_,
+                SendMaxStreams(manager_.max_incoming_unidirectional_streams(),
+                               frame.unidirectional));
+  }
   EXPECT_TRUE(manager_.OnStreamsBlockedFrame(frame, nullptr));
 }