diff --git a/packages/next/src/client/app-call-server.ts b/packages/next/src/client/app-call-server.ts
index c447e163828a..6d6f8e197b02 100644
--- a/packages/next/src/client/app-call-server.ts
+++ b/packages/next/src/client/app-call-server.ts
@@ -1,17 +1,35 @@
 import { startTransition } from 'react'
 import { ACTION_SERVER_ACTION } from './components/router-reducer/router-reducer-types'
 import { dispatchAppRouterAction } from './components/use-action-queue'
+import {
+  getServerActionDispatchContext,
+  type ServerActionDispatchScope,
+} from './server-action-dispatch'
 
-export async function callServer(actionId: string, actionArgs: any[]) {
+function dispatchServerAction(
+  actionId: string,
+  actionArgs: any[],
+  scope?: ServerActionDispatchScope
+) {
   return new Promise((resolve, reject) => {
     startTransition(() => {
       dispatchAppRouterAction({
         type: ACTION_SERVER_ACTION,
         actionId,
         actionArgs,
+        actionDispatchContext: getServerActionDispatchContext(actionId, scope),
         resolve,
         reject,
       })
     })
   })
 }
+
+export async function callServer(actionId: string, actionArgs: any[]) {
+  return dispatchServerAction(actionId, actionArgs)
+}
+
+export function createScopedCallServer(scope: ServerActionDispatchScope) {
+  return (actionId: string, actionArgs: any[]) =>
+    dispatchServerAction(actionId, actionArgs, scope)
+}
diff --git a/packages/next/src/client/app-index.tsx b/packages/next/src/client/app-index.tsx
index e517169017c5..6326beeb15d9 100644
--- a/packages/next/src/client/app-index.tsx
+++ b/packages/next/src/client/app-index.tsx
@@ -13,7 +13,7 @@ import {
   onCaughtError,
   onUncaughtError,
 } from './react-client-callbacks/error-boundary-callbacks'
-import { callServer } from './app-call-server'
+import { createScopedCallServer } from './app-call-server'
 import { findSourceMapURL } from './app-find-source-map-url'
 import {
   type AppRouterActionQueue,
@@ -29,6 +29,10 @@ import { getDeploymentId } from '../shared/lib/deployment-id'
 import { setNavigationBuildId } from './navigation-build-id'
 import type { ClientInstrumentationModules } from './router-transition-types'
 import { initializeRouterTransitionModules } from './components/router-transition'
+import {
+  createServerActionDispatchScope,
+  setServerActionDispatchScopeRoutingKeys,
+} from './server-action-dispatch'
 
 /// <reference types="react-dom/experimental" />
 
@@ -225,13 +229,18 @@ if (
 }
 
 let initialServerResponse: Promise<InitialRSCPayload>
+const initialActionDispatchScope = createServerActionDispatchScope(
+  window.location.href,
+  null
+)
+const initialCallServer = createScopedCallServer(initialActionDispatchScope)
 if (instantTestStaticFetch) {
   // Instant Navigation Testing API: hydrate from the static RSC payload
   // fetch kicked off by an injected <script> tag, instead of the inline
   // Flight data (which is not present in the static shell).
   initialServerResponse = Promise.resolve(
     createFromFetch<InitialRSCPayload>(instantTestStaticFetch, {
-      callServer,
+      callServer: initialCallServer,
       findSourceMapURL,
       debugChannel,
       // The static fetch response is a partial stream (static-only Flight
@@ -255,7 +264,7 @@ if (instantTestStaticFetch) {
     window.__NEXT_CLIENT_RESUME
   initialServerResponse = Promise.resolve(
     createFromFetch<InitialRSCPayload>(clientResumeFetch, {
-      callServer,
+      callServer: initialCallServer,
       findSourceMapURL,
       debugChannel,
     })
@@ -269,7 +278,7 @@ if (instantTestStaticFetch) {
   initialServerResponse = createFromReadableStream<InitialRSCPayload>(
     readable,
     {
-      callServer,
+      callServer: initialCallServer,
       findSourceMapURL,
       debugChannel,
       startTime: 0,
@@ -358,6 +367,10 @@ export async function hydrate(
     webSocket = createWebSocket(assetPrefix, staticIndicatorState)
   }
   const initialRSCPayload = await initialServerResponse
+  setServerActionDispatchScopeRoutingKeys(
+    initialActionDispatchScope,
+    initialRSCPayload.A
+  )
 
   // Initialize the offline module to register browser event listeners
   // (offline/online) before any components hydrate.
diff --git a/packages/next/src/client/components/router-reducer/create-initial-router-state.ts b/packages/next/src/client/components/router-reducer/create-initial-router-state.ts
index c5ee737b77bd..1ea21da6b202 100644
--- a/packages/next/src/client/components/router-reducer/create-initial-router-state.ts
+++ b/packages/next/src/client/components/router-reducer/create-initial-router-state.ts
@@ -21,6 +21,7 @@ import {
 import { decodeStageUntilBoundary } from './fetch-server-response'
 import { discoverKnownRoute } from '../segment-cache/optimistic-routes'
 import type { NormalizedSearch } from '../segment-cache/cache-key'
+import { registerServerActionDispatchContext } from '../../server-action-dispatch'
 
 export interface InitialRouterStateParameters {
   navigatedAt: number
@@ -68,6 +69,10 @@ export function createInitialRouterState({
         createHrefFromUrl(location)
       : initialCanonicalUrl
 
+  if (location !== null) {
+    registerServerActionDispatchContext(initialRSCPayload.A, canonicalUrl, null)
+  }
+
   // Decode the initial transport tree into the RouteTree type, with the
   // payload's render output embedded on each node. (discoverKnownRoute below
   // stores this tree in the route cache, which strips the data on write —
@@ -106,7 +111,7 @@ export function createInitialRouterState({
   // route learning nor segment cache state persists from SSR to client.
   if (location !== null && metadataVaryPath !== null) {
     // Learn the route pattern so we can predict it for future navigations.
-    discoverKnownRoute(
+    const fulfilledRoute = discoverKnownRoute(
       Date.now(),
       location.pathname,
       location.search as NormalizedSearch,
@@ -119,6 +124,7 @@ export function createInitialRouterState({
       initialSupportsPerSegmentPrefetching,
       false // hasDynamicRewrite
     )
+    fulfilledRoute.actionRoutingKeys = initialRSCPayload.A ?? null
 
     // TODO: Implement Shell extraction as part of Cached Navigations.
     // Intentionally holding off on doing this until we decide how the Cached
@@ -141,7 +147,12 @@ export function createInitialRouterState({
               await decodeStageUntilBoundary<InitialRSCPayload>(
                 initialFlightStreamForCache,
                 byteLength,
-                undefined
+                undefined,
+                {
+                  url: canonicalUrl,
+                  nextUrl: null,
+                  actionRoutingKeys: initialRSCPayload.A,
+                }
               )
             const now = Date.now()
             const staleAt = await resolveStaleAt(now, staticStageResponse.s)
@@ -206,7 +217,12 @@ export function createInitialRouterState({
         Date.now(),
         initialRuntimePrefetchStream,
         initialTree,
-        initialRenderedSearch
+        initialRenderedSearch,
+        {
+          url: canonicalUrl,
+          nextUrl: null,
+          actionRoutingKeys: initialRSCPayload.A,
+        }
       )
         .then((processed) => {
           if (processed !== null) {
diff --git a/packages/next/src/client/components/router-reducer/fetch-server-response.ts b/packages/next/src/client/components/router-reducer/fetch-server-response.ts
index 73999c01bc5e..7bb7b68dbc34 100644
--- a/packages/next/src/client/components/router-reducer/fetch-server-response.ts
+++ b/packages/next/src/client/components/router-reducer/fetch-server-response.ts
@@ -28,7 +28,7 @@ import {
   NEXT_HTML_REQUEST_ID_HEADER,
   NEXT_REQUEST_ID_HEADER,
 } from '../app-router-headers'
-import { callServer } from '../../app-call-server'
+import { callServer, createScopedCallServer } from '../../app-call-server'
 import { findSourceMapURL } from '../../app-find-source-map-url'
 import { prepareFlightRouterStateForRequest } from '../../flight-data-helpers'
 import type { PartialTransportData } from '../../../shared/lib/rsc-transport'
@@ -43,6 +43,12 @@ import {
   createNonTaskyPrefetchResponseStream,
 } from '../segment-cache/cache'
 import { UnknownDynamicStaleTime } from '../segment-cache/bfcache'
+import {
+  createServerActionDispatchScope,
+  setServerActionDispatchScopeContext,
+  setServerActionDispatchScopeRoutingKeys,
+  type ServerActionDispatchScope,
+} from '../../server-action-dispatch'
 
 const createFromReadableStream =
   createFromReadableStreamBrowser as (typeof import('react-server-dom-webpack/client.browser'))['createFromReadableStream']
@@ -81,6 +87,7 @@ type SpaFetchServerResponseResult = {
   renderedSearch: NormalizedSearch
   couldBeIntercepted: boolean
   supportsPerSegmentPrefetching: boolean
+  actionRoutingKeys: readonly string[] | null
   postponed: boolean
   dynamicStaleTime: number
   staticStageData: StaticStageData | null
@@ -118,6 +125,12 @@ export type RequestHeaders = {
   [NEXT_REQUEST_ID_HEADER]?: string // dev-only
 }
 
+export type FlightDecoderActionDispatchContext = {
+  url: string | URL
+  nextUrl: string | null
+  actionRoutingKeys?: readonly string[] | null
+}
+
 function doMpaNavigation(url: string): FetchServerResponseResult {
   return urlToUrlWithoutFlightMarker(new URL(url, location.origin)).toString()
 }
@@ -259,7 +272,10 @@ export async function fetchServerResponse(
         createFromNextReadableStream<NavigationFlightResponse>(
           res.body,
           headers,
-          { allowPartialStream: postponed }
+          {
+            allowPartialStream: postponed,
+            actionDispatchContext: { url: canonicalUrl, nextUrl },
+          }
         )
     }
 
@@ -284,7 +300,11 @@ export async function fetchServerResponse(
 
     const staticStageData =
       cacheData !== null
-        ? await resolveStaticStageData(cacheData, flightResponse, headers)
+        ? await resolveStaticStageData(cacheData, flightResponse, headers, {
+            url: canonicalUrl,
+            nextUrl,
+            actionRoutingKeys: flightResponse.A,
+          })
         : null
 
     return {
@@ -300,6 +320,7 @@ export async function fetchServerResponse(
       renderedSearch: flightResponse.q as NormalizedSearch,
       couldBeIntercepted: interception,
       supportsPerSegmentPrefetching: flightResponse.S,
+      actionRoutingKeys: flightResponse.A ?? null,
       postponed,
       // The dynamicStaleTime is only present in the response body when
       // a page exports unstable_dynamicStaleTime and this is a dynamic render.
@@ -460,7 +481,8 @@ export async function resolveStaticStageData<
 >(
   cacheData: FetchResponseCacheData,
   flightResponse: T,
-  headers: RequestHeaders | undefined
+  headers: RequestHeaders | undefined,
+  actionDispatchContext?: FlightDecoderActionDispatchContext
 ): Promise<StaticStageData<T> | null> {
   const { isResponsePartial, staticBodyClone } = cacheData
 
@@ -479,7 +501,8 @@ export async function resolveStaticStageData<
       const response = await decodeStageUntilBoundary<T>(
         staticBodyClone,
         staticStageByteLength,
-        headers
+        headers,
+        actionDispatchContext
       )
 
       return { response, isResponsePartial: true }
@@ -510,7 +533,8 @@ export async function resolveShellStageData<
 >(
   cacheData: FetchResponseCacheData,
   flightResponse: T,
-  headers: RequestHeaders | undefined
+  headers: RequestHeaders | undefined,
+  actionDispatchContext?: FlightDecoderActionDispatchContext
 ): Promise<T | null> {
   const { shellBodyClone } = cacheData
 
@@ -530,7 +554,12 @@ export async function resolveShellStageData<
     return null
   }
 
-  return decodeStageUntilBoundary<T>(shellBodyClone, shellByteLength, headers)
+  return decodeStageUntilBoundary<T>(
+    shellBodyClone,
+    shellByteLength,
+    headers,
+    actionDispatchContext
+  )
 }
 
 /**
@@ -541,13 +570,14 @@ export async function resolveShellStageData<
 export async function decodeStageUntilBoundary<T>(
   responseBodyClone: ReadableStream<Uint8Array>,
   byteLength: number,
-  headers: RequestHeaders | undefined
+  headers: RequestHeaders | undefined,
+  actionDispatchContext?: FlightDecoderActionDispatchContext
 ): Promise<T> {
   const { buffer } = await createNonTaskyPrefetchResponseStream(
     responseBodyClone,
     byteLength
   )
-  return decodeBufferedStage<T>(buffer, headers)
+  return decodeBufferedStage<T>(buffer, headers, actionDispatchContext)
 }
 
 /**
@@ -559,7 +589,8 @@ export async function decodeStageUntilBoundary<T>(
  */
 export function decodeBufferedStage<T>(
   buffer: Uint8Array,
-  headers: RequestHeaders | undefined
+  headers: RequestHeaders | undefined,
+  actionDispatchContext?: FlightDecoderActionDispatchContext
 ): Promise<T> {
   const stream = new ReadableStream<Uint8Array>({
     start(controller) {
@@ -569,6 +600,7 @@ export function decodeBufferedStage<T>(
   })
   return createFromNextReadableStream<T>(stream, headers, {
     allowPartialStream: true,
+    actionDispatchContext,
   })
 }
 
@@ -584,7 +616,8 @@ export function decodeBufferedStage<T>(
 function createHaltingFlightResponse<T>(
   fetchPromise: Promise<Response>,
   headers: RequestHeaders,
-  signal: AbortSignal
+  signal: AbortSignal,
+  actionDispatchScope: ServerActionDispatchScope
 ): Promise<T> & { _debugInfo?: Array<any> } {
   let closed = false
   let reader: ReadableStreamDefaultReader<Uint8Array> | null = null
@@ -665,9 +698,12 @@ function createHaltingFlightResponse<T>(
   })
 
   // React attaches `_debugInfo` to the returned promise at runtime.
-  return createFromNextReadableStream<T>(wrapper, headers, {
-    allowPartialStream: true,
-  }) as Promise<T> & { _debugInfo?: Array<any> }
+  return createFromReadableStreamWithScope<T>(
+    wrapper,
+    headers,
+    true,
+    actionDispatchScope
+  ) as Promise<T> & { _debugInfo?: Array<any> }
 }
 
 // Selects the Flight decode strategy: a halting wrapper for cancellable HMR
@@ -677,16 +713,22 @@ function createHaltingFlightResponse<T>(
 function decodeFlightResponse<T>(
   fetchPromise: Promise<Response>,
   headers: RequestHeaders,
-  signal: AbortSignal | undefined
+  signal: AbortSignal | undefined,
+  actionDispatchScope: ServerActionDispatchScope
 ): Promise<T> & { _debugInfo?: Array<any> } {
   if (
     process.env.__NEXT_DEV_SERVER &&
     process.env.__NEXT_SERVER_COMPONENTS_HMR_CANCELLATION &&
     signal
   ) {
-    return createHaltingFlightResponse<T>(fetchPromise, headers, signal)
+    return createHaltingFlightResponse<T>(
+      fetchPromise,
+      headers,
+      signal,
+      actionDispatchScope
+    )
   }
-  return createFromNextFetch<T>(fetchPromise, headers)
+  return createFromNextFetch<T>(fetchPromise, headers, actionDispatchScope)
 }
 
 export async function createFetch<T>(
@@ -736,6 +778,10 @@ export async function createFetch<T>(
   await setCacheBustingSearchParam(fetchUrl, headers)
   let processed = fetch(fetchUrl, fetchOptions).then(processFetch)
   let fetchPromise = processed.then(({ response }) => response)
+  let actionDispatchScope = createServerActionDispatchScope(
+    url,
+    headers[NEXT_URL] ?? null
+  )
 
   // Immediately pass the fetch promise to the Flight client so that the debug
   // info includes the latency from the client to the server. The internal timer
@@ -746,7 +792,12 @@ export async function createFetch<T>(
   // been written into the cache by the time the navigation happens, the router
   // will go straight to a dynamic request.
   let flightResponsePromise = shouldImmediatelyDecode
-    ? decodeFlightResponse<T>(fetchPromise, headers, signal)
+    ? decodeFlightResponse<T>(
+        fetchPromise,
+        headers,
+        signal,
+        actionDispatchScope
+      )
     : null
   let browserResponse = await fetchPromise
 
@@ -806,8 +857,17 @@ export async function createFetch<T>(
       await setCacheBustingSearchParam(fetchUrl, headers)
       processed = fetch(fetchUrl, fetchOptions).then(processFetch)
       fetchPromise = processed.then(({ response }) => response)
+      actionDispatchScope = createServerActionDispatchScope(
+        responseUrl,
+        headers[NEXT_URL] ?? null
+      )
       flightResponsePromise = shouldImmediatelyDecode
-        ? decodeFlightResponse<T>(fetchPromise, headers, signal)
+        ? decodeFlightResponse<T>(
+            fetchPromise,
+            headers,
+            signal,
+            actionDispatchScope
+          )
         : null
       browserResponse = await fetchPromise
       // We just performed a manual redirect, so this is now true.
@@ -819,6 +879,14 @@ export async function createFetch<T>(
   // from leaking outside of this function.
   const responseUrl = new URL(browserResponse.url, fetchUrl)
   responseUrl.searchParams.delete(NEXT_RSC_UNION_QUERY)
+  setServerActionDispatchScopeContext(
+    actionDispatchScope,
+    responseUrl,
+    headers[NEXT_URL] ?? null
+  )
+  if (flightResponsePromise !== null) {
+    trackActionRoutingKeys(flightResponsePromise, actionDispatchScope)
+  }
 
   const rscResponse: RSCResponse<T> = {
     url: responseUrl.href,
@@ -851,23 +919,82 @@ export async function createFetch<T>(
 export function createFromNextReadableStream<T>(
   flightStream: ReadableStream<Uint8Array>,
   requestHeaders: RequestHeaders | undefined,
-  options?: { allowPartialStream?: boolean }
+  options?: {
+    allowPartialStream?: boolean
+    actionDispatchContext?: FlightDecoderActionDispatchContext
+  }
+): Promise<T> {
+  const actionDispatchContext = options?.actionDispatchContext
+  if (actionDispatchContext === undefined) {
+    return createFromReadableStreamWithScope(
+      flightStream,
+      requestHeaders,
+      options?.allowPartialStream
+    )
+  }
+
+  const actionDispatchScope = createServerActionDispatchScope(
+    actionDispatchContext.url,
+    actionDispatchContext.nextUrl,
+    actionDispatchContext.actionRoutingKeys
+  )
+  const response = createFromReadableStreamWithScope<T>(
+    flightStream,
+    requestHeaders,
+    options?.allowPartialStream,
+    actionDispatchScope
+  )
+  if (actionDispatchContext.actionRoutingKeys === undefined) {
+    trackActionRoutingKeys(response, actionDispatchScope)
+  }
+  return response
+}
+
+function createFromReadableStreamWithScope<T>(
+  flightStream: ReadableStream<Uint8Array>,
+  requestHeaders: RequestHeaders | undefined,
+  allowPartialStream?: boolean,
+  actionDispatchScope?: ServerActionDispatchScope
 ): Promise<T> {
   return createFromReadableStream(flightStream, {
-    callServer,
+    callServer:
+      actionDispatchScope === undefined
+        ? callServer
+        : createScopedCallServer(actionDispatchScope),
     findSourceMapURL,
     debugChannel: createDebugChannel && createDebugChannel(requestHeaders),
-    unstable_allowPartialStream: options?.allowPartialStream,
+    unstable_allowPartialStream: allowPartialStream,
   })
 }
 
 function createFromNextFetch<T>(
   promiseForResponse: Promise<Response>,
-  requestHeaders: RequestHeaders
+  requestHeaders: RequestHeaders,
+  actionDispatchScope: ServerActionDispatchScope
 ): Promise<T> & { _debugInfo?: Array<any> } {
   return createFromFetch(promiseForResponse, {
-    callServer,
+    callServer: createScopedCallServer(actionDispatchScope),
     findSourceMapURL,
     debugChannel: createDebugChannel && createDebugChannel(requestHeaders),
   })
 }
+
+function trackActionRoutingKeys<T>(
+  response: Promise<T>,
+  scope: ServerActionDispatchScope
+): void {
+  void response.then(
+    (value) => {
+      let routingKeys: readonly string[] | undefined
+      if (value !== null && typeof value === 'object') {
+        const payload = value as {
+          A?: readonly string[]
+          actionRoutingKeys?: readonly string[]
+        }
+        routingKeys = payload.A ?? payload.actionRoutingKeys
+      }
+      setServerActionDispatchScopeRoutingKeys(scope, routingKeys)
+    },
+    () => {}
+  )
+}
diff --git a/packages/next/src/client/components/router-reducer/ppr-navigations.ts b/packages/next/src/client/components/router-reducer/ppr-navigations.ts
index 209d30755a01..e3cfecffcdef 100644
--- a/packages/next/src/client/components/router-reducer/ppr-navigations.ts
+++ b/packages/next/src/client/components/router-reducer/ppr-navigations.ts
@@ -57,6 +57,7 @@ import {
   updateBFCacheEntryStaleAt,
   computeDynamicStaleAt,
 } from '../segment-cache/bfcache'
+import { registerServerActionDispatchContext } from '../../server-action-dispatch'
 
 // This is yet another tree type that is used to track pending promises that
 // need to be fulfilled once the dynamic data is received. The terminal nodes of
@@ -1812,6 +1813,12 @@ async function fetchMissingDynamicData(
       await navigationLock
     }
 
+    registerServerActionDispatchContext(
+      result.actionRoutingKeys ?? undefined,
+      result.canonicalUrl,
+      nextUrl
+    )
+
     // TODO: Implement Shell extraction as part of Cached Navigations.
     // Intentionally holding off on doing this until we decide how the Cached
     // Navigations behavior should work in combination with App Shells.
@@ -1848,7 +1855,12 @@ async function fetchMissingDynamicData(
         now,
         result.runtimePrefetchStream,
         dynamicRequestTree,
-        result.renderedSearch
+        result.renderedSearch,
+        {
+          url: result.canonicalUrl,
+          nextUrl,
+          actionRoutingKeys: result.actionRoutingKeys,
+        }
       )
         .then((processed) => {
           if (processed !== null) {
diff --git a/packages/next/src/client/components/router-reducer/reducers/server-action-reducer.ts b/packages/next/src/client/components/router-reducer/reducers/server-action-reducer.ts
index e7bbd2fd8b94..3d28437a10d4 100644
--- a/packages/next/src/client/components/router-reducer/reducers/server-action-reducer.ts
+++ b/packages/next/src/client/components/router-reducer/reducers/server-action-reducer.ts
@@ -2,7 +2,7 @@ import type {
   ActionFlightResponse,
   ActionResult,
 } from '../../../../shared/lib/app-router-types'
-import { callServer } from '../../../app-call-server'
+import { createScopedCallServer } from '../../../app-call-server'
 import { findSourceMapURL } from '../../../app-find-source-map-url'
 import {
   ACTION_HEADER,
@@ -70,6 +70,11 @@ import {
   invalidateBfCache,
   UnknownDynamicStaleTime,
 } from '../../segment-cache/bfcache'
+import {
+  createServerActionDispatchScope,
+  registerServerActionDispatchContext,
+  setServerActionDispatchScopeRoutingKeys,
+} from '../../../server-action-dispatch'
 
 const createFromFetch =
   createFromFetchBrowser as (typeof import('react-server-dom-webpack/client.browser'))['createFromFetch']
@@ -98,6 +103,7 @@ type FetchServerActionResult = {
    */
   actionFlightData: PartialTransportData | string | undefined
   actionFlightDataRenderedSearch: NormalizedSearch | undefined
+  actionRoutingKeys: readonly string[] | undefined
   isPrerender: boolean
   couldBeIntercepted: boolean
 }
@@ -107,7 +113,30 @@ async function fetchServerAction(
   nextUrl: ReadonlyReducerState['nextUrl'],
   action: ServerActionAction
 ): Promise<FetchServerActionResult> {
-  const { actionId, actionArgs } = action
+  const { actionId, actionArgs, actionDispatchContext } = action
+  const currentRequestUrl = new URL(state.canonicalUrl, window.location.origin)
+  let actionRequestUrl = currentRequestUrl
+  let actionNextUrl = nextUrl
+  if (actionDispatchContext !== undefined) {
+    const registeredActionRequestUrl = new URL(
+      actionDispatchContext.url,
+      window.location.origin
+    )
+    // Search params do not affect which route worker handles the request. If
+    // they changed after this action was registered, preserve the URL at the
+    // time of invocation instead of dispatching against the stale search.
+    if (
+      registeredActionRequestUrl.pathname !== currentRequestUrl.pathname ||
+      actionDispatchContext.nextUrl !== nextUrl
+    ) {
+      actionRequestUrl = registeredActionRequestUrl
+      actionNextUrl = actionDispatchContext.nextUrl
+    }
+  }
+  const isCrossRouteDispatch =
+    actionRequestUrl.pathname !== currentRequestUrl.pathname ||
+    actionRequestUrl.search !== currentRequestUrl.search ||
+    actionNextUrl !== nextUrl
   const temporaryReferences = createTemporaryReferenceSet()
   const info = extractInfoFromServerReferenceId(actionId)
   const usedArgs = omitUnusedArgs(actionArgs, info)
@@ -116,9 +145,12 @@ async function fetchServerAction(
   const headers: Record<string, string> = {
     Accept: RSC_CONTENT_TYPE_HEADER,
     [ACTION_HEADER]: actionId,
-    [NEXT_ROUTER_STATE_TREE_HEADER]: prepareFlightRouterStateForRequest(
+  }
+
+  if (!isCrossRouteDispatch) {
+    headers[NEXT_ROUTER_STATE_TREE_HEADER] = prepareFlightRouterStateForRequest(
       state.tree
-    ),
+    )
   }
 
   const deploymentId = getDeploymentId()
@@ -126,8 +158,8 @@ async function fetchServerAction(
     headers['x-deployment-id'] = deploymentId
   }
 
-  if (nextUrl) {
-    headers[NEXT_URL] = nextUrl
+  if (actionNextUrl) {
+    headers[NEXT_URL] = actionNextUrl
   }
 
   if (process.env.__NEXT_DEV_SERVER) {
@@ -145,7 +177,11 @@ async function fetchServerAction(
 
   let res: Response
   try {
-    res = await fetch(state.canonicalUrl, { method: 'POST', headers, body })
+    res = await fetch(createHrefFromUrl(actionRequestUrl), {
+      method: 'POST',
+      headers,
+      body,
+    })
     // If the fetch succeeds while we're in the offline state, notify the
     // offline module so it can short-circuit the polling loop.
     if (process.env.__NEXT_USE_OFFLINE) {
@@ -238,6 +274,7 @@ async function fetchServerAction(
   let actionResult: FetchServerActionResult['actionResult']
   let actionFlightData: FetchServerActionResult['actionFlightData']
   let actionFlightDataRenderedSearch: FetchServerActionResult['actionFlightDataRenderedSearch']
+  let actionRoutingKeys: FetchServerActionResult['actionRoutingKeys']
   let couldBeIntercepted: boolean = false
 
   if (isRscResponse) {
@@ -247,20 +284,29 @@ async function fetchServerAction(
     const responsePromise = redirectLocation
       ? processFetch(res).then(({ response: r }) => r)
       : Promise.resolve(res)
+    const responseActionDispatchScope = createServerActionDispatchScope(
+      redirectLocation ?? actionRequestUrl,
+      redirectLocation === undefined ? actionNextUrl : nextUrl
+    )
 
     const response: ActionFlightResponse = await createFromFetch(
       responsePromise,
       {
-        callServer,
+        callServer: createScopedCallServer(responseActionDispatchScope),
         findSourceMapURL,
         temporaryReferences,
         debugChannel: createDebugChannel && createDebugChannel(headers),
       }
     )
+    setServerActionDispatchScopeRoutingKeys(
+      responseActionDispatchScope,
+      response.A
+    )
 
     // An internal redirect can send an RSC response, but does not have a useful `actionResult`.
     actionResult = redirectLocation ? undefined : response.a
     couldBeIntercepted = response.i
+    actionRoutingKeys = response.A
 
     // Check if the response build ID matches the client build ID.
     // In a multi-zone setup, when a server action triggers a redirect,
@@ -293,12 +339,14 @@ async function fetchServerAction(
     actionResult = undefined
     actionFlightData = undefined
     actionFlightDataRenderedSearch = undefined
+    actionRoutingKeys = undefined
   }
 
   return {
     actionResult,
     actionFlightData,
     actionFlightDataRenderedSearch,
+    actionRoutingKeys,
     redirectLocation,
     redirectType,
     revalidationKind,
@@ -338,6 +386,7 @@ export function serverActionReducer(
       actionResult,
       actionFlightData: flightData,
       actionFlightDataRenderedSearch: flightDataRenderedSearch,
+      actionRoutingKeys,
       redirectLocation,
       redirectType,
       isPrerender,
@@ -472,6 +521,11 @@ export function serverActionReducer(
         // new fetch, like we would for a normal navigation.
         const redirectCanonicalUrl = createHrefFromUrl(redirectUrl)
         const now = Date.now()
+        registerServerActionDispatchContext(
+          actionRoutingKeys,
+          redirectCanonicalUrl,
+          nextUrl
+        )
         // TODO: Store the dynamic stale time on the top-level state so it's
         // known during restores and refreshes.
         const redirectSeed = convertServerPatchToFullTree(
@@ -485,7 +539,7 @@ export function serverActionReducer(
         // Learn the route pattern so we can predict it for future navigations.
         const metadataVaryPath = redirectSeed.metadataVaryPath
         if (metadataVaryPath !== null) {
-          discoverKnownRoute(
+          const fulfilledRoute = discoverKnownRoute(
             now,
             redirectUrl.pathname,
             redirectUrl.search as NormalizedSearch,
@@ -498,6 +552,7 @@ export function serverActionReducer(
             isPrerender,
             false // hasDynamicRewrite
           )
+          fulfilledRoute.actionRoutingKeys = actionRoutingKeys ?? null
         }
         const navigationLock = getCurrentNavigationLock()
 
diff --git a/packages/next/src/client/components/router-reducer/router-reducer-types.ts b/packages/next/src/client/components/router-reducer/router-reducer-types.ts
index 5bce9f1e49f7..c23ccfbadc5c 100644
--- a/packages/next/src/client/components/router-reducer/router-reducer-types.ts
+++ b/packages/next/src/client/components/router-reducer/router-reducer-types.ts
@@ -3,6 +3,7 @@ import type { FlightRouterState } from '../../../shared/lib/app-router-types'
 import type { NavigationSeed } from '../segment-cache/decode-server-response'
 import type { FetchServerResponseResult } from './fetch-server-response'
 import type { FreshnessPolicy } from './ppr-navigations'
+import type { ServerActionDispatchContext } from '../../server-action-dispatch'
 
 export const ACTION_REFRESH = 'refresh'
 export const ACTION_NAVIGATE = 'navigate'
@@ -52,6 +53,12 @@ export interface ServerActionAction {
   type: typeof ACTION_SERVER_ACTION
   actionId: string
   actionArgs: any[]
+  /**
+   * The route that owns this action, if it was advertised in a Flight payload.
+   * Missing context falls back to the current route so version-skewed action
+   * IDs retain the existing unrecognized-action behavior.
+   */
+  actionDispatchContext: ServerActionDispatchContext | undefined
   resolve: (value: any) => void
   reject: (reason?: any) => void
   didRevalidate?: boolean
diff --git a/packages/next/src/client/components/segment-cache/cache.ts b/packages/next/src/client/components/segment-cache/cache.ts
index a777012ed880..5ba9434b2ead 100644
--- a/packages/next/src/client/components/segment-cache/cache.ts
+++ b/packages/next/src/client/components/segment-cache/cache.ts
@@ -27,6 +27,7 @@ import {
   createFromNextReadableStream,
   decodeBufferedStage,
   resolveShellStageData,
+  type FlightDecoderActionDispatchContext,
   type RSCResponse,
   type RequestHeaders,
 } from '../router-reducer/fetch-server-response'
@@ -218,6 +219,9 @@ type RouteCacheEntryShared = {
   // received a response from the server.
   couldBeIntercepted: boolean
 
+  // Opaque routing keys for Server Actions handled by this route's worker.
+  actionRoutingKeys: readonly string[] | null
+
   // When true, this entry should not be used as a template for route
   // prediction. Set when we discover that the URL was rewritten by middleware
   // to a different route structure (e.g., /foo was rewritten to /bar). Since
@@ -697,6 +701,7 @@ function createDetachedRouteCacheEntry(): PendingRouteCacheEntry {
     // could be intercepted. It's only set to false once we receive a response
     // from the server.
     couldBeIntercepted: true,
+    actionRoutingKeys: null,
     // Similarly, we don't yet know if the route supports PPR.
     supportsPerSegmentPrefetching: false,
     hasDynamicRewrite: false,
@@ -849,6 +854,7 @@ export function deprecated_requestOptimisticRouteCacheEntry(
     tree: optimisticRouteTree,
     metadata: optimisticMetadataTree,
     couldBeIntercepted: routeWithNoSearchParams.couldBeIntercepted,
+    actionRoutingKeys: routeWithNoSearchParams.actionRoutingKeys,
     supportsPerSegmentPrefetching:
       routeWithNoSearchParams.supportsPerSegmentPrefetching,
     hasDynamicRewrite: routeWithNoSearchParams.hasDynamicRewrite,
@@ -2176,7 +2182,10 @@ export async function fetchRouteOnCacheMiss(
       const serverData = await createFromNextReadableStream<RootTreePrefetch>(
         prefetchStream,
         headers,
-        { allowPartialStream: true }
+        {
+          allowPartialStream: true,
+          actionDispatchContext: { url: canonicalUrl, nextUrl },
+        }
       )
 
       if (
@@ -2214,6 +2223,7 @@ export async function fetchRouteOnCacheMiss(
         return null
       }
 
+      entry.actionRoutingKeys = serverData.actionRoutingKeys ?? null
       discoverKnownRoute(
         Date.now(),
         pathname,
@@ -2241,7 +2251,10 @@ export async function fetchRouteOnCacheMiss(
         await createFromNextReadableStream<NavigationFlightResponse>(
           prefetchStream,
           headers,
-          { allowPartialStream: true }
+          {
+            allowPartialStream: true,
+            actionDispatchContext: { url: canonicalUrl, nextUrl },
+          }
         )
 
       if (
@@ -2540,7 +2553,14 @@ async function fetchSegmentsOnCacheMissImpl(
     await createFromNextReadableStream<SegmentPrefetchResponse>(
       prefetchStream,
       headers,
-      { allowPartialStream: true }
+      {
+        allowPartialStream: true,
+        actionDispatchContext: {
+          url: route.canonicalUrl,
+          nextUrl,
+          actionRoutingKeys: route.actionRoutingKeys,
+        },
+      }
     )
 
   if (serverResponse.data.length === 0) {
@@ -2583,7 +2603,12 @@ async function fetchSegmentsOnCacheMissImpl(
     try {
       shellResponse = await decodeBufferedStage<SegmentPrefetchResponse>(
         buffer.subarray(0, shellOffset),
-        headers
+        headers,
+        {
+          url: route.canonicalUrl,
+          nextUrl,
+          actionRoutingKeys: route.actionRoutingKeys,
+        }
       )
     } catch {
       // The truncated prefix couldn't be decoded. Treat it as if no shell
@@ -3237,7 +3262,10 @@ export async function fetchSegmentPrefetchesUsingDynamicRequest(
       createFromNextReadableStream<NavigationFlightResponse>(
         prefetchStream,
         headers,
-        { allowPartialStream: true }
+        {
+          allowPartialStream: true,
+          actionDispatchContext: { url: route.canonicalUrl, nextUrl },
+        }
       ),
       response.cacheData,
     ])
@@ -3263,7 +3291,12 @@ export async function fetchSegmentPrefetchesUsingDynamicRequest(
       const shellStageData = await resolveShellStageData(
         cacheData,
         serverData,
-        headers
+        headers,
+        {
+          url: route.canonicalUrl,
+          nextUrl,
+          actionRoutingKeys: serverData.A,
+        }
       )
       if (shellStageData === null) {
         // No App Shell can be extracted. This usually means the entire response
@@ -3482,6 +3515,7 @@ function writeDynamicTreeResponseIntoCache(
     return
   }
 
+  entry.actionRoutingKeys = serverData.A ?? null
   discoverKnownRoute(
     now,
     originalPathname,
@@ -4194,7 +4228,8 @@ export async function processRuntimePrefetchStream(
   now: number,
   runtimePrefetchStream: ReadableStream<Uint8Array>,
   baseTree: FlightRouterState,
-  renderedSearch: string
+  renderedSearch: string,
+  actionDispatchContext: FlightDecoderActionDispatchContext
 ): Promise<{
   navigationSeed: NavigationSeed
   buildId: string | undefined
@@ -4209,7 +4244,7 @@ export async function processRuntimePrefetchStream(
     await createFromNextReadableStream<NavigationFlightResponse>(
       stream,
       undefined,
-      { allowPartialStream: true }
+      { allowPartialStream: true, actionDispatchContext }
     )
 
   const rootVaryParamsIterable = serverData.r ?? null
diff --git a/packages/next/src/client/components/segment-cache/navigation.ts b/packages/next/src/client/components/segment-cache/navigation.ts
index 62906f0a0257..74bcff9003cf 100644
--- a/packages/next/src/client/components/segment-cache/navigation.ts
+++ b/packages/next/src/client/components/segment-cache/navigation.ts
@@ -40,6 +40,7 @@ import {
   convertServerPatchToFullTree,
   type NavigationSeed,
 } from './decode-server-response'
+import { registerServerActionDispatchContext } from '../../server-action-dispatch'
 
 /**
  * Navigate to a new URL, using the Segment Cache to construct a response.
@@ -389,6 +390,11 @@ function navigateUsingPrefetchedRouteTree(
   const routeTree = route.tree
   const canonicalUrl = route.canonicalUrl + url.hash
   const renderedSearch = route.renderedSearch
+  registerServerActionDispatchContext(
+    route.actionRoutingKeys ?? undefined,
+    canonicalUrl,
+    nextUrl
+  )
   const prefetchSeed: NavigationSeed = {
     renderedSearch,
     routeTree,
@@ -493,6 +499,7 @@ async function navigateToUnknownRoute(
     renderedSearch,
     couldBeIntercepted,
     supportsPerSegmentPrefetching,
+    actionRoutingKeys,
     dynamicStaleTime,
     staticStageData,
     runtimePrefetchStream,
@@ -500,6 +507,12 @@ async function navigateToUnknownRoute(
     debugInfo,
   } = result
 
+  registerServerActionDispatchContext(
+    actionRoutingKeys ?? undefined,
+    canonicalUrl,
+    nextUrl
+  )
+
   // Since the response format of dynamic requests and prefetches is slightly
   // different, we'll need to massage the data a bit. Create FlightRouterState
   // tree that simulates what we'd receive as the result of a prefetch.
@@ -518,7 +531,7 @@ async function navigateToUnknownRoute(
   // retrying after a tree mismatch (see dispatchRetryDueToTreeMismatch).
   const metadataVaryPath = navigationSeed.metadataVaryPath
   if (metadataVaryPath !== null) {
-    discoverKnownRoute(
+    const fulfilledRoute = discoverKnownRoute(
       now,
       url.pathname,
       url.search as NormalizedSearch,
@@ -533,6 +546,7 @@ async function navigateToUnknownRoute(
       supportsPerSegmentPrefetching,
       false // hasDynamicRewrite - not a retry, rewrite detection happens during traversal
     )
+    fulfilledRoute.actionRoutingKeys = actionRoutingKeys
 
     if (staticStageData !== null) {
       const { response: staticStageResponse, isResponsePartial } =
@@ -573,7 +587,12 @@ async function navigateToUnknownRoute(
         now,
         runtimePrefetchStream,
         currentFlightRouterState,
-        renderedSearch
+        renderedSearch,
+        {
+          url: canonicalUrl,
+          nextUrl,
+          actionRoutingKeys,
+        }
       )
         .then((processed) => {
           if (processed !== null) {
diff --git a/packages/next/src/client/components/segment-cache/optimistic-routes.ts b/packages/next/src/client/components/segment-cache/optimistic-routes.ts
index 87b2af934f60..f927e98c9b91 100644
--- a/packages/next/src/client/components/segment-cache/optimistic-routes.ts
+++ b/packages/next/src/client/components/segment-cache/optimistic-routes.ts
@@ -685,6 +685,7 @@ export function matchKnownRoute(
     tree: reifiedTree,
     metadata: reifiedMetadata,
     couldBeIntercepted: pattern.couldBeIntercepted,
+    actionRoutingKeys: pattern.actionRoutingKeys,
     supportsPerSegmentPrefetching: pattern.supportsPerSegmentPrefetching,
     hasDynamicRewrite: false,
     renderedSearch: search,
diff --git a/packages/next/src/client/flight-data-helpers.ts b/packages/next/src/client/flight-data-helpers.ts
index e1c32f2dfb15..93d88f33ee7a 100644
--- a/packages/next/src/client/flight-data-helpers.ts
+++ b/packages/next/src/client/flight-data-helpers.ts
@@ -65,6 +65,7 @@ export function createInitialRSCPayloadFromFallbackPrerender(
     m: fallbackInitialRSCPayload.m,
     G: fallbackInitialRSCPayload.G,
     S: fallbackInitialRSCPayload.S,
+    A: fallbackInitialRSCPayload.A,
   }
   if (fallbackInitialRSCPayload.b) {
     payload.b = fallbackInitialRSCPayload.b
diff --git a/packages/next/src/client/server-action-dispatch.ts b/packages/next/src/client/server-action-dispatch.ts
new file mode 100644
index 000000000000..8f0b2bf1d67b
--- /dev/null
+++ b/packages/next/src/client/server-action-dispatch.ts
@@ -0,0 +1,88 @@
+'use client'
+
+import { createServerActionRoutingKey } from '../shared/lib/server-action-routing-key'
+
+export type ServerActionDispatchContext = {
+  url: string
+  nextUrl: string | null
+}
+
+/**
+ * React retains the `callServer` callback from a Flight decoder on every
+ * Server Reference created by that decoder. This scope lets the callback
+ * prefer the URL that produced the reference, but only when that response
+ * advertised ownership of the action. References to actions owned by another
+ * worker still fall back to the global routing map.
+ *
+ * Keep the routing keys as their original array. Segment decoders create many
+ * short-lived scopes for the same route, so copying the keys into a Set would
+ * multiply memory usage by the number of decoded segments.
+ */
+export type ServerActionDispatchScope = {
+  context: ServerActionDispatchContext
+  routingKeys: readonly string[]
+}
+
+const dispatchContextByRoutingKey = new Map<
+  string,
+  ServerActionDispatchContext
+>()
+
+function normalizeDispatchUrl(url: string | URL): string {
+  const parsed = new URL(url, window.location.origin)
+  return parsed.pathname + parsed.search
+}
+
+export function createServerActionDispatchScope(
+  url: string | URL,
+  nextUrl: string | null,
+  routingKeys?: readonly string[] | null
+): ServerActionDispatchScope {
+  return {
+    context: { url: normalizeDispatchUrl(url), nextUrl },
+    routingKeys: routingKeys ?? [],
+  }
+}
+
+export function setServerActionDispatchScopeContext(
+  scope: ServerActionDispatchScope,
+  url: string | URL,
+  nextUrl: string | null
+): void {
+  scope.context = { url: normalizeDispatchUrl(url), nextUrl }
+}
+
+export function setServerActionDispatchScopeRoutingKeys(
+  scope: ServerActionDispatchScope,
+  routingKeys: readonly string[] | undefined
+): void {
+  scope.routingKeys = routingKeys ?? []
+}
+
+export function registerServerActionDispatchContext(
+  actionRoutingKeys: readonly string[] | undefined,
+  url: string | URL,
+  nextUrl: string | null
+): void {
+  if (actionRoutingKeys === undefined || actionRoutingKeys.length === 0) {
+    return
+  }
+
+  const normalizedUrl = normalizeDispatchUrl(url)
+  const context = { url: normalizedUrl, nextUrl }
+
+  for (const routingKey of actionRoutingKeys) {
+    dispatchContextByRoutingKey.set(routingKey, context)
+  }
+}
+
+export function getServerActionDispatchContext(
+  actionId: string,
+  scope?: ServerActionDispatchScope
+): ServerActionDispatchContext | undefined {
+  const routingKey = createServerActionRoutingKey(actionId)
+  if (scope?.routingKeys.includes(routingKey)) {
+    return scope.context
+  }
+  return dispatchContextByRoutingKey.get(routingKey)
+}
diff --git a/packages/next/src/server/app-render/action-handler.test.ts b/packages/next/src/server/app-render/action-handler.test.ts
index 71b241ab0306..c69deaca9d0c 100644
--- a/packages/next/src/server/app-render/action-handler.test.ts
+++ b/packages/next/src/server/app-render/action-handler.test.ts
@@ -1,9 +1,11 @@
 import { parseHostHeader } from './action-handler'
 import {
+  getServerActionRoutingKeysForPage,
   getServerModuleMap,
   setManifestsSingleton,
 } from './manifests-singleton'
 import type { ClientReferenceManifest } from '../../build/webpack/plugins/flight-manifest-plugin'
+import { createServerActionRoutingKey } from '../../shared/lib/server-action-routing-key'
 
 describe('server module map', () => {
   const actionId = '00' + 'a'.repeat(40)
@@ -39,6 +41,15 @@ describe('server module map', () => {
     })
   })
 
+  it('lists opaque routing keys for the actions owned by a route', () => {
+    const routingKeys = getServerActionRoutingKeysForPage('/test/page')
+
+    expect(routingKeys).toEqual([createServerActionRoutingKey(actionId)])
+    expect(
+      getServerActionRoutingKeysForPage('/test/without-actions')
+    ).toBeUndefined()
+  })
+
   it('rejects plausible server reference IDs that are missing', () => {
     expect(() => getServerModuleMap()[missingActionId]).toThrow(
       `Failed to find Server Action "${missingActionId}".`
diff --git a/packages/next/src/server/app-render/action-handler.ts b/packages/next/src/server/app-render/action-handler.ts
index 1156f88da65e..95c0cae4f84d 100644
--- a/packages/next/src/server/app-render/action-handler.ts
+++ b/packages/next/src/server/app-render/action-handler.ts
@@ -755,6 +755,12 @@ export async function handleAction({
   )
 
   const actionWasForwarded = Boolean(req.headers['x-action-forwarded'])
+  // A fetch action without a router state tree cannot produce a Flight patch
+  // for the currently rendered page. This occurs when the client dispatches an
+  // action directly to a different route, so only execute the action without
+  // rendering the destination route's page tree.
+  const isActionOnlyRequest =
+    isFetchAction && req.headers[NEXT_ROUTER_STATE_TREE_HEADER] === undefined
   // A fetch action targeting a fallback route has no concrete params with
   // which to resume the destination page.
   const isActionOnlyFallbackRequest =
@@ -762,7 +768,7 @@ export async function handleAction({
     requestStore.fallbackParams != null &&
     typeof ctx.renderOpts.postponed === 'string'
   const shouldSkipPageRendering =
-    actionWasForwarded || isActionOnlyFallbackRequest
+    actionWasForwarded || isActionOnlyRequest || isActionOnlyFallbackRequest
 
   // Only attempt to forward if this request has not already been forwarded.
   // Otherwise middleware that rewrites the action POST can cause the receiving
diff --git a/packages/next/src/server/app-render/app-render.tsx b/packages/next/src/server/app-render/app-render.tsx
index 59f37a8722bb..69a55a57bc21 100644
--- a/packages/next/src/server/app-render/app-render.tsx
+++ b/packages/next/src/server/app-render/app-render.tsx
@@ -154,6 +154,7 @@ import { createFullComponentTree, getRootParams } from './create-component-tree'
 import { getAssetQueryString } from './get-asset-query-string'
 import {
   getClientReferenceManifest,
+  getServerActionRoutingKeysForPage,
   getServerModuleMap,
 } from './manifests-singleton'
 import {
@@ -825,6 +826,7 @@ async function generateDynamicRSCPayload(
       // static pages do, because their per-segment prefetch responses are
       // generated during static generation (build or ISR).
       S: ctx.renderCapabilities.supportsPerSegmentPrefetching,
+      A: getServerActionRoutingKeysForPage(ctx.workStore.page),
       r: getRootParamsVaryParamsAccumulator() ?? undefined,
     }
   )
@@ -2252,6 +2254,7 @@ async function getRSCPayload(
     // static pages do, because their per-segment prefetch responses are
     // generated during static generation (build or ISR).
     S: ctx.renderCapabilities.supportsPerSegmentPrefetching,
+    A: getServerActionRoutingKeysForPage(ctx.workStore.page),
     r: getRootParamsVaryParamsAccumulator() ?? undefined,
     s: staleTimeIterable,
     a: shellByteLengthPromise,
diff --git a/packages/next/src/server/app-render/collect-segment-data.tsx b/packages/next/src/server/app-render/collect-segment-data.tsx
index 2616ae2cd11a..948ad972133c 100644
--- a/packages/next/src/server/app-render/collect-segment-data.tsx
+++ b/packages/next/src/server/app-render/collect-segment-data.tsx
@@ -49,6 +49,7 @@ export type RootTreePrefetch = {
   buildId?: string
   tree: TreePrefetch
   staleTime: number
+  actionRoutingKeys?: readonly string[]
 }
 
 export type TreePrefetchParam = {
@@ -1013,6 +1014,7 @@ async function PrefetchTreeData({
   const treePrefetch: RootTreePrefetch = {
     tree,
     staleTime,
+    actionRoutingKeys: initialRSCPayload.A,
   }
   if (buildId) {
     treePrefetch.buildId = buildId
diff --git a/packages/next/src/server/app-render/manifests-singleton.ts b/packages/next/src/server/app-render/manifests-singleton.ts
index e91ace8c6432..e79eaef5e4f1 100644
--- a/packages/next/src/server/app-render/manifests-singleton.ts
+++ b/packages/next/src/server/app-render/manifests-singleton.ts
@@ -7,6 +7,7 @@ import { pathHasPrefix } from '../../shared/lib/router/utils/path-has-prefix'
 import { removePathPrefix } from '../../shared/lib/router/utils/remove-path-prefix'
 import { mightBeServerReferenceId } from '../../shared/lib/server-reference-info'
 import { wellKnownProperties } from '../../shared/lib/utils/reflect-utils'
+import { createServerActionRoutingKey } from '../../shared/lib/server-action-routing-key'
 import { workAsyncStorage } from './work-async-storage.external'
 
 export interface ServerModuleMap {
@@ -73,6 +74,7 @@ interface ManifestsSingleton {
   readonly proxiedClientReferenceManifest: DeepReadonly<ClientReferenceManifest>
   serverActionsManifest: DeepReadonly<ActionManifest>
   serverModuleMap: ServerModuleMap
+  serverActionRoutingKeysPerPage: Map<string, readonly string[] | undefined>
 }
 
 type GlobalThisWithManifests = typeof globalThis & {
@@ -335,6 +337,36 @@ export function selectWorkerForForwarding(
   return denormalizeWorkerPageName(Object.keys(workers)[0])
 }
 
+export function getServerActionRoutingKeysForPage(
+  pageName: string
+): readonly string[] | undefined {
+  const singleton = getManifestsSingleton()
+  const runtime = process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node'
+  const workerPageName = normalizeWorkerPageName(pageName)
+  const cacheKey = `${runtime}:${workerPageName}`
+  const cachedRoutingKeys =
+    singleton.serverActionRoutingKeysPerPage.get(cacheKey)
+
+  if (singleton.serverActionRoutingKeysPerPage.has(cacheKey)) {
+    return cachedRoutingKeys
+  }
+
+  const actionIds: string[] = []
+  const actions = singleton.serverActionsManifest[runtime]
+  for (const actionId in actions) {
+    if (actions[actionId].workers[workerPageName] !== undefined) {
+      actionIds.push(actionId)
+    }
+  }
+
+  const routingKeys =
+    actionIds.length === 0
+      ? undefined
+      : actionIds.map(createServerActionRoutingKey)
+  singleton.serverActionRoutingKeysPerPage.set(cacheKey, routingKeys)
+  return routingKeys
+}
+
 export function setManifestsSingleton({
   page,
   clientReferenceManifest,
@@ -362,6 +394,7 @@ export function setManifestsSingleton({
     })
 
     existingSingleton.serverActionsManifest = serverActionsManifest
+    existingSingleton.serverActionRoutingKeysPerPage.clear()
   } else {
     const clientReferenceManifestsPerRoute = new Map<
       string,
@@ -377,6 +410,7 @@ export function setManifestsSingleton({
       proxiedClientReferenceManifest,
       serverActionsManifest,
       serverModuleMap: createServerModuleMap(),
+      serverActionRoutingKeysPerPage: new Map(),
     }
   }
 }
diff --git a/packages/next/src/shared/lib/app-router-types.ts b/packages/next/src/shared/lib/app-router-types.ts
index e126c44a76b3..7b0a204b6b8b 100644
--- a/packages/next/src/shared/lib/app-router-types.ts
+++ b/packages/next/src/shared/lib/app-router-types.ts
@@ -408,6 +408,8 @@ export type InitialRSCPayload = {
   G: [React.ComponentType<any>, React.ReactNode | undefined]
   /** supportsPerSegmentPrefetching */
   S: boolean
+  /** Opaque routing keys for Server Actions owned by this route. */
+  A?: readonly string[]
   /**
    * rootVaryParams - the root params accessed anywhere in the response, emitted
    * once. The client unions these into the head and every segment's vary
@@ -486,6 +488,8 @@ export type NavigationFlightResponse = {
   n?: string
   /** supportsPerSegmentPrefetching */
   S: boolean
+  /** Opaque routing keys for Server Actions owned by this route. */
+  A?: readonly string[]
   /** renderedSearch */
   q: string
   /** couldBeIntercepted */
@@ -557,6 +561,8 @@ export type ActionFlightResponse = {
   q: string
   /** couldBeIntercepted */
   i: boolean
+  /** Opaque routing keys, present when the response contains a redirect target. */
+  A?: readonly string[]
 }
 
 export type RSCPayload =
diff --git a/packages/next/src/shared/lib/server-action-routing-key.ts b/packages/next/src/shared/lib/server-action-routing-key.ts
new file mode 100644
index 000000000000..a9f10657ef3e
--- /dev/null
+++ b/packages/next/src/shared/lib/server-action-routing-key.ts
@@ -0,0 +1,11 @@
+import fnv1a from './fnv1a'
+
+/**
+ * Creates an opaque routing key for a Server Action without serializing its
+ * full action ID in the route payload. The key only associates an action
+ * reference the client already possesses with a route that can execute it. It
+ * is not a security boundary; the server still validates the full action ID.
+ */
+export function createServerActionRoutingKey(actionId: string): string {
+  return fnv1a(actionId, { size: 128 }).toString(36)
+}
diff --git a/test/e2e/app-dir/actions/app-action.test.ts b/test/e2e/app-dir/actions/app-action.test.ts
index 33fd78e13d73..6f9ca941a413 100644
--- a/test/e2e/app-dir/actions/app-action.test.ts
+++ b/test/e2e/app-dir/actions/app-action.test.ts
@@ -94,6 +94,14 @@ describe('app-dir action handling', () => {
 
   it('should handle basic actions correctly', async () => {
     const browser = await next.browser('/server')
+    let actionRequestHeaders: Record<string, string> | undefined
+
+    browser.on('request', (request) => {
+      const headers = request.headers()
+      if (request.method() === 'POST' && headers['next-action'] !== undefined) {
+        actionRequestHeaders = headers
+      }
+    })
 
     const cnt = await browser.elementById('count').text()
     expect(cnt).toBe('0')
@@ -116,6 +124,79 @@ describe('app-dir action handling', () => {
     await retry(async () => {
       expect(await browser.elementById('count').text()).toBe('3')
     })
+
+    expect(actionRequestHeaders?.['next-action-only']).toBeUndefined()
+    expect(actionRequestHeaders?.['next-router-state-tree']).toBeDefined()
+  })
+
+  it('should invoke an action against the current search params', async () => {
+    const browser = await next.browser('/server')
+    let actionRequestUrl: string | undefined
+
+    browser.on('request', (request) => {
+      const headers = request.headers()
+      if (request.method() === 'POST' && headers['next-action'] !== undefined) {
+        actionRequestUrl = request.url()
+      }
+    })
+
+    await browser.eval(() => {
+      window.history.pushState(null, '', '/server?invocation=1')
+    })
+    await retry(async () => {
+      expect(await browser.elementById('search-params').text()).toBe(
+        'invocation=1'
+      )
+    })
+
+    await browser.elementById('inc').click()
+    await retry(async () => {
+      expect(await browser.elementById('count').text()).toBe('1')
+    })
+
+    if (actionRequestUrl === undefined) {
+      throw new Error('Failed to capture Server Action request')
+    }
+    expect(new URL(actionRequestUrl).search).toBe('?invocation=1')
+  })
+
+  it('should preserve the URL of an action in a retained parallel route', async () => {
+    const browser = await next.browser('/parallel-action/one')
+    const actionRequestPaths: string[] = []
+
+    browser.on('request', (request) => {
+      const headers = request.headers()
+      if (request.method() === 'POST' && headers['next-action'] !== undefined) {
+        actionRequestPaths.push(new URL(request.url()).pathname)
+      }
+    })
+
+    await browser.elementByCss("[href='/parallel-action/two']").click()
+    await retry(async () => {
+      expect(new URL(await browser.url()).pathname).toBe('/parallel-action/two')
+      expect(await browser.hasElementByCssSelector('#retained-action')).toBe(
+        true
+      )
+    })
+
+    await browser.elementById('retained-action').click()
+    await retry(async () => {
+      expect(await browser.elementById('retained-action-result').text()).toBe(
+        'action invoked'
+      )
+    })
+
+    await browser.elementById('current-action').click()
+    await retry(async () => {
+      expect(await browser.elementById('current-action-result').text()).toBe(
+        'action invoked'
+      )
+    })
+
+    expect(actionRequestPaths).toEqual([
+      '/parallel-action/one',
+      '/parallel-action/two',
+    ])
   })
 
   it('should report errors with bad inputs correctly', async () => {
@@ -901,10 +982,23 @@ describe('app-dir action handling', () => {
   }
 
   it.each(['node', 'edge'])(
-    'should forward action request to a worker that contains the action handler (%s)',
+    'should dispatch a delayed action to the route that owns it (%s)',
     async (runtime) => {
       const cliOutputIndex = next.cliOutput.length
       const browser = await next.browser(`/delayed-action/${runtime}`)
+      const actionRequestPaths: string[] = []
+      let actionRequestHeaders: Record<string, string> | undefined
+
+      browser.on('request', (request) => {
+        const headers = request.headers()
+        if (
+          request.method() === 'POST' &&
+          headers['next-action'] !== undefined
+        ) {
+          actionRequestPaths.push(new URL(request.url()).pathname)
+          actionRequestHeaders = headers
+        }
+      })
 
       // confirm there's no data yet
       expect(await browser.elementById('delayed-action-result').text()).toBe(
@@ -933,6 +1027,10 @@ describe('app-dir action handling', () => {
       // make sure that we still are rendering other-page content
       expect(await browser.hasElementByCssSelector('#other-page')).toBe(true)
 
+      expect(actionRequestPaths).toEqual([`/delayed-action/${runtime}`])
+      expect(actionRequestHeaders?.['next-action-only']).toBeUndefined()
+      expect(actionRequestHeaders?.['next-router-state-tree']).toBeUndefined()
+
       // make sure we didn't get any errors in the console
       expect(next.cliOutput.slice(cliOutputIndex)).not.toContain(
         'Failed to find Server Action'
@@ -941,11 +1039,21 @@ describe('app-dir action handling', () => {
   )
 
   it.each(['node', 'edge'])(
-    'should not error when a forwarded action triggers a redirect (%s)',
+    'should dispatch a delayed redirect action to the route that owns it (%s)',
     async (runtime) => {
       let redirectResponseCode
+      const actionRequestPaths: string[] = []
       const browser = await next.browser(`/delayed-action/${runtime}`, {
         beforePageLoad(page) {
+          page.on('request', (request) => {
+            if (
+              request.method() === 'POST' &&
+              request.headers()['next-action'] !== undefined
+            ) {
+              actionRequestPaths.push(new URL(request.url()).pathname)
+            }
+          })
+
           page.on('response', async (res) => {
             const headers = await res.allHeaders().catch(() => ({}))
             if (headers['x-action-redirect']) {
@@ -969,6 +1077,8 @@ describe('app-dir action handling', () => {
         expect(redirectResponseCode).toBe(200)
       })
 
+      expect(actionRequestPaths).toEqual([`/delayed-action/${runtime}`])
+
       // confirm that the redirect was handled
       await browser.waitForElementByCss('#run-action-redirect')
     }
diff --git a/test/e2e/app-dir/actions/app/parallel-action/@slot/default.tsx b/test/e2e/app-dir/actions/app/parallel-action/@slot/default.tsx
new file mode 100644
index 000000000000..86b9e9a38812
--- /dev/null
+++ b/test/e2e/app-dir/actions/app/parallel-action/@slot/default.tsx
@@ -0,0 +1,3 @@
+export default function Default() {
+  return null
+}
diff --git a/test/e2e/app-dir/actions/app/parallel-action/@slot/one/page.tsx b/test/e2e/app-dir/actions/app/parallel-action/@slot/one/page.tsx
new file mode 100644
index 000000000000..68a4e6900be0
--- /dev/null
+++ b/test/e2e/app-dir/actions/app/parallel-action/@slot/one/page.tsx
@@ -0,0 +1,6 @@
+import { action } from '../../actions'
+import { ActionButton } from '../../button'
+
+export default function Page() {
+  return <ActionButton action={action} id="retained-action" />
+}
diff --git a/test/e2e/app-dir/actions/app/parallel-action/actions.ts b/test/e2e/app-dir/actions/app/parallel-action/actions.ts
new file mode 100644
index 000000000000..46645b5515ff
--- /dev/null
+++ b/test/e2e/app-dir/actions/app/parallel-action/actions.ts
@@ -0,0 +1,5 @@
+'use server'
+
+export async function action() {
+  return 'action invoked'
+}
diff --git a/test/e2e/app-dir/actions/app/parallel-action/button.tsx b/test/e2e/app-dir/actions/app/parallel-action/button.tsx
new file mode 100644
index 000000000000..1965d0ae0a2d
--- /dev/null
+++ b/test/e2e/app-dir/actions/app/parallel-action/button.tsx
@@ -0,0 +1,22 @@
+'use client'
+
+import { useState } from 'react'
+
+export function ActionButton({
+  action,
+  id,
+}: {
+  action: () => Promise<string>
+  id: string
+}) {
+  const [result, setResult] = useState('<null>')
+
+  return (
+    <>
+      <button id={id} onClick={async () => setResult(await action())}>
+        Invoke action
+      </button>
+      <p id={`${id}-result`}>{result}</p>
+    </>
+  )
+}
diff --git a/test/e2e/app-dir/actions/app/parallel-action/layout.tsx b/test/e2e/app-dir/actions/app/parallel-action/layout.tsx
new file mode 100644
index 000000000000..e05fc8bd1357
--- /dev/null
+++ b/test/e2e/app-dir/actions/app/parallel-action/layout.tsx
@@ -0,0 +1,14 @@
+export default function Layout({
+  children,
+  slot,
+}: {
+  children: React.ReactNode
+  slot: React.ReactNode
+}) {
+  return (
+    <>
+      {children}
+      {slot}
+    </>
+  )
+}
diff --git a/test/e2e/app-dir/actions/app/parallel-action/one/page.tsx b/test/e2e/app-dir/actions/app/parallel-action/one/page.tsx
new file mode 100644
index 000000000000..1fa9b9e43b49
--- /dev/null
+++ b/test/e2e/app-dir/actions/app/parallel-action/one/page.tsx
@@ -0,0 +1,5 @@
+import Link from 'next/link'
+
+export default function Page() {
+  return <Link href="/parallel-action/two">Navigate to two</Link>
+}
diff --git a/test/e2e/app-dir/actions/app/parallel-action/two/page.tsx b/test/e2e/app-dir/actions/app/parallel-action/two/page.tsx
new file mode 100644
index 000000000000..999cfe0a7ff4
--- /dev/null
+++ b/test/e2e/app-dir/actions/app/parallel-action/two/page.tsx
@@ -0,0 +1,6 @@
+import { action } from '../actions'
+import { ActionButton } from '../button'
+
+export default function Page() {
+  return <ActionButton action={action} id="current-action" />
+}
diff --git a/test/e2e/app-dir/actions/app/server/counter.js b/test/e2e/app-dir/actions/app/server/counter.js
index 7e12cf22063f..4fd3ece148d9 100644
--- a/test/e2e/app-dir/actions/app/server/counter.js
+++ b/test/e2e/app-dir/actions/app/server/counter.js
@@ -1,13 +1,16 @@
 'use client'
 
 import { useState } from 'react'
+import { useSearchParams } from 'next/navigation'
 
 export default function Counter({ inc, dec, double, slowInc }) {
   const [count, setCount] = useState(0)
+  const searchParams = useSearchParams()
 
   return (
     <div>
       <h1 id="count">{count}</h1>
+      <p id="search-params">{searchParams.toString()}</p>
       <button
         id="inc"
         onClick={async () => {
diff --git a/test/e2e/app-dir/actions/app/server/page.js b/test/e2e/app-dir/actions/app/server/page.js
index 7569f02453f6..5a487c999988 100644
--- a/test/e2e/app-dir/actions/app/server/page.js
+++ b/test/e2e/app-dir/actions/app/server/page.js
@@ -1,3 +1,4 @@
+import { Suspense } from 'react'
 import Counter from './counter'
 import Form from './form'
 import ClientForm from './client-form'
@@ -14,19 +15,21 @@ export default function Page() {
 
   return (
     <>
-      <Counter
-        inc={inc}
-        dec={dec}
-        slowInc={slowInc}
-        double={async (x) => {
-          'use server'
-          if (data === '你好') {
-            return x * two.value
-          }
-          // Wrong answer
-          return 42
-        }}
-      />
+      <Suspense>
+        <Counter
+          inc={inc}
+          dec={dec}
+          slowInc={slowInc}
+          double={async (x) => {
+            'use server'
+            if (data === '你好') {
+              return x * two.value
+            }
+            // Wrong answer
+            return 42
+          }}
+        />
+      </Suspense>
       <Form />
       <ClientForm />
       <form>