diff --git a/packages/next/src/server/request/cookies.ts b/packages/next/src/server/request/cookies.ts
index 6b5100b4d762a..090b9de6a4dd8 100644
--- a/packages/next/src/server/request/cookies.ts
+++ b/packages/next/src/server/request/cookies.ts
@@ -171,6 +171,11 @@ function makeHangingCookies(
 function makeUntrackedCookies(
   underlyingCookies: ReadonlyRequestCookies
 ): Promise<ReadonlyRequestCookies> {
+  // If CC is enabled, don't cache the promise.
+  if (process.env.__NEXT_CACHE_COMPONENTS) {
+    return Promise.resolve(underlyingCookies)
+  }
+
   const cachedCookies = CachedCookies.get(underlyingCookies)
   if (cachedCookies) {
     return cachedCookies
@@ -186,14 +191,29 @@ function makeUntrackedCookiesWithDevWarnings(
   underlyingCookies: ReadonlyRequestCookies,
   route?: string
 ): Promise<ReadonlyRequestCookies> {
-  const cachedCookies = CachedCookies.get(underlyingCookies)
-  if (cachedCookies) {
+  // If CC is enabled, don't cache the promise.
+  if (process.env.__NEXT_CACHE_COMPONENTS) {
+    return makeUntrackedCookiesWithDevWarningsImpl(underlyingCookies, route)
+  } else {
+    let cachedCookies = CachedCookies.get(underlyingCookies)
+    if (!cachedCookies) {
+      cachedCookies = makeUntrackedCookiesWithDevWarningsImpl(
+        underlyingCookies,
+        route
+      )
+      CachedCookies.set(underlyingCookies, cachedCookies)
+    }
     return cachedCookies
   }
+}
 
+function makeUntrackedCookiesWithDevWarningsImpl(
+  underlyingCookies: ReadonlyRequestCookies,
+  route?: string
+): Promise<ReadonlyRequestCookies> {
   const promise = makeDevtoolsIOAwarePromise(underlyingCookies)
 
-  const proxiedPromise = new Proxy(promise, {
+  return new Proxy(promise, {
     get(target, prop, receiver) {
       switch (prop) {
         case Symbol.iterator: {
@@ -219,10 +239,6 @@ function makeUntrackedCookiesWithDevWarnings(
       return ReflectAdapter.get(target, prop, receiver)
     },
   })
-
-  CachedCookies.set(underlyingCookies, proxiedPromise)
-
-  return proxiedPromise
 }
 
 const warnForSyncAccess = createDedupedByCallsiteServerErrorLoggerDev(
diff --git a/packages/next/src/server/request/headers.ts b/packages/next/src/server/request/headers.ts
index 48e99793ee21c..72def2be3f61d 100644
--- a/packages/next/src/server/request/headers.ts
+++ b/packages/next/src/server/request/headers.ts
@@ -180,6 +180,11 @@ function makeHangingHeaders(
 function makeUntrackedHeaders(
   underlyingHeaders: ReadonlyHeaders
 ): Promise<ReadonlyHeaders> {
+  // If CC is enabled, don't cache the promise.
+  if (process.env.__NEXT_CACHE_COMPONENTS) {
+    return Promise.resolve(underlyingHeaders)
+  }
+
   const cachedHeaders = CachedHeaders.get(underlyingHeaders)
   if (cachedHeaders) {
     return cachedHeaders
@@ -195,14 +200,29 @@ function makeUntrackedHeadersWithDevWarnings(
   underlyingHeaders: ReadonlyHeaders,
   route?: string
 ): Promise<ReadonlyHeaders> {
-  const cachedHeaders = CachedHeaders.get(underlyingHeaders)
-  if (cachedHeaders) {
+  // If CC is enabled, don't cache the promise.
+  if (process.env.__NEXT_CACHE_COMPONENTS) {
+    return makeUntrackedHeadersWithDevWarningsImpl(underlyingHeaders, route)
+  } else {
+    let cachedHeaders = CachedHeaders.get(underlyingHeaders)
+    if (!cachedHeaders) {
+      cachedHeaders = makeUntrackedHeadersWithDevWarningsImpl(
+        underlyingHeaders,
+        route
+      )
+      CachedHeaders.set(underlyingHeaders, cachedHeaders)
+    }
     return cachedHeaders
   }
+}
 
+function makeUntrackedHeadersWithDevWarningsImpl(
+  underlyingHeaders: ReadonlyHeaders,
+  route?: string
+): Promise<ReadonlyHeaders> {
   const promise = makeDevtoolsIOAwarePromise(underlyingHeaders)
 
-  const proxiedPromise = new Proxy(promise, {
+  return new Proxy(promise, {
     get(target, prop, receiver) {
       switch (prop) {
         case Symbol.iterator: {
@@ -230,10 +250,6 @@ function makeUntrackedHeadersWithDevWarnings(
       return ReflectAdapter.get(target, prop, receiver)
     },
   })
-
-  CachedHeaders.set(underlyingHeaders, proxiedPromise)
-
-  return proxiedPromise
 }
 
 const warnForSyncAccess = createDedupedByCallsiteServerErrorLoggerDev(
diff --git a/packages/next/src/server/request/params.ts b/packages/next/src/server/request/params.ts
index 2e0485b0538d4..e6a89c88c4501 100644
--- a/packages/next/src/server/request/params.ts
+++ b/packages/next/src/server/request/params.ts
@@ -431,6 +431,11 @@ function makeErroringParams(
 }
 
 function makeUntrackedParams(underlyingParams: Params): Promise<Params> {
+  // If CC is enabled, don't cache the promise.
+  if (process.env.__NEXT_CACHE_COMPONENTS) {
+    return Promise.resolve(underlyingParams)
+  }
+
   const cachedParams = CachedParams.get(underlyingParams)
   if (cachedParams) {
     return cachedParams
@@ -447,11 +452,32 @@ function makeDynamicallyTrackedParamsWithDevWarnings(
   hasFallbackParams: boolean,
   store: WorkStore
 ): Promise<Params> {
-  const cachedParams = CachedParams.get(underlyingParams)
-  if (cachedParams) {
+  // If CC is enabled, don't cache the promise.
+  if (process.env.__NEXT_CACHE_COMPONENTS) {
+    return makeDynamicallyTrackedParamsWithDevWarningsImpl(
+      underlyingParams,
+      hasFallbackParams,
+      store
+    )
+  } else {
+    let cachedParams = CachedParams.get(underlyingParams)
+    if (!cachedParams) {
+      cachedParams = makeDynamicallyTrackedParamsWithDevWarningsImpl(
+        underlyingParams,
+        hasFallbackParams,
+        store
+      )
+      CachedParams.set(underlyingParams, cachedParams)
+    }
     return cachedParams
   }
+}
 
+function makeDynamicallyTrackedParamsWithDevWarningsImpl(
+  underlyingParams: Params,
+  hasFallbackParams: boolean,
+  store: WorkStore
+): Promise<Params> {
   // We don't use makeResolvedReactPromise here because params
   // supports copying with spread and we don't want to unnecessarily
   // instrument the promise with spreadable properties of ReactPromise.
@@ -472,7 +498,7 @@ function makeDynamicallyTrackedParamsWithDevWarnings(
     }
   })
 
-  const proxiedPromise = new Proxy(promise, {
+  return new Proxy(promise, {
     get(target, prop, receiver) {
       if (typeof prop === 'string') {
         if (
@@ -497,9 +523,6 @@ function makeDynamicallyTrackedParamsWithDevWarnings(
       return Reflect.ownKeys(target)
     },
   })
-
-  CachedParams.set(underlyingParams, proxiedPromise)
-  return proxiedPromise
 }
 
 const warnForSyncAccess = createDedupedByCallsiteServerErrorLoggerDev(
diff --git a/packages/next/src/server/request/search-params.ts b/packages/next/src/server/request/search-params.ts
index 65718648d86e7..79c5a692b9bbc 100644
--- a/packages/next/src/server/request/search-params.ts
+++ b/packages/next/src/server/request/search-params.ts
@@ -358,6 +358,11 @@ export function makeErroringSearchParamsForUseCache(
 function makeUntrackedSearchParams(
   underlyingSearchParams: SearchParams
 ): Promise<SearchParams> {
+  // If CC is enabled, don't cache the promise.
+  if (process.env.__NEXT_CACHE_COMPONENTS) {
+    return Promise.resolve(underlyingSearchParams)
+  }
+
   const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams)
   if (cachedSearchParams) {
     return cachedSearchParams
@@ -373,11 +378,29 @@ function makeUntrackedSearchParamsWithDevWarnings(
   underlyingSearchParams: SearchParams,
   store: WorkStore
 ): Promise<SearchParams> {
-  const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams)
-  if (cachedSearchParams) {
+  // If CC is enabled, don't cache the promise.
+  if (process.env.__NEXT_CACHE_COMPONENTS) {
+    return makeUntrackedSearchParamsWithDevWarningsImpl(
+      underlyingSearchParams,
+      store
+    )
+  } else {
+    let cachedSearchParams = CachedSearchParams.get(underlyingSearchParams)
+    if (!cachedSearchParams) {
+      cachedSearchParams = makeUntrackedSearchParamsWithDevWarningsImpl(
+        underlyingSearchParams,
+        store
+      )
+      CachedSearchParams.set(underlyingSearchParams, cachedSearchParams)
+    }
     return cachedSearchParams
   }
+}
 
+function makeUntrackedSearchParamsWithDevWarningsImpl(
+  underlyingSearchParams: SearchParams,
+  store: WorkStore
+): Promise<SearchParams> {
   // Track which properties we should warn for.
   const proxiedProperties = new Set<string>()
 
@@ -446,7 +469,7 @@ function makeUntrackedSearchParamsWithDevWarnings(
     }
   })
 
-  const proxiedPromise = new Proxy(promise, {
+  return new Proxy(promise, {
     get(target, prop, receiver) {
       if (prop === 'then' && store.dynamicShouldError) {
         const expression = '`searchParams.then`'
@@ -499,9 +522,6 @@ function makeUntrackedSearchParamsWithDevWarnings(
       return Reflect.ownKeys(target)
     },
   })
-
-  CachedSearchParams.set(underlyingSearchParams, proxiedPromise)
-  return proxiedPromise
 }
 
 const warnForSyncAccess = createDedupedByCallsiteServerErrorLoggerDev(