diff --git a/apps/sim/.env.example b/apps/sim/.env.example
index 95c5115cb2b..ca6012c7bb1 100644
--- a/apps/sim/.env.example
+++ b/apps/sim/.env.example
@@ -48,6 +48,8 @@ API_ENCRYPTION_KEY=your_api_encryption_key # Use `openssl rand -hex 32` to gener
 # OLLAMA_URL=http://localhost:11434  # URL for local Ollama server - uncomment if using local models
 # VLLM_BASE_URL=http://localhost:8000    # Base URL for your self-hosted vLLM (OpenAI-compatible)
 # VLLM_API_KEY=                          # Optional bearer token if your vLLM instance requires auth
+# LITELLM_BASE_URL=http://localhost:4000 # Base URL for your LiteLLM proxy (OpenAI-compatible)
+# LITELLM_API_KEY=                       # Optional bearer token if your LiteLLM proxy requires auth
 # FIREWORKS_API_KEY=                     # Optional Fireworks AI API key for model listing
 # NEXT_PUBLIC_BEDROCK_DEFAULT_CREDENTIALS=true  # Set when using AWS default credential chain (IAM roles, ECS task roles, IRSA). Hides credential fields in Agent block UI.
 # AZURE_OPENAI_ENDPOINT=                        # Azure OpenAI endpoint (hides field in UI when set alongside NEXT_PUBLIC_AZURE_CONFIGURED)
@@ -60,6 +62,15 @@ API_ENCRYPTION_KEY=your_api_encryption_key # Use `openssl rand -hex 32` to gener
 # COHERE_API_KEY=                               # Cohere API key for the Knowledge block reranker (rerank-v4.0-pro/-fast, rerank-v3.5). Alternatively set COHERE_API_KEY_1/2/3 for rotation.
 # NEXT_PUBLIC_COHERE_CONFIGURED=true            # Set when COHERE_API_KEY (or rotation keys) are pre-configured above. Hides the Cohere API Key field on the Knowledge block UI.
 
+# Hosted tool API keys (Optional - lets Sim supply the key so users don't have to bring their own).
+# Each provider reads `{PREFIX}_COUNT` then `{PREFIX}_1..N`, distributing requests round-robin across the keys.
+# HUNTER_API_KEY_COUNT=2                         # Number of Hunter.io keys for hosted Hunter blocks
+# HUNTER_API_KEY_1=                              # Hunter.io API key #1
+# HUNTER_API_KEY_2=                              # Hunter.io API key #2
+# PEOPLEDATALABS_API_KEY_COUNT=2                 # Number of People Data Labs keys for hosted PDL blocks
+# PEOPLEDATALABS_API_KEY_1=                      # People Data Labs API key #1
+# PEOPLEDATALABS_API_KEY_2=                      # People Data Labs API key #2
+
 # Admin API (Optional - for self-hosted GitOps)
 # ADMIN_API_KEY=  # Use `openssl rand -hex 32` to generate. Enables admin API for workflow export/import.
                   # Usage: curl -H "x-admin-key: your_key" https://your-instance/api/v1/admin/workspaces
diff --git a/apps/sim/app/api/copilot/chat/queries.ts b/apps/sim/app/api/copilot/chat/queries.ts
index 41ff9ec4bbf..55d8f5acad0 100644
--- a/apps/sim/app/api/copilot/chat/queries.ts
+++ b/apps/sim/app/api/copilot/chat/queries.ts
@@ -12,13 +12,17 @@ import { normalizeMessage } from '@/lib/copilot/chat/persisted-message'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
+  createForbiddenResponse,
   createInternalServerErrorResponse,
   createUnauthorizedResponse,
 } from '@/lib/copilot/request/http'
 import { readFilePreviewSessions } from '@/lib/copilot/request/session'
 import { readEvents } from '@/lib/copilot/request/session/buffer'
 import { toStreamBatchEvent } from '@/lib/copilot/request/session/types'
-import { assertActiveWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+import {
+  assertActiveWorkspaceAccess,
+  isWorkspaceAccessDeniedError,
+} from '@/lib/workspaces/permissions/utils'
 
 const logger = createLogger('CopilotChatAPI')
 
@@ -196,6 +200,9 @@ export async function GET(req: NextRequest) {
       chats: chats.map(transformChatListItem),
     })
   } catch (error) {
+    if (isWorkspaceAccessDeniedError(error)) {
+      return createForbiddenResponse('Workspace access denied')
+    }
     logger.error('Error fetching copilot chats:', error)
     return createInternalServerErrorResponse('Failed to fetch chats')
   }
diff --git a/apps/sim/app/api/copilot/chats/route.ts b/apps/sim/app/api/copilot/chats/route.ts
index 0aecdb462b9..05e4c7773db 100644
--- a/apps/sim/app/api/copilot/chats/route.ts
+++ b/apps/sim/app/api/copilot/chats/route.ts
@@ -10,12 +10,16 @@ import { resolveOrCreateChat } from '@/lib/copilot/chat/lifecycle'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
+  createForbiddenResponse,
   createInternalServerErrorResponse,
   createUnauthorizedResponse,
 } from '@/lib/copilot/request/http'
 import { taskPubSub } from '@/lib/copilot/tasks'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
-import { assertActiveWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+import {
+  assertActiveWorkspaceAccess,
+  isWorkspaceAccessDeniedError,
+} from '@/lib/workspaces/permissions/utils'
 
 const logger = createLogger('CopilotChatsListAPI')
 
@@ -138,6 +142,9 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
 
     return NextResponse.json({ success: true, id: result.chatId })
   } catch (error) {
+    if (isWorkspaceAccessDeniedError(error)) {
+      return createForbiddenResponse('Workspace access denied')
+    }
     logger.error('Error creating workflow copilot chat:', error)
     return createInternalServerErrorResponse('Failed to create chat')
   }
diff --git a/apps/sim/app/api/function/execute/route.ts b/apps/sim/app/api/function/execute/route.ts
index 5fa058736d2..92dbaa87ef2 100644
--- a/apps/sim/app/api/function/execute/route.ts
+++ b/apps/sim/app/api/function/execute/route.ts
@@ -1132,7 +1132,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
             output: { result: null, stdout: cleanStdout(shellStdout), executionTime },
           },
           routeContext,
-          { status: 500 }
+          { status: 422 }
         )
       }
 
@@ -1269,7 +1269,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
               output: { result: null, stdout: cleanedOutput, executionTime },
             },
             routeContext,
-            { status: 500 }
+            { status: 422 }
           )
         }
 
@@ -1356,7 +1356,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
             output: { result: null, stdout: cleanedOutput, executionTime },
           },
           routeContext,
-          { status: 500 }
+          { status: 422 }
         )
       }
 
diff --git a/apps/sim/app/api/mothership/chats/[chatId]/fork/route.ts b/apps/sim/app/api/mothership/chats/[chatId]/fork/route.ts
index 8cea0668228..1509f68eb55 100644
--- a/apps/sim/app/api/mothership/chats/[chatId]/fork/route.ts
+++ b/apps/sim/app/api/mothership/chats/[chatId]/fork/route.ts
@@ -11,6 +11,7 @@ import { fetchGo } from '@/lib/copilot/request/go/fetch'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
+  createForbiddenResponse,
   createInternalServerErrorResponse,
   createNotFoundResponse,
   createUnauthorizedResponse,
@@ -21,7 +22,10 @@ import { taskPubSub } from '@/lib/copilot/tasks'
 import { env } from '@/lib/core/config/env'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { captureServerEvent } from '@/lib/posthog/server'
-import { assertActiveWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+import {
+  assertActiveWorkspaceAccess,
+  isWorkspaceAccessDeniedError,
+} from '@/lib/workspaces/permissions/utils'
 
 const logger = createLogger('ForkChatAPI')
 
@@ -150,6 +154,9 @@ export const POST = withRouteHandler(
 
       return NextResponse.json({ success: true, id: newId })
     } catch (error) {
+      if (isWorkspaceAccessDeniedError(error)) {
+        return createForbiddenResponse('Workspace access denied')
+      }
       logger.error('Error forking chat:', error)
       return createInternalServerErrorResponse('Failed to fork chat')
     }
diff --git a/apps/sim/app/api/mothership/chats/route.ts b/apps/sim/app/api/mothership/chats/route.ts
index f6d2d9eae35..1b7157fdde5 100644
--- a/apps/sim/app/api/mothership/chats/route.ts
+++ b/apps/sim/app/api/mothership/chats/route.ts
@@ -11,13 +11,17 @@ import { parseRequest } from '@/lib/api/server'
 import { reconcileChatStreamMarkers } from '@/lib/copilot/chat/stream-liveness'
 import {
   authenticateCopilotRequestSessionOnly,
+  createForbiddenResponse,
   createInternalServerErrorResponse,
   createUnauthorizedResponse,
 } from '@/lib/copilot/request/http'
 import { taskPubSub } from '@/lib/copilot/tasks'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { captureServerEvent } from '@/lib/posthog/server'
-import { assertActiveWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+import {
+  assertActiveWorkspaceAccess,
+  isWorkspaceAccessDeniedError,
+} from '@/lib/workspaces/permissions/utils'
 
 const logger = createLogger('MothershipChatsAPI')
 
@@ -68,6 +72,9 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
 
     return NextResponse.json({ success: true, data: reconciled })
   } catch (error) {
+    if (isWorkspaceAccessDeniedError(error)) {
+      return createForbiddenResponse('Workspace access denied')
+    }
     logger.error('Error fetching mothership chats:', error)
     return createInternalServerErrorResponse('Failed to fetch chats')
   }
@@ -118,6 +125,9 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
 
     return NextResponse.json({ success: true, id: chat.id })
   } catch (error) {
+    if (isWorkspaceAccessDeniedError(error)) {
+      return createForbiddenResponse('Workspace access denied')
+    }
     logger.error('Error creating mothership chat:', error)
     return createInternalServerErrorResponse('Failed to create chat')
   }
diff --git a/apps/sim/app/api/mothership/execute/route.ts b/apps/sim/app/api/mothership/execute/route.ts
index ab53f413baf..a3550718b92 100644
--- a/apps/sim/app/api/mothership/execute/route.ts
+++ b/apps/sim/app/api/mothership/execute/route.ts
@@ -19,6 +19,7 @@ import { buildMothershipToolsForRequest } from '@/lib/mothership/settings/runtim
 import {
   assertActiveWorkspaceAccess,
   getUserEntityPermissions,
+  isWorkspaceAccessDeniedError,
 } from '@/lib/workspaces/permissions/utils'
 
 export const maxDuration = 3600
@@ -378,6 +379,10 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
       return NextResponse.json({ error: 'Mothership execution aborted' }, { status: 499 })
     }
 
+    if (isWorkspaceAccessDeniedError(error)) {
+      return NextResponse.json({ error: 'Workspace access denied' }, { status: 403 })
+    }
+
     logger.error(
       messageId ? `Mothership execute error [messageId:${messageId}]` : 'Mothership execute error',
       {
diff --git a/apps/sim/app/api/providers/litellm/models/route.ts b/apps/sim/app/api/providers/litellm/models/route.ts
new file mode 100644
index 00000000000..bf40b54c424
--- /dev/null
+++ b/apps/sim/app/api/providers/litellm/models/route.ts
@@ -0,0 +1,70 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import { type NextRequest, NextResponse } from 'next/server'
+import {
+  providerModelsResponseSchema,
+  vllmUpstreamResponseSchema,
+} from '@/lib/api/contracts/providers'
+import { env } from '@/lib/core/config/env'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { filterBlacklistedModels, isProviderBlacklisted } from '@/providers/utils'
+
+const logger = createLogger('LiteLLMModelsAPI')
+
+export const GET = withRouteHandler(async (_request: NextRequest) => {
+  if (isProviderBlacklisted('litellm')) {
+    logger.info('LiteLLM provider is blacklisted, returning empty models')
+    return NextResponse.json({ models: [] })
+  }
+
+  const baseUrl = (env.LITELLM_BASE_URL || '').replace(/\/$/, '')
+
+  if (!baseUrl) {
+    logger.info('LITELLM_BASE_URL not configured')
+    return NextResponse.json({ models: [] })
+  }
+
+  try {
+    logger.info('Fetching LiteLLM models', { baseUrl })
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    }
+
+    if (env.LITELLM_API_KEY) {
+      headers.Authorization = `Bearer ${env.LITELLM_API_KEY}`
+    }
+
+    const response = await fetch(`${baseUrl}/v1/models`, {
+      headers,
+      next: { revalidate: 60 },
+    })
+
+    if (!response.ok) {
+      logger.warn('LiteLLM service is not available', {
+        status: response.status,
+        statusText: response.statusText,
+      })
+      return NextResponse.json({ models: [] })
+    }
+
+    const data = vllmUpstreamResponseSchema.parse(await response.json())
+    const allModels = data.data.map((model) => `litellm/${model.id}`)
+    const models = filterBlacklistedModels(allModels)
+
+    logger.info('Successfully fetched LiteLLM models', {
+      count: models.length,
+      filtered: allModels.length - models.length,
+      models,
+    })
+
+    return NextResponse.json(providerModelsResponseSchema.parse({ models }))
+  } catch (error) {
+    logger.error('Failed to fetch LiteLLM models', {
+      error: getErrorMessage(error, 'Unknown error'),
+      baseUrl,
+    })
+
+    return NextResponse.json({ models: [] })
+  }
+})
diff --git a/apps/sim/app/api/tools/file/manage/route.ts b/apps/sim/app/api/tools/file/manage/route.ts
index f95b4a9941d..61648a2a4d9 100644
--- a/apps/sim/app/api/tools/file/manage/route.ts
+++ b/apps/sim/app/api/tools/file/manage/route.ts
@@ -19,7 +19,10 @@ import {
 } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
 import { getFileExtension, getMimeTypeFromExtension } from '@/lib/uploads/utils/file-utils'
 import { performMoveWorkspaceFileItems } from '@/lib/workspace-files/orchestration'
-import { assertActiveWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+import {
+  assertActiveWorkspaceAccess,
+  isWorkspaceAccessDeniedError,
+} from '@/lib/workspaces/permissions/utils'
 
 export const dynamic = 'force-dynamic'
 
@@ -352,6 +355,12 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       }
     }
   } catch (error) {
+    if (isWorkspaceAccessDeniedError(error)) {
+      return NextResponse.json(
+        { success: false, error: 'Workspace access denied' },
+        { status: 403 }
+      )
+    }
     const message = getErrorMessage(error, 'Unknown error')
     logger.error('File operation failed', { operation: body.operation, error: message })
     return NextResponse.json({ success: false, error: message }, { status: 500 })
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel.tsx b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel.tsx
index 7af1ea24fdd..afb38a87842 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel.tsx
@@ -1071,16 +1071,24 @@ const HtmlPreview = memo(function HtmlPreview({ content }: { content: string })
 })
 
 function SvgPreview({ content }: { content: string }) {
-  const wrappedContent = `<!DOCTYPE html><html><head><style>body{margin:0;display:flex;align-items:center;justify-content:center;min-height:100vh;background:transparent;}svg{max-width:100%;max-height:100vh;}</style></head><body>${content}</body></html>`
+  const [blobUrl, setBlobUrl] = useState('')
+
+  useEffect(() => {
+    const url = URL.createObjectURL(new Blob([content], { type: 'image/svg+xml' }))
+    setBlobUrl(url)
+    return () => URL.revokeObjectURL(url)
+  }, [content])
 
   return (
     <ZoomablePreview className='h-full' contentClassName='h-full w-full'>
-      <iframe
-        srcDoc={wrappedContent}
-        sandbox=''
-        title='SVG Preview'
-        className='h-full w-full border-0'
-      />
+      {blobUrl && (
+        <img
+          src={blobUrl}
+          alt='SVG preview'
+          className='max-h-full max-w-full select-none object-contain'
+          draggable={false}
+        />
+      )}
     </ZoomablePreview>
   )
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-wheel-zoom.ts b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-wheel-zoom.ts
index 9d68f0b89bc..cdb44a2d86d 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-wheel-zoom.ts
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-wheel-zoom.ts
@@ -1,17 +1,39 @@
+interface BindPreviewWheelZoomOptions {
+  /**
+   * Called for non-modifier wheel events (two-finger scroll). When provided,
+   * the container's native scrolling is suppressed and the consumer drives
+   * pan via `deltaX` / `deltaY`. Use for transform-based viewers (e.g. image)
+   * where the content is not a real scroll container.
+   */
+  onPan?: (event: WheelEvent) => void
+}
+
 /**
- * Bind browser pinch/ctrl-wheel zoom and horizontal wheel gestures for preview scroll containers.
+ * Bind browser pinch/ctrl-wheel zoom and horizontal wheel gestures for preview
+ * scroll containers. Trackpad pinch fires `wheel` with `ctrlKey=true`; without
+ * a non-passive native listener the browser falls back to page zoom. `metaKey`
+ * is also accepted so Cmd+scroll zooms on macOS, matching Figma/tldraw/Excalidraw.
  */
 export function bindPreviewWheelZoom(
   container: HTMLElement,
-  onZoom: (event: WheelEvent) => void
+  onZoom: (event: WheelEvent) => void,
+  options: BindPreviewWheelZoomOptions = {}
 ): () => void {
+  const { onPan } = options
+
   const onWheel = (event: WheelEvent) => {
-    if (event.ctrlKey) {
+    if (event.ctrlKey || event.metaKey) {
       event.preventDefault()
       onZoom(event)
       return
     }
 
+    if (onPan) {
+      event.preventDefault()
+      onPan(event)
+      return
+    }
+
     const horizontalDelta = event.deltaX !== 0 ? event.deltaX : event.shiftKey ? event.deltaY : 0
     if (horizontalDelta === 0 || container.scrollWidth <= container.clientWidth) return
 
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/zoomable-preview.tsx b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/zoomable-preview.tsx
index 272bb00b2b7..a0a6acbbb5c 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/zoomable-preview.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/zoomable-preview.tsx
@@ -1,9 +1,10 @@
 'use client'
 
-import type { MouseEvent, ReactNode, WheelEvent } from 'react'
+import type { MouseEvent, ReactNode } from 'react'
 import { useCallback, useLayoutEffect, useRef, useState } from 'react'
 import { cn } from '@/lib/core/utils/cn'
 import { PreviewToolbar } from './preview-toolbar'
+import { bindPreviewWheelZoom } from './preview-wheel-zoom'
 
 const ZOOM_MIN = 0.25
 const ZOOM_MAX = 4
@@ -133,31 +134,39 @@ export function ZoomablePreview({
     applyZoom(clampZoom(zoom / ZOOM_BUTTON_FACTOR))
   }
 
-  const handleWheel = (e: WheelEvent<HTMLDivElement>) => {
-    e.preventDefault()
-    if (e.ctrlKey || e.metaKey) {
-      hasInteractedRef.current = true
-      const rect = e.currentTarget.getBoundingClientRect()
-      applyZoom(
-        clampZoom(zoomRef.current * Math.exp(-e.deltaY * ZOOM_WHEEL_SENSITIVITY)),
-        e.clientX - rect.left,
-        e.clientY - rect.top
-      )
-    } else {
-      hasInteractedRef.current = true
-      setOffset((currentOffset) =>
-        clampOffset(
-          containerSizeRef.current,
-          contentSizeRef.current,
-          {
-            x: currentOffset.x - e.deltaX,
-            y: currentOffset.y - e.deltaY,
-          },
-          zoomRef.current
+  useLayoutEffect(() => {
+    const viewport = viewportRef.current
+    if (!viewport) return
+
+    return bindPreviewWheelZoom(
+      viewport,
+      (event) => {
+        hasInteractedRef.current = true
+        const rect = viewport.getBoundingClientRect()
+        applyZoom(
+          clampZoom(zoomRef.current * Math.exp(-event.deltaY * ZOOM_WHEEL_SENSITIVITY)),
+          event.clientX - rect.left,
+          event.clientY - rect.top
         )
-      )
-    }
-  }
+      },
+      {
+        onPan: (event) => {
+          hasInteractedRef.current = true
+          setOffset((currentOffset) =>
+            clampOffset(
+              containerSizeRef.current,
+              contentSizeRef.current,
+              {
+                x: currentOffset.x - event.deltaX,
+                y: currentOffset.y - event.deltaY,
+              },
+              zoomRef.current
+            )
+          )
+        },
+      }
+    )
+  }, [applyZoom])
 
   useLayoutEffect(() => {
     const updateSizes = () => {
@@ -257,7 +266,6 @@ export function ZoomablePreview({
         onMouseMove={handleMouseMove}
         onMouseUp={handleMouseUp}
         onMouseLeave={handleMouseUp}
-        onWheel={handleWheel}
       >
         <div className='pointer-events-none absolute inset-0 flex items-center justify-center'>
           <div
diff --git a/apps/sim/app/workspace/[workspaceId]/providers/provider-models-loader.tsx b/apps/sim/app/workspace/[workspaceId]/providers/provider-models-loader.tsx
index f83d9e63bb0..f2563a2b37c 100644
--- a/apps/sim/app/workspace/[workspaceId]/providers/provider-models-loader.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/providers/provider-models-loader.tsx
@@ -6,6 +6,7 @@ import { useParams } from 'next/navigation'
 import { useProviderModels } from '@/hooks/queries/providers'
 import {
   updateFireworksProviderModels,
+  updateLiteLLMProviderModels,
   updateOllamaProviderModels,
   updateOpenRouterProviderModels,
   updateVLLMProviderModels,
@@ -32,6 +33,8 @@ function useSyncProvider(provider: ProviderName, workspaceId?: string) {
         updateOllamaProviderModels(data.models)
       } else if (provider === 'vllm') {
         updateVLLMProviderModels(data.models)
+      } else if (provider === 'litellm') {
+        updateLiteLLMProviderModels(data.models)
       } else if (provider === 'openrouter') {
         void updateOpenRouterProviderModels(data.models)
         if (data.modelInfo) {
@@ -61,6 +64,7 @@ export function ProviderModelsLoader() {
   useSyncProvider('base')
   useSyncProvider('ollama')
   useSyncProvider('vllm')
+  useSyncProvider('litellm')
   useSyncProvider('openrouter')
   useSyncProvider('fireworks', workspaceId)
   return null
diff --git a/apps/sim/app/workspace/[workspaceId]/settings/components/byok/byok.tsx b/apps/sim/app/workspace/[workspaceId]/settings/components/byok/byok.tsx
index 527d9262251..4aaf902ffaf 100644
--- a/apps/sim/app/workspace/[workspaceId]/settings/components/byok/byok.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/settings/components/byok/byok.tsx
@@ -23,12 +23,14 @@ import {
   FireworksIcon,
   GeminiIcon,
   GoogleIcon,
+  HunterIOIcon,
   ImageIcon,
   JinaAIIcon,
   LinkupIcon,
   MistralIcon,
   OpenAIIcon,
   ParallelIcon,
+  PeopleDataLabsIcon,
   PerplexityIcon,
   SerperIcon,
 } from '@/components/icons'
@@ -156,6 +158,20 @@ const PROVIDERS: {
     description: 'Brand assets, logos, colors, and company info',
     placeholder: 'Enter your Brandfetch API key',
   },
+  {
+    id: 'hunter',
+    name: 'Hunter',
+    icon: HunterIOIcon,
+    description: 'Email finder, verification, and domain search',
+    placeholder: 'Enter your Hunter.io API key',
+  },
+  {
+    id: 'peopledatalabs',
+    name: 'People Data Labs',
+    icon: PeopleDataLabsIcon,
+    description: 'Person and company enrichment, search, and identity',
+    placeholder: 'Enter your People Data Labs API key',
+  },
 ]
 
 export function BYOK() {
diff --git a/apps/sim/app/workspace/[workspaceId]/w/components/preview/components/preview-workflow/preview-workflow.tsx b/apps/sim/app/workspace/[workspaceId]/w/components/preview/components/preview-workflow/preview-workflow.tsx
index dfde43d4792..f8dddc56ab6 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/components/preview/components/preview-workflow/preview-workflow.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/components/preview/components/preview-workflow/preview-workflow.tsx
@@ -108,26 +108,24 @@ export function getLeftmostBlockId(workflowState: WorkflowState | null | undefin
 /** Execution status for edges/nodes in the preview */
 type ExecutionStatus = 'success' | 'error' | 'not-executed'
 
-/** Calculates absolute position, handling nested subflows. */
-function calculateAbsolutePosition(
+/** Calculates nesting depth, handling nested subflows. */
+function calculateNestingDepth(
   block: BlockState,
-  blocks: Record<string, BlockState>
-): { x: number; y: number } {
-  if (!block.data?.parentId) {
-    return block.position
-  }
-
-  const parentBlock = blocks[block.data.parentId]
+  blocks: Record<string, BlockState>,
+  visited: Set<string> = new Set()
+): number {
+  const parentId = block.data?.parentId
+  if (!parentId) return 0
+  if (visited.has(parentId)) return 0
+
+  const parentBlock = blocks[parentId]
   if (!parentBlock) {
-    logger.warn(`Parent block not found for child block`)
-    return block.position
+    logger.warn('Parent block not found for child block')
+    return 0
   }
 
-  const parentAbsolutePosition = calculateAbsolutePosition(parentBlock, blocks)
-  return {
-    x: parentAbsolutePosition.x + block.position.x,
-    y: parentAbsolutePosition.y + block.position.y,
-  }
+  visited.add(parentId)
+  return 1 + calculateNestingDepth(parentBlock, blocks, visited)
 }
 
 interface PreviewWorkflowProps {
@@ -329,7 +327,8 @@ export function PreviewWorkflow({
 
       if (childStatuses.length === 0) return undefined
       if (childStatuses.some((s) => s === 'error')) return 'error'
-      return 'success'
+      if (childStatuses.every((s) => s === 'success')) return 'success'
+      return undefined
     }
     return derive
   }, [subflowChildrenMap, blockExecutionMap, workflowState.blocks])
@@ -367,13 +366,20 @@ export function PreviewWorkflow({
 
     const nodeArray: Node[] = []
 
-    Object.entries(workflowState.blocks || {}).forEach(([blockId, block]) => {
+    const sortedBlocks = Object.entries(workflowState.blocks || {}).sort(
+      ([, left], [, right]) =>
+        calculateNestingDepth(left, workflowState.blocks) -
+        calculateNestingDepth(right, workflowState.blocks)
+    )
+
+    sortedBlocks.forEach(([blockId, block]) => {
       if (!block || !block.type) {
         logger.warn(`Skipping invalid block: ${blockId}`)
         return
       }
 
-      const absolutePosition = calculateAbsolutePosition(block, workflowState.blocks)
+      const parentId = block.data?.parentId
+      const nestingDepth = calculateNestingDepth(block, workflowState.blocks)
 
       if (block.type === 'loop' || block.type === 'parallel') {
         const isSelected = selectedBlockId === blockId
@@ -391,9 +397,14 @@ export function PreviewWorkflow({
         nodeArray.push({
           id: blockId,
           type: 'subflowNode',
-          position: absolutePosition,
+          position: block.position,
+          parentId,
+          extent: block.data?.extent || undefined,
           draggable: false,
+          zIndex: nestingDepth,
+          className: parentId ? 'nested-subflow-node' : undefined,
           data: {
+            ...block.data,
             name: block.name,
             width: dimensions.width,
             height: dimensions.height,
@@ -430,9 +441,11 @@ export function PreviewWorkflow({
       nodeArray.push({
         id: blockId,
         type: nodeType,
-        position: absolutePosition,
+        position: block.position,
+        parentId,
+        extent: block.data?.extent || undefined,
         draggable: false,
-        zIndex: block.data?.parentId ? 10 : undefined,
+        zIndex: parentId ? 1000 : undefined,
         data: {
           type: block.type,
           name: block.name,
diff --git a/apps/sim/app/workspace/[workspaceId]/w/components/preview/preview.tsx b/apps/sim/app/workspace/[workspaceId]/w/components/preview/preview.tsx
index bb4ffa6ad3d..adaab38e200 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/components/preview/preview.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/components/preview/preview.tsx
@@ -34,6 +34,15 @@ interface BlockExecutionData {
   childWorkflowSnapshotId?: string
 }
 
+function isPauseOutput(output: unknown): boolean {
+  return (
+    output !== null &&
+    typeof output === 'object' &&
+    '_pauseMetadata' in output &&
+    (output as Record<string, unknown>)._pauseMetadata !== undefined
+  )
+}
+
 /** Represents a level in the workflow navigation stack */
 interface WorkflowStackEntry {
   workflowState: WorkflowState
@@ -91,7 +100,7 @@ export function buildBlockExecutions(spans: TraceSpan[]): Record<string, BlockEx
       blockExecutionMap[span.blockId] = {
         input: redactApiKeys(span.input || {}),
         output: redactApiKeys(span.output || {}),
-        status: span.status || 'unknown',
+        status: isPauseOutput(span.output) ? 'pending' : span.status || 'unknown',
         durationMs: span.duration || 0,
         children: span.children,
         childWorkflowSnapshotId: span.childWorkflowSnapshotId,
diff --git a/apps/sim/blocks/blocks/hunter.ts b/apps/sim/blocks/blocks/hunter.ts
index 4c26bb85d43..1cd983c2eca 100644
--- a/apps/sim/blocks/blocks/hunter.ts
+++ b/apps/sim/blocks/blocks/hunter.ts
@@ -256,6 +256,7 @@ Return ONLY the search query text - no explanations.`,
       required: true,
       placeholder: 'Enter your Hunter.io API key',
       password: true,
+      hideWhenHosted: true,
     },
   ],
   tools: {
diff --git a/apps/sim/blocks/blocks/peopledatalabs.ts b/apps/sim/blocks/blocks/peopledatalabs.ts
index 2578574993e..1689fbb4acb 100644
--- a/apps/sim/blocks/blocks/peopledatalabs.ts
+++ b/apps/sim/blocks/blocks/peopledatalabs.ts
@@ -397,6 +397,7 @@ export const PeopleDataLabsBlock: BlockConfig<PdlPersonEnrichResponse> = {
       placeholder: 'Enter your People Data Labs API key',
       password: true,
       required: true,
+      hideWhenHosted: true,
     },
   ],
 
diff --git a/apps/sim/blocks/utils.test.ts b/apps/sim/blocks/utils.test.ts
index 309f5990474..3148e646732 100644
--- a/apps/sim/blocks/utils.test.ts
+++ b/apps/sim/blocks/utils.test.ts
@@ -27,6 +27,7 @@ const { mockProviders } = vi.hoisted(() => ({
       base: { models: [] as string[], isLoading: false },
       ollama: { models: [] as string[], isLoading: false },
       vllm: { models: [] as string[], isLoading: false },
+      litellm: { models: [] as string[], isLoading: false },
       openrouter: { models: [] as string[], isLoading: false },
       fireworks: { models: [] as string[], isLoading: false },
     },
@@ -101,6 +102,7 @@ describe('getApiKeyCondition / shouldRequireApiKeyForModel', () => {
       base: { models: [], isLoading: false },
       ollama: { models: [], isLoading: false },
       vllm: { models: [], isLoading: false },
+      litellm: { models: [], isLoading: false },
       openrouter: { models: [], isLoading: false },
       fireworks: { models: [], isLoading: false },
     }
@@ -185,6 +187,11 @@ describe('getApiKeyCondition / shouldRequireApiKeyForModel', () => {
       expect(evaluateCondition('my-custom-model')).toBe(false)
     })
 
+    it('does not require API key when model is in the LiteLLM store bucket', () => {
+      mockProviders.value.litellm.models = ['litellm/anthropic/claude-sonnet-4-6']
+      expect(evaluateCondition('litellm/anthropic/claude-sonnet-4-6')).toBe(false)
+    })
+
     it('requires API key when model is in the fireworks store bucket', () => {
       mockProviders.value.fireworks.models = ['fireworks/llama-3']
       expect(evaluateCondition('fireworks/llama-3')).toBe(true)
diff --git a/apps/sim/blocks/utils.ts b/apps/sim/blocks/utils.ts
index 830a4642e66..4a17b845263 100644
--- a/apps/sim/blocks/utils.ts
+++ b/apps/sim/blocks/utils.ts
@@ -51,6 +51,7 @@ export function getModelOptions() {
   const baseModels = providersState.providers.base.models
   const ollamaModels = providersState.providers.ollama.models
   const vllmModels = providersState.providers.vllm.models
+  const litellmModels = providersState.providers.litellm.models
   const openrouterModels = providersState.providers.openrouter.models
   const fireworksModels = providersState.providers.fireworks.models
   const allModels = Array.from(
@@ -58,6 +59,7 @@ export function getModelOptions() {
       ...baseModels,
       ...ollamaModels,
       ...vllmModels,
+      ...litellmModels,
       ...openrouterModels,
       ...fireworksModels,
     ])
@@ -160,12 +162,13 @@ function shouldRequireApiKeyForModel(model: string): boolean {
   ) {
     return false
   }
-  if (normalizedModel.startsWith('vllm/')) {
+  if (normalizedModel.startsWith('vllm/') || normalizedModel.startsWith('litellm/')) {
     return false
   }
 
   const storeProvider = getProviderFromStore(normalizedModel)
-  if (storeProvider === 'ollama' || storeProvider === 'vllm') return false
+  if (storeProvider === 'ollama' || storeProvider === 'vllm' || storeProvider === 'litellm')
+    return false
   if (storeProvider) return true
 
   if (isOllamaConfigured) {
diff --git a/apps/sim/components/icons.tsx b/apps/sim/components/icons.tsx
index 5f79d8ad05c..0e10935d999 100644
--- a/apps/sim/components/icons.tsx
+++ b/apps/sim/components/icons.tsx
@@ -4439,6 +4439,20 @@ export function VllmIcon(props: SVGProps<SVGSVGElement>) {
   )
 }
 
+export function LitellmIcon(props: SVGProps<SVGSVGElement>) {
+  return (
+    <svg {...props} fill='none' viewBox='0 0 72 72' xmlns='http://www.w3.org/2000/svg'>
+      <title>LiteLLM</title>
+      <image
+        href='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEgAAABICAMAAABiM0N1AAAC+lBMVEUAAABmZmXo6uvl5uQ+S3bd4uPl5t5DRk/n6ed6nbji4tYvPmuosLyIqcOApcAnJB86Rm8xLSpgc5Oguszi49zs7eakqaPq6uRNXY7T08M5SYc0QGsoJiRRT0mFhXZ0d3CnuMRHS1LZ2cr4+PIoNGM0MyslIR9KV341Mi0qO22WnrrD0tuLkqBpj7AqM1STrMdlZU+amXyfn4SyxtPn6ONOWXzj49urwtLs7OOeoZ/F09xMX5C6yNY0NkPDytJ5eWBteqQvQGxndpGarMBGRDs0MyqlpY5LSD+RkXZqc48wPWTZ2dGtraZETnHX18xXV0YhHxt9fnSvtclUaZ87OjFvb1f4+PJ5eV9zc1vk5Nj8/Pbq6t/m5trt7eRoaFL19u/i4tXd3c/6+vTz8+zv7+dsbFba2szT08Po6Nzf39J2dl3s7OHW1scmNWM4RnksPnR+fmNkZE7x8elml7rNzbw8SX2BgWWIiGwmNmcrPHAhLFNlZVDCwq1MX6ArO2soNlwnN2zQ0MBEW6VQVVhEQTk2MSyjo4YxQXdwnsDLy7nGxrJFXas2SIQdJ0fX18saIj1IRzsuKiWxz+amx+GQt9Z3pMZLZbtIYbO7u6RBV6A9UpWnjF+Ks9Fgk7itrZI2SYk+ToQwQXyWl3kzQG6FhWl7qMlpmr+7vaq+vqi2tqI7TYxHVIQvO2ZNVV6fwdtThatJXJqyspkzRYB+gHiPj3FUWV0dGxeDrMvNz8fIyLY/VZs6TpFEVY6bmnxUaHqSlHg8OTSQmrQ4RXI8RGGZvNdxjqZSZqRGWZXGycC9wb2xt7NmeK6BlKRjhKNOWX5+gXt7fXZPWHNsgL9Ra7yirrKqqp9RY56kpJOuk2A0PVXqq1RKS0ZTU0Nxmrhug55kfZVCUolJUmxfYFpCRUaTs85ajrR2krGUpa1LZK2RnaRaWkzppUXa29h6jMWFo7XAwbRaia5ecH6rkmMqMkg2Okayu9N2h5KUloeXiWRqamBFU3qbhFjglzLFgynBltUQAAAAVXRSTlMACgUOhiGTMS/98YYc/v7+h4X+29dmU0n59PPy2Rz9/fr59fPz7urMoZ2Zgzn++/jz8tC/tKmooH9xZl1VTPv079zZ08q1m5h+dV3l49/U0rGreG9fuSw7vQAABwlJREFUWMPs0z+M0lAcwHFzBHIQYRCwYSM6KrkBIoRcHHTUOJJU2tAW0j+hU+vowlaXDnIkDmU8DAuO4OJEk0JggzABywFx4WC52d/j8eeiIODiwjcBpvfh995rH5w6derU/+rMZrefE4TfH4s5oH8ybHbCH3sR8flcLhfL8rosC4HjB7ETjojPxfKykMt9WPfp2FkIx7uAAEBO5lmJISkxmc3SUPJI6Pnbbq/X63a75a+339l0Kg0pipLJZI/b1sPHr+bzH6vmZUqkcKTrmMO5jL52hmbfNg2b4tIB6FAlHvV6NLUIqWppmWpaFAkxjHQYZLuMet1IUUuaVoCucQWtZUmSBE8A/+QAxh4PX3hUFRAQqlXDMK6WGUZ1kuN59CDthc7On3ndfaQAAkS9XqlU8rjKlVH1dAQZEgL7GY9aVJECCBCfF+UrN27nONSGzKYA7YHWDFKWCCLM9vARNBwMzFarkxNgqL9B9g2DlXx9YQzv7lo/O82GVavpus6zDMq1+6biYfeGyddvPOP2YNCaNBs1XYJXQ0zisjhq1+EQ4Qt1VCxp13BFaDMmDNGo8QyFltK41W8GonccjiPoHI0WZ1zojxcGS4rr/8eLlXQ6lUhwqETi6dZd+X1BGEfVNK3vnDQtnbm3ExoAWI/i0FcKSgC07cojL6ezGbwJ/WmnsToP+ICBCQ73XuRZHiVTAG3Z1ZvGxAz1ndOgxTMkBQwgyMAIAKtYGk+WygL0566Ej+Uvt5YFd8OQJAUQIDAJNu7HMSmOQ046qSj0b+P8ar7OQ5oM4wCOv7NjfySoUSJ5ZXhGdEFBdN8HRKdtYpnSYW7tSFrNpducW1LOzH90M8i5BelaUOug3Ky1wKiBHdJsFeEBYakEVnRDv+f3vDu0Wf/2wcF42fN9n+d5977MhTNuGwylRwsPF0AGOrlkR7ASUthLHmZwoQqFxQDe5BzanTNid6ZOKW9uKT2FGViVECvBmcD54fT7Pw8NPSM8k++x3no8K0K/yRNnnDY0nyo8QzI4F7y8/sLefcX79whzhZ876+rq6uurqjSmsvb29jLC2TgtdFlHmw2nyyFTlBOoELvYBFw6MPisDktVGhryer1lXqc1EIpYsvpRS2n54YKCohwh7i6CCDYOEfhQnQMV2jGayvysen9o3PYVHc9PHT4IGbxIezECEyEJGM7Kz1/WCRVcmLFVdqWs7AoRDEXOnCy59BAzxbDBAGYizGUT+Sx4qh4cqqcZ6DSIH0DkAbhisk9jO3FNjna4nfbg3mAkkChCBdT0/ipAMq0NDreTZJzObqesUozrmhlnb61qv5WLN2LxnlwsBIcfBPTJfMujAUaYTYPD2mgxOaHSbTJ1iyXx2HE2GqvqPYPkaZC7Ox8DdCiMRYWse0bQSjONepsMIiaZTGaqVEIoYlEc6XR6BoWH8ougcCY4tBzhjwTikbcBOBwOq7VRb29SiWUyMXDLLPJUhomlnU7PrQIcHzLyNnGaKgVvHFZIwFz0kKmUKCwQcbstFrFSlMpMWKVv1fT392u8H3B0YGgpamYZwDsrJuz2pibIlCgVNguyuZWqVGaj3mHUaOAaxLWwYy8GNRtaiKvofAcESEIiKSlRq+WiapUNiSwixWwmSw/LJqe69BxO2mLoOhfi5NXzQV/udBBPqZ6enk+++1RPz/0UJstuorP93kXOevXrr4GXaGBg4OePrpMBbUmPwbWgJ73JcOAJSk5mspSSykoyWfcX+vmv54aHh1+gc20n25AZHJitUilCVFfX1FSjmtmKmhpmkkqhEhH3k8zgrrnNfNfPbL4ecDy79wargkpx9fX1vSIqUvpSGO5KrCoUvuTjI11gHQNSqfTYaNI8voAnEPB4Ani/nGEWx8McwcdvPGkYPCAA/D/l8XlIIOVn8xkorVRgqDebzxcgHkWHZwcd+AN7OC9vLgNmZVgU1RCCw4j2+HRg3t+cOAF/CEIgckeGW+X7JuCFEECHfjjEkTFBiKYWL8hISgru8TEpj6wJXv8QWGPob+hF69bNnz9/3rx55uvHpbhHuE2j4SaOIlg++j+eyMhZsbGxi7b1Vly+DF+ZywEVfu/Ba3AWaMlLe1a7ZcMGJixuhkokVyuBXC5CKj+fVqt1uXS62qioqJt+WznhO5wFNrlaXUJvcoQx7H0is1iTuX5NGsTQzaiba8cIbYzHjkQCIXVISC6ykY5rfSInghNTqwOkpouKCd+ZtZl2SAkog2w+l/aVNo2Ly0+vxSXqXLXp3DEWxnYqgZglQ+4+2GRXDF1ITJROS8CEIsKGlqZiiJZCM2KxD65QWmYie8KYdJiOrjYdwuFwstQlADOkYLoUEJ+QlrB2Z2AYZ2lmQkJC5tIwHcTdNImKjo4eHxANNnG53BGjOImJiRzmP/Ubf4ltRM+YtyIAAAAASUVORK5CYII='
+        width='72'
+        height='72'
+        preserveAspectRatio='xMidYMid meet'
+      />
+    </svg>
+  )
+}
+
 export function PosthogIcon(props: SVGProps<SVGSVGElement>) {
   return (
     <svg
@@ -4635,16 +4649,9 @@ export function ZendeskIcon(props: SVGProps<SVGSVGElement>) {
 
 export function ZoomIcon(props: SVGProps<SVGSVGElement>) {
   return (
-    <svg
-      {...props}
-      fill='currentColor'
-      width='800px'
-      height='800px'
-      viewBox='-1 9.5 34 13'
-      version='1.1'
-      xmlns='http://www.w3.org/2000/svg'
-    >
-      <path d='M19.28 17.4c-0.37 0.37-0.88 0.61-1.44 0.61-1.12 0-2.02-0.91-2.02-2.02s0.91-2.02 2.02-2.02c0.93 0 1.71 0.63 1.95 1.48l0 0.01c0.05 0.16 0.07 0.34 0.07 0.53 0 0.55-0.22 1.05-0.58 1.42l0-0zM15.47 13.59c-0.65 0.62-1.05 1.48-1.05 2.45 0 1.86 1.51 3.37 3.37 3.37s3.37-1.51 3.37-3.37c0-1.54-1.03-2.84-2.44-3.24l-0.02-0.01c-0.27-0.08-0.58-0.12-0.9-0.12-0.9 0-1.72 0.35-2.32 0.93l00zM28.3 12.6c-0.8 0-1.52 0.35-2.02 0.91l0 0c-0.5-0.56-1.22-0.91-2.02-0.91-0.56 0-1.09 0.17-1.52 0.47l0.01-0.01c-0.32-0.28-0.73-0.45-1.18-0.46l0-0v6.74l0.34-0.02c0.54-0.01 0.98-0.45 1-0.99l00 0.02-0.34v-2.36l0.02-0.34c00 00 00 0-0.24 0.06-0.48 0.17-0.68l0 0.01c0.24-0.4 0.67-0.67 1.17-0.67s0.93 0.27 1.16 0.66l0 0.01c0.1 0.2 0.16 0.43 0.17 0.68v0l0.02 0.34v2.36l0.02 0.34c0.02 0.54 0.45 0.97 0.99 1l0 0 0.34 0.02v-3.71l0.02-0.34c00 00 00 0-0.25 0.06-0.48 0.17-0.68l0 0.01c0.24-0.4 0.67-0.67 1.17-0.67 0.5 0 0.93 0.27 1.16 0.67l0 0.01c0.1 0.2 0.16 0.43 0.16 0.67 0 0 0 0 0 0v-0l0.02 0.34v2.36l0.02 0.34c0.02 0.54 0.45 0.98 0.99 1l0 0 0.34 0.02v-4.04c0-1.49-1.21-2.69-2.7-2.690 00 00 0h0zM12.21 17.4c-0.37 0.39-0.89 0.64-1.47 0.64-1.12 0-2.02-0.91-2.02-2.02s0.91-2.02 2.02-2.02c0.92 0 1.7 0.62 1.95 1.47l0 0.01c0.05 0.16 0.08 0.35 0.08 0.54 0 0.54-0.21 1.02-0.55 1.39l00zM10.78 12.6h0c-1.86 0-3.37 1.51-3.37 3.37s1.51 3.37 3.37 3.37 3.37-1.51 3.37-3.37c0-1.86-1.51-3.37-3.37-3.37h-0zM6.73 18.01l-0.34-0.01h-3.03l4.04-4.04-0.02-0.34c-0.01-0.54-0.45-0.98-0.99-0.99l0-0-0.34-0.02h-5.05l0.02 0.34c0.03 0.54 0.46 0.97 0.99 1l0 0 0.34 0.02h3.04l-4.05 4.05 0.02 0.34c0.02 0.54 0.45 0.98 0.99 1l0 0 0.34 0.02h5.06l-0.02-0.34c-0.02-0.54-0.45-0.97-0.99-0.99l0-0z' />
+    <svg {...props} viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg' aria-hidden='true'>
+      <rect x='2' y='6' width='14' height='12' rx='2.5' fill='#0B5CFF' />
+      <path d='M16 9 L22 6 V18 L16 15 Z' fill='#0B5CFF' />
     </svg>
   )
 }
diff --git a/apps/sim/connectors/registry.ts b/apps/sim/connectors/registry.ts
index 284f20bc522..4e87861bde6 100644
--- a/apps/sim/connectors/registry.ts
+++ b/apps/sim/connectors/registry.ts
@@ -29,6 +29,7 @@ import type { ConnectorRegistry } from '@/connectors/types'
 import { webflowConnector } from '@/connectors/webflow'
 import { wordpressConnector } from '@/connectors/wordpress'
 import { zendeskConnector } from '@/connectors/zendesk'
+import { zoomConnector } from '@/connectors/zoom'
 
 export const CONNECTOR_REGISTRY: ConnectorRegistry = {
   airtable: airtableConnector,
@@ -61,4 +62,5 @@ export const CONNECTOR_REGISTRY: ConnectorRegistry = {
   webflow: webflowConnector,
   wordpress: wordpressConnector,
   zendesk: zendeskConnector,
+  zoom: zoomConnector,
 }
diff --git a/apps/sim/connectors/zoom/index.ts b/apps/sim/connectors/zoom/index.ts
new file mode 100644
index 00000000000..668411f0deb
--- /dev/null
+++ b/apps/sim/connectors/zoom/index.ts
@@ -0,0 +1 @@
+export { zoomConnector } from '@/connectors/zoom/zoom'
diff --git a/apps/sim/connectors/zoom/zoom.test.ts b/apps/sim/connectors/zoom/zoom.test.ts
new file mode 100644
index 00000000000..040de394fbf
--- /dev/null
+++ b/apps/sim/connectors/zoom/zoom.test.ts
@@ -0,0 +1,87 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { parseVtt } from '@/connectors/zoom/zoom'
+
+const HEADER = 'WEBVTT\n\n'
+
+describe('parseVtt', () => {
+  it.concurrent('returns empty string for input with no cues', () => {
+    expect(parseVtt(HEADER)).toBe('')
+  })
+
+  it.concurrent('extracts plain spoken text from a single cue', () => {
+    const vtt = `${HEADER}00:00:00.000 --> 00:00:02.000\nHello world\n`
+    expect(parseVtt(vtt)).toBe('Hello world')
+  })
+
+  it.concurrent('preserves WebVTT voice tags as "Speaker: text"', () => {
+    const vtt = `${HEADER}00:00:00.000 --> 00:00:02.000\n<v Alice>hello there</v>\n`
+    expect(parseVtt(vtt)).toBe('Alice: hello there')
+  })
+
+  it.concurrent('preserves voice tags with class suffix', () => {
+    const vtt = `${HEADER}00:00:00.000 --> 00:00:02.000\n<v.host Bob>welcome</v>\n`
+    expect(parseVtt(vtt)).toBe('Bob: welcome')
+  })
+
+  it.concurrent('strips inline formatting tags but keeps text', () => {
+    const vtt = `${HEADER}00:00:00.000 --> 00:00:02.000\n<b>bold</b> and <i>italic</i>\n`
+    expect(parseVtt(vtt)).toBe('bold and italic')
+  })
+
+  it.concurrent('strips karaoke timestamp tags', () => {
+    const vtt = `${HEADER}00:00:00.000 --> 00:00:02.000\nhello <00:00:01.000>world\n`
+    expect(parseVtt(vtt)).toBe('hello world')
+  })
+
+  it.concurrent('strips class spans', () => {
+    const vtt = `${HEADER}00:00:00.000 --> 00:00:02.000\n<c.loud>SHOUT</c>\n`
+    expect(parseVtt(vtt)).toBe('SHOUT')
+  })
+
+  it.concurrent('skips cue identifier lines before timing', () => {
+    const vtt = `${HEADER}cue-1\n00:00:00.000 --> 00:00:02.000\nhello\n`
+    expect(parseVtt(vtt)).toBe('hello')
+  })
+
+  it.concurrent('joins multiple cues with newlines', () => {
+    const vtt = `${HEADER}00:00:00.000 --> 00:00:02.000\nfirst\n\n00:00:02.000 --> 00:00:04.000\nsecond\n`
+    expect(parseVtt(vtt)).toBe('first\nsecond')
+  })
+
+  it.concurrent('collapses repeated whitespace within a cue', () => {
+    const vtt = `${HEADER}00:00:00.000 --> 00:00:02.000\nhello   world\n`
+    expect(parseVtt(vtt)).toBe('hello world')
+  })
+
+  it.concurrent('iteratively strips overlapping tags that reconstruct after one pass', () => {
+    const crafted = '<<b>b>injected</<b>b>'
+    const vtt = `${HEADER}00:00:00.000 --> 00:00:02.000\n${crafted}\n`
+    const result = parseVtt(vtt)
+    expect(result).not.toMatch(/<\/?[^>]+>/)
+    expect(result).toContain('injected')
+  })
+
+  it.concurrent('iteratively strips nested script-like tag fragments', () => {
+    const crafted = '<scr<script>ipt>alert(1)</scr</script>ipt>'
+    const vtt = `${HEADER}00:00:00.000 --> 00:00:02.000\n${crafted}\n`
+    const result = parseVtt(vtt)
+    expect(result).not.toMatch(/<\/?[^>]+>/)
+    expect(result.toLowerCase()).not.toContain('script')
+  })
+
+  it.concurrent('sanitizes crafted speaker names that embed tag fragments', () => {
+    const vtt = `${HEADER}00:00:00.000 --> 00:00:02.000\n<v <b>Evil</b>>payload</v>\n`
+    const result = parseVtt(vtt)
+    expect(result).not.toMatch(/<\/?[^>]+>/)
+  })
+
+  it.concurrent('terminates on adversarial deeply-nested input', () => {
+    const crafted = `${'<'.repeat(50)}b${'>'.repeat(50)}text${'<'.repeat(50)}/b${'>'.repeat(50)}`
+    const vtt = `${HEADER}00:00:00.000 --> 00:00:02.000\n${crafted}\n`
+    const result = parseVtt(vtt)
+    expect(result).not.toMatch(/<\/?[^>]+>/)
+  })
+})
diff --git a/apps/sim/connectors/zoom/zoom.ts b/apps/sim/connectors/zoom/zoom.ts
new file mode 100644
index 00000000000..240031d1cf3
--- /dev/null
+++ b/apps/sim/connectors/zoom/zoom.ts
@@ -0,0 +1,524 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage, toError } from '@sim/utils/errors'
+import { ZoomIcon } from '@/components/icons'
+import { fetchWithRetry, VALIDATE_RETRY_OPTIONS } from '@/lib/knowledge/documents/utils'
+import type { ConnectorConfig, ExternalDocument, ExternalDocumentList } from '@/connectors/types'
+import { parseTagDate } from '@/connectors/utils'
+
+const logger = createLogger('ZoomConnector')
+
+const ZOOM_API_BASE = 'https://api.zoom.us/v2'
+const PAGE_SIZE = 300
+const WINDOW_DAYS = 30
+const DEFAULT_LOOKBACK_DAYS = 180
+const MAX_LOOKBACK_DAYS = 180
+/**
+ * Days of overlap added when computing the incremental sync window. Zoom transcript
+ * generation is usually fast, but AI Companion / audio transcription can lag hours to
+ * days for large accounts. A 30-day overlap catches late-arriving transcripts at the
+ * cost of at most one extra 30-day window per sync.
+ */
+const INCREMENTAL_OVERLAP_DAYS = 30
+const MS_PER_DAY = 24 * 60 * 60 * 1000
+
+interface ZoomRecordingFile {
+  id?: string
+  meeting_id?: string
+  recording_start?: string
+  recording_end?: string
+  file_type?: string
+  file_extension?: string
+  file_size?: number
+  download_url?: string
+  status?: string
+  recording_type?: string
+}
+
+interface ZoomRecording {
+  uuid: string
+  id?: number | string
+  topic?: string
+  start_time?: string
+  duration?: number
+  total_size?: number
+  recording_count?: number
+  share_url?: string
+  host_email?: string
+  host_id?: string
+  account_id?: string
+  type?: number
+  recording_files?: ZoomRecordingFile[]
+}
+
+interface ZoomRecordingsListResponse {
+  meetings?: ZoomRecording[]
+  next_page_token?: string
+  page_size?: number
+  total_records?: number
+  from?: string
+  to?: string
+}
+
+interface CursorState {
+  windowIndex: number
+  pageToken?: string
+}
+
+/**
+ * URL-encodes a Zoom meeting UUID. Double-encodes when the UUID starts with '/'
+ * or contains '//', per Zoom's API requirements.
+ */
+function encodeMeetingUuid(uuid: string): string {
+  const encoded = encodeURIComponent(uuid)
+  if (uuid.startsWith('/') || uuid.includes('//')) {
+    return encodeURIComponent(encoded)
+  }
+  return encoded
+}
+
+function formatDate(date: Date): string {
+  const y = date.getFullYear()
+  const m = String(date.getMonth() + 1).padStart(2, '0')
+  const d = String(date.getDate()).padStart(2, '0')
+  return `${y}-${m}-${d}`
+}
+
+function encodeCursor(state: CursorState): string {
+  return Buffer.from(JSON.stringify(state), 'utf8').toString('base64url')
+}
+
+function decodeCursor(cursor?: string): CursorState {
+  if (!cursor) return { windowIndex: 0 }
+  try {
+    const json = Buffer.from(cursor, 'base64url').toString('utf8')
+    const parsed = JSON.parse(json) as Partial<CursorState>
+    return {
+      windowIndex: Number(parsed.windowIndex) || 0,
+      pageToken: typeof parsed.pageToken === 'string' ? parsed.pageToken : undefined,
+    }
+  } catch {
+    return { windowIndex: 0 }
+  }
+}
+
+/**
+ * Picks the best transcript file from a recording's files array.
+ * Prefers the AI Companion audio_transcript (file_type TRANSCRIPT) and falls back
+ * to closed captions (file_type CC) — both are VTT and contain spoken text.
+ */
+function findTranscriptFile(files?: ZoomRecordingFile[]): ZoomRecordingFile | undefined {
+  if (!files) return undefined
+  const eligible = (f: ZoomRecordingFile) =>
+    Boolean(f.download_url) && (f.status === 'completed' || f.status == null)
+
+  const transcript = files.find((f) => f.file_type === 'TRANSCRIPT' && eligible(f))
+  if (transcript) return transcript
+  return files.find((f) => f.file_type === 'CC' && eligible(f))
+}
+
+/**
+ * Extracts spoken text from a Zoom WebVTT transcript, stripping cue identifiers,
+ * timestamps, and inline markup. Handles both Zoom's `Speaker: text` convention
+ * and standard WebVTT `<v Speaker>text</v>` voice tags.
+ *
+ * Exported for unit tests; not part of the connector's public surface.
+ */
+export function parseVtt(vtt: string): string {
+  const lines = vtt.split(/\r?\n/)
+  const segments: string[] = []
+  let i = 0
+
+  while (i < lines.length && lines[i].trim() !== '') i++
+
+  while (i < lines.length) {
+    while (i < lines.length && lines[i].trim() === '') i++
+    if (i >= lines.length) break
+
+    if (i + 1 < lines.length && !lines[i].includes('-->') && lines[i + 1].includes('-->')) {
+      i++
+    }
+
+    if (i < lines.length && lines[i].includes('-->')) {
+      i++
+    } else {
+      while (i < lines.length && lines[i].trim() !== '') i++
+      continue
+    }
+
+    const textParts: string[] = []
+    while (i < lines.length && lines[i].trim() !== '') {
+      textParts.push(lines[i])
+      i++
+    }
+
+    if (textParts.length > 0) {
+      const raw = textParts.join(' ')
+      const withSpeakers = raw.replace(/<v(?:\.[^\s>]+)?\s+([^>]+)>([\s\S]*?)<\/v>/g, '$1: $2')
+      let withoutTags = withSpeakers
+      let previous: string
+      do {
+        previous = withoutTags
+        withoutTags = withoutTags.replace(/<\/?[^>]+>/g, '')
+      } while (withoutTags !== previous)
+      const stripped = withoutTags.replace(/\s+/g, ' ').trim()
+      if (stripped) segments.push(stripped)
+    }
+  }
+
+  return segments.join('\n')
+}
+
+function formatTranscriptContent(recording: ZoomRecording, transcript: string): string {
+  const parts: string[] = []
+  if (recording.topic) parts.push(`Meeting: ${recording.topic}`)
+  if (recording.start_time) parts.push(`Date: ${recording.start_time}`)
+  if (recording.duration != null) parts.push(`Duration: ${recording.duration} minutes`)
+  if (recording.host_email) parts.push(`Host: ${recording.host_email}`)
+
+  parts.push('')
+  parts.push('--- Transcript ---')
+  parts.push(transcript)
+
+  return parts.join('\n')
+}
+
+function buildContentHash(recording: ZoomRecording, file: ZoomRecordingFile): string {
+  return `zoom:${recording.uuid}:${file.id ?? ''}:${file.file_size ?? ''}:${file.recording_end ?? ''}`
+}
+
+function buildSourceUrl(recording: ZoomRecording): string | undefined {
+  return recording.share_url || undefined
+}
+
+function recordingToStub(
+  recording: ZoomRecording,
+  transcriptFile: ZoomRecordingFile
+): ExternalDocument {
+  return {
+    externalId: recording.uuid,
+    title: recording.topic?.trim() || 'Untitled Zoom Meeting',
+    content: '',
+    contentDeferred: true,
+    mimeType: 'text/plain',
+    sourceUrl: buildSourceUrl(recording),
+    contentHash: buildContentHash(recording, transcriptFile),
+    metadata: {
+      meetingId: recording.id != null ? String(recording.id) : undefined,
+      hostEmail: recording.host_email,
+      duration: recording.duration,
+      meetingDate: recording.start_time,
+      topic: recording.topic,
+    },
+  }
+}
+
+/**
+ * Computes the effective lookback window in days, narrowing to the time since
+ * the last successful sync (plus an overlap to catch transcripts that finished
+ * processing late) when incremental sync is active.
+ */
+function computeLookbackDays(
+  sourceConfig: Record<string, unknown>,
+  lastSyncAt: Date | undefined
+): number {
+  const raw = sourceConfig.lookback as string | undefined
+  const configured = Number(raw)
+  const baseline =
+    Number.isFinite(configured) && configured > 0
+      ? Math.min(Math.floor(configured), MAX_LOOKBACK_DAYS)
+      : DEFAULT_LOOKBACK_DAYS
+
+  if (!lastSyncAt) return baseline
+
+  const sinceLastSync = Math.ceil((Date.now() - lastSyncAt.getTime()) / MS_PER_DAY)
+  const incremental = Math.max(sinceLastSync + INCREMENTAL_OVERLAP_DAYS, INCREMENTAL_OVERLAP_DAYS)
+  return Math.min(incremental, baseline)
+}
+
+export const zoomConnector: ConnectorConfig = {
+  id: 'zoom',
+  name: 'Zoom',
+  description: 'Sync meeting transcripts from Zoom cloud recordings',
+  version: '1.0.0',
+  icon: ZoomIcon,
+
+  auth: {
+    mode: 'oauth',
+    provider: 'zoom',
+    requiredScopes: [
+      'user:read:user',
+      'cloud_recording:read:list_user_recordings',
+      'cloud_recording:read:list_recording_files',
+    ],
+  },
+
+  supportsIncrementalSync: true,
+
+  configFields: [
+    {
+      id: 'lookback',
+      title: 'Date Range',
+      type: 'dropdown',
+      required: false,
+      options: [
+        { label: 'Last 30 days', id: '30' },
+        { label: 'Last 90 days', id: '90' },
+        { label: 'Last 6 months (recommended)', id: '180' },
+      ],
+      description:
+        'On initial sync only. Zoom only allows access to cloud recordings within the last 6 months.',
+    },
+    {
+      id: 'maxRecordings',
+      title: 'Max Recordings',
+      type: 'short-input',
+      required: false,
+      placeholder: 'e.g. 200 (default: unlimited)',
+    },
+  ],
+
+  listDocuments: async (
+    accessToken: string,
+    sourceConfig: Record<string, unknown>,
+    cursor?: string,
+    syncContext?: Record<string, unknown>,
+    lastSyncAt?: Date
+  ): Promise<ExternalDocumentList> => {
+    const lookbackDays = computeLookbackDays(sourceConfig, lastSyncAt)
+    const maxRecordings = sourceConfig.maxRecordings ? Number(sourceConfig.maxRecordings) : 0
+    const numWindows = Math.max(1, Math.ceil(lookbackDays / WINDOW_DAYS))
+    const state = decodeCursor(cursor)
+
+    if (state.windowIndex >= numWindows) {
+      return { documents: [], hasMore: false }
+    }
+
+    const now = new Date()
+    const earliest = new Date(now.getTime() - lookbackDays * MS_PER_DAY)
+    const toDate = new Date(now.getTime() - state.windowIndex * WINDOW_DAYS * MS_PER_DAY)
+    const rawFromDate = new Date(toDate.getTime() - WINDOW_DAYS * MS_PER_DAY)
+    const fromDate = rawFromDate < earliest ? earliest : rawFromDate
+
+    if (fromDate >= toDate) {
+      return { documents: [], hasMore: false }
+    }
+
+    const queryParams = new URLSearchParams({
+      page_size: String(PAGE_SIZE),
+      from: formatDate(fromDate),
+      to: formatDate(toDate),
+      trash: 'false',
+    })
+    if (state.pageToken) queryParams.set('next_page_token', state.pageToken)
+
+    const url = `${ZOOM_API_BASE}/users/me/recordings?${queryParams.toString()}`
+
+    logger.info('Listing Zoom recordings', {
+      windowIndex: state.windowIndex,
+      windowTotal: numWindows,
+      from: formatDate(fromDate),
+      to: formatDate(toDate),
+      hasToken: Boolean(state.pageToken),
+      incremental: Boolean(lastSyncAt),
+    })
+
+    const response = await fetchWithRetry(url, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/json',
+      },
+    })
+
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => '')
+      logger.error('Failed to list Zoom recordings', {
+        status: response.status,
+        error: errorText.slice(0, 500),
+      })
+      throw new Error(`Failed to list Zoom recordings: ${response.status}`)
+    }
+
+    const data = (await response.json()) as ZoomRecordingsListResponse
+    const meetings = data.meetings ?? []
+    const nextPageToken = data.next_page_token?.trim() || undefined
+
+    const allDocuments: ExternalDocument[] = []
+    for (const meeting of meetings) {
+      if (!meeting.uuid) continue
+      const transcript = findTranscriptFile(meeting.recording_files)
+      if (!transcript) continue
+      allDocuments.push(recordingToStub(meeting, transcript))
+    }
+
+    const prevFetched = (syncContext?.totalDocsFetched as number) ?? 0
+    let documents = allDocuments
+    if (maxRecordings > 0) {
+      const remaining = Math.max(0, maxRecordings - prevFetched)
+      if (allDocuments.length > remaining) {
+        documents = allDocuments.slice(0, remaining)
+      }
+    }
+
+    const totalFetched = prevFetched + documents.length
+    if (syncContext) syncContext.totalDocsFetched = totalFetched
+    const hitLimit = maxRecordings > 0 && totalFetched >= maxRecordings
+    if (hitLimit && syncContext) syncContext.listingCapped = true
+
+    let nextCursor: string | undefined
+    let hasMore = false
+
+    if (hitLimit) {
+      // Stop syncing — limit reached
+    } else if (nextPageToken) {
+      nextCursor = encodeCursor({ windowIndex: state.windowIndex, pageToken: nextPageToken })
+      hasMore = true
+    } else if (state.windowIndex + 1 < numWindows) {
+      nextCursor = encodeCursor({ windowIndex: state.windowIndex + 1 })
+      hasMore = true
+    }
+
+    return { documents, nextCursor, hasMore }
+  },
+
+  getDocument: async (
+    accessToken: string,
+    _sourceConfig: Record<string, unknown>,
+    externalId: string
+  ): Promise<ExternalDocument | null> => {
+    try {
+      if (!externalId) return null
+
+      const url = `${ZOOM_API_BASE}/meetings/${encodeMeetingUuid(externalId)}/recordings`
+
+      const response = await fetchWithRetry(url, {
+        method: 'GET',
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          Accept: 'application/json',
+        },
+      })
+
+      if (!response.ok) {
+        if (response.status === 404 || response.status === 410) return null
+        throw new Error(`Failed to fetch Zoom recording: ${response.status}`)
+      }
+
+      const recording = (await response.json()) as ZoomRecording
+      const transcript = findTranscriptFile(recording.recording_files)
+
+      if (!transcript?.download_url) {
+        logger.info('Transcript no longer available for Zoom recording', { externalId })
+        return null
+      }
+
+      const vttResponse = await fetchWithRetry(transcript.download_url, {
+        method: 'GET',
+        headers: { Authorization: `Bearer ${accessToken}` },
+      })
+
+      if (!vttResponse.ok) {
+        logger.warn('Failed to download Zoom transcript', {
+          externalId,
+          status: vttResponse.status,
+        })
+        return null
+      }
+
+      const vttText = await vttResponse.text()
+      const transcriptText = parseVtt(vttText).trim()
+      if (!transcriptText) return null
+
+      const content = formatTranscriptContent(recording, transcriptText)
+
+      return {
+        externalId: recording.uuid || externalId,
+        title: recording.topic?.trim() || 'Untitled Zoom Meeting',
+        content,
+        contentDeferred: false,
+        mimeType: 'text/plain',
+        sourceUrl: buildSourceUrl(recording),
+        contentHash: buildContentHash(recording, transcript),
+        metadata: {
+          meetingId: recording.id != null ? String(recording.id) : undefined,
+          hostEmail: recording.host_email,
+          duration: recording.duration,
+          meetingDate: recording.start_time,
+          topic: recording.topic,
+        },
+      }
+    } catch (error) {
+      logger.warn('Failed to get Zoom recording', {
+        externalId,
+        error: toError(error).message,
+      })
+      return null
+    }
+  },
+
+  validateConfig: async (
+    accessToken: string,
+    sourceConfig: Record<string, unknown>
+  ): Promise<{ valid: boolean; error?: string }> => {
+    const maxRecordings = sourceConfig.maxRecordings as string | undefined
+    if (maxRecordings && (Number.isNaN(Number(maxRecordings)) || Number(maxRecordings) < 0)) {
+      return { valid: false, error: 'Max recordings must be a non-negative number' }
+    }
+
+    try {
+      const response = await fetchWithRetry(
+        `${ZOOM_API_BASE}/users/me`,
+        {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            Accept: 'application/json',
+          },
+        },
+        VALIDATE_RETRY_OPTIONS
+      )
+
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => '')
+        return {
+          valid: false,
+          error: `Zoom access failed: ${response.status}${errorText ? ` — ${errorText.slice(0, 200)}` : ''}`,
+        }
+      }
+
+      return { valid: true }
+    } catch (error) {
+      const message = getErrorMessage(error, 'Failed to validate configuration')
+      return { valid: false, error: message }
+    }
+  },
+
+  tagDefinitions: [
+    { id: 'topic', displayName: 'Topic', fieldType: 'text' },
+    { id: 'hostEmail', displayName: 'Host Email', fieldType: 'text' },
+    { id: 'duration', displayName: 'Duration (minutes)', fieldType: 'number' },
+    { id: 'meetingDate', displayName: 'Meeting Date', fieldType: 'date' },
+  ],
+
+  mapTags: (metadata: Record<string, unknown>): Record<string, unknown> => {
+    const result: Record<string, unknown> = {}
+
+    if (typeof metadata.topic === 'string' && metadata.topic.trim()) {
+      result.topic = metadata.topic
+    }
+
+    if (typeof metadata.hostEmail === 'string' && metadata.hostEmail.trim()) {
+      result.hostEmail = metadata.hostEmail
+    }
+
+    if (metadata.duration != null) {
+      const num = Number(metadata.duration)
+      if (!Number.isNaN(num)) result.duration = num
+    }
+
+    const meetingDate = parseTagDate(metadata.meetingDate)
+    if (meetingDate) result.meetingDate = meetingDate
+
+    return result
+  },
+}
diff --git a/apps/sim/executor/constants.ts b/apps/sim/executor/constants.ts
index 71fa8dea3f1..592d8cecdbb 100644
--- a/apps/sim/executor/constants.ts
+++ b/apps/sim/executor/constants.ts
@@ -74,6 +74,20 @@ export const EDGE = {
   DEFAULT: 'default',
 } as const
 
+export const SUBFLOW_CONTROL_EDGE_HANDLES = new Set<string>([
+  EDGE.LOOP_CONTINUE,
+  EDGE.LOOP_CONTINUE_ALT,
+  EDGE.LOOP_EXIT,
+  EDGE.PARALLEL_CONTINUE,
+  EDGE.PARALLEL_EXIT,
+])
+
+export const CONTROL_BACK_EDGE_HANDLES = new Set<string>([
+  EDGE.LOOP_CONTINUE,
+  EDGE.LOOP_CONTINUE_ALT,
+  EDGE.PARALLEL_CONTINUE,
+])
+
 export const LOOP = {
   TYPE: {
     FOR: 'for' as LoopType,
diff --git a/apps/sim/executor/dag/construction/edges.test.ts b/apps/sim/executor/dag/construction/edges.test.ts
index 857f98af27b..0f10e33a48d 100644
--- a/apps/sim/executor/dag/construction/edges.test.ts
+++ b/apps/sim/executor/dag/construction/edges.test.ts
@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it } from 'vitest'
 import type { DAG, DAGNode } from '@/executor/dag/builder'
+import { buildBranchNodeId } from '@/executor/utils/subflow-utils'
 import type { SerializedBlock, SerializedLoop, SerializedWorkflow } from '@/serializer/types'
 import { EdgeConstructor } from './edges'
 
@@ -133,6 +134,129 @@ describe('EdgeConstructor', () => {
     })
   })
 
+  describe('nested subflow skip-at-start bypasses', () => {
+    it('wires a nested loop start exit to the next sibling inside a parallel branch', () => {
+      const parallelId = 'parallel-1'
+      const loopId = 'loop-1'
+      const afterId = 'after'
+      const loopStartId = `loop-${loopId}-sentinel-start`
+      const loopEndId = `loop-${loopId}-sentinel-end`
+      const afterTemplateId = buildBranchNodeId(afterId, 0)
+      const dag = createMockDAG([loopStartId, loopEndId, afterTemplateId])
+      dag.nodes.get(loopStartId)!.metadata = {
+        isSentinel: true,
+        sentinelType: 'start',
+        subflowId: loopId,
+        subflowType: 'loop',
+      }
+      dag.nodes.get(loopEndId)!.metadata = {
+        isSentinel: true,
+        sentinelType: 'end',
+        subflowId: loopId,
+        subflowType: 'loop',
+      }
+      dag.nodes.get(afterTemplateId)!.metadata = {
+        isParallelBranch: true,
+        subflowId: parallelId,
+        subflowType: 'parallel',
+        branchIndex: 0,
+      }
+      dag.loopConfigs.set(loopId, { id: loopId, nodes: [], iterations: 1 })
+      dag.parallelConfigs.set(parallelId, {
+        id: parallelId,
+        nodes: [loopId, afterId],
+        count: 1,
+      })
+
+      const workflow = createMockWorkflow(
+        [createMockBlock(loopId, 'loop'), createMockBlock(afterId)],
+        [{ source: loopId, target: afterId }]
+      )
+
+      edgeConstructor.execute(
+        workflow,
+        dag,
+        new Set([loopId, afterId]),
+        new Set(),
+        new Set([loopId, afterId]),
+        new Map()
+      )
+
+      const loopStartTargets = Array.from(dag.nodes.get(loopStartId)!.outgoingEdges.values())
+      expect(loopStartTargets).toContainEqual({
+        target: loopEndId,
+        sourceHandle: 'loop_exit',
+        targetHandle: undefined,
+      })
+      expect(Array.from(dag.nodes.get(loopEndId)!.outgoingEdges.values())).toContainEqual({
+        target: afterTemplateId,
+        sourceHandle: 'loop_exit',
+        targetHandle: undefined,
+      })
+      expect(dag.nodes.get(loopEndId)!.incomingEdges).not.toContain(loopStartId)
+    })
+
+    it('wires a parallel start exit bypass to a downstream parallel sentinel start', () => {
+      const sourceParallelId = 'parallel-a'
+      const targetParallelId = 'parallel-b'
+      const sourceStartId = `parallel-${sourceParallelId}-sentinel-start`
+      const sourceEndId = `parallel-${sourceParallelId}-sentinel-end`
+      const targetStartId = `parallel-${targetParallelId}-sentinel-start`
+      const targetEndId = `parallel-${targetParallelId}-sentinel-end`
+      const dag = createMockDAG([sourceStartId, sourceEndId, targetStartId, targetEndId])
+      dag.parallelConfigs.set(sourceParallelId, { id: sourceParallelId, nodes: [], count: 1 })
+      dag.parallelConfigs.set(targetParallelId, { id: targetParallelId, nodes: [], count: 1 })
+
+      const workflow = createMockWorkflow(
+        [
+          createMockBlock(sourceParallelId, 'parallel'),
+          createMockBlock(targetParallelId, 'parallel'),
+        ],
+        [{ source: sourceParallelId, target: targetParallelId }]
+      )
+
+      edgeConstructor.execute(workflow, dag, new Set(), new Set(), new Set(), new Map())
+
+      const sourceStartTargets = Array.from(dag.nodes.get(sourceStartId)!.outgoingEdges.values())
+      expect(sourceStartTargets).toContainEqual({
+        target: sourceEndId,
+        sourceHandle: 'parallel_exit',
+        targetHandle: undefined,
+      })
+      expect(dag.nodes.get(sourceEndId)!.incomingEdges).not.toContain(sourceStartId)
+    })
+
+    it('wires terminal top-level loop start exit through its own sentinel end', () => {
+      const loopId = 'loop-1'
+      const taskId = 'task-1'
+      const loopStartId = `loop-${loopId}-sentinel-start`
+      const loopEndId = `loop-${loopId}-sentinel-end`
+      const dag = createMockDAG([loopStartId, loopEndId, taskId])
+      dag.loopConfigs.set(loopId, { id: loopId, nodes: [taskId], iterations: 1 })
+      const workflow = createMockWorkflow(
+        [createMockBlock(loopId, 'loop'), createMockBlock(taskId)],
+        []
+      )
+
+      edgeConstructor.execute(
+        workflow,
+        dag,
+        new Set(),
+        new Set([taskId]),
+        new Set([taskId]),
+        new Map()
+      )
+
+      const loopStartTargets = Array.from(dag.nodes.get(loopStartId)!.outgoingEdges.values())
+      expect(loopStartTargets).toContainEqual({
+        target: loopEndId,
+        sourceHandle: 'loop_exit',
+        targetHandle: undefined,
+      })
+      expect(dag.nodes.get(loopEndId)!.incomingEdges).not.toContain(loopStartId)
+    })
+  })
+
   describe('Condition block edge wiring', () => {
     it('should wire condition block edges with proper condition prefixes', () => {
       const conditionId = 'condition-1'
@@ -441,8 +565,9 @@ describe('EdgeConstructor', () => {
 
       // Sentinel start should have edge to node in loop (it's a start node - no incoming from loop)
       const sentinelStartNode = dag.nodes.get(sentinelStartId)!
-      expect(sentinelStartNode.outgoingEdges.size).toBe(1)
-      const startEdge = Array.from(sentinelStartNode.outgoingEdges.values())[0]
+      const startEdge = Array.from(sentinelStartNode.outgoingEdges.values()).find(
+        (edge) => edge.target === nodeInLoopId
+      )
       expect(startEdge.target).toBe(nodeInLoopId)
 
       // Node in loop should have edge to sentinel end (it's a terminal node - no outgoing to loop)
@@ -500,7 +625,10 @@ describe('EdgeConstructor', () => {
 
       // Sentinel start should have edges to both nodes (both are start nodes)
       const sentinelStartNode = dag.nodes.get(sentinelStartId)!
-      expect(sentinelStartNode.outgoingEdges.size).toBe(2)
+      const bodyStartEdges = Array.from(sentinelStartNode.outgoingEdges.values()).filter(
+        (edge) => edge.target === node1Id || edge.target === node2Id
+      )
+      expect(bodyStartEdges).toHaveLength(2)
 
       // Both nodes should have edges to sentinel end (both are terminal nodes)
       const node1 = dag.nodes.get(node1Id)!
@@ -702,7 +830,7 @@ describe('EdgeConstructor', () => {
 
         const loop1StartNode = dag.nodes.get(loop1SentinelStart)!
         const earlyExitEdges = Array.from(loop1StartNode.outgoingEdges.values()).filter(
-          (e) => e.target === loop2SentinelStart && e.sourceHandle === 'loop_exit'
+          (e) => e.target === loop1SentinelEnd && e.sourceHandle === 'loop_exit'
         )
         expect(earlyExitEdges.length).toBeGreaterThan(0)
       })
@@ -864,7 +992,7 @@ describe('EdgeConstructor', () => {
 
         const loopStartNode = dag.nodes.get(loopSentinelStart)!
         const earlyExitEdges = Array.from(loopStartNode.outgoingEdges.values()).filter(
-          (e) => e.target === parallelSentinelStart && e.sourceHandle === 'loop_exit'
+          (e) => e.target === loopSentinelEnd && e.sourceHandle === 'loop_exit'
         )
         expect(earlyExitEdges.length).toBeGreaterThan(0)
       })
@@ -925,6 +1053,15 @@ describe('EdgeConstructor', () => {
         expect(edgesToRegular.length).toBe(1)
         expect(edgesToRegular[0].sourceHandle).toBe('parallel_exit')
 
+        const edgesToParallelStart = Array.from(parallelEndNode.outgoingEdges.values()).filter(
+          (e) => e.target === parallelSentinelStart
+        )
+        expect(edgesToParallelStart.length).toBe(1)
+        expect(edgesToParallelStart[0].sourceHandle).toBe('parallel_continue')
+
+        const parallelStartNode = dag.nodes.get(parallelSentinelStart)!
+        expect(parallelStartNode.incomingEdges.has(parallelSentinelEnd)).toBe(false)
+
         const regularBlockNode = dag.nodes.get(regularBlockId)!
         expect(regularBlockNode.incomingEdges.has(parallelSentinelEnd)).toBe(true)
       })
@@ -1356,31 +1493,32 @@ describe('EdgeConstructor', () => {
       // Set up sentinel metadata
       dag.nodes.get(outerSentinelStart)!.metadata = {
         isSentinel: true,
-        isParallelSentinel: true,
         sentinelType: 'start',
-        parallelId: outerParallelId,
+        subflowId: outerParallelId,
+        subflowType: 'parallel',
       }
       dag.nodes.get(outerSentinelEnd)!.metadata = {
         isSentinel: true,
-        isParallelSentinel: true,
         sentinelType: 'end',
-        parallelId: outerParallelId,
+        subflowId: outerParallelId,
+        subflowType: 'parallel',
       }
       dag.nodes.get(innerSentinelStart)!.metadata = {
         isSentinel: true,
-        isParallelSentinel: true,
         sentinelType: 'start',
-        parallelId: innerParallelId,
+        subflowId: innerParallelId,
+        subflowType: 'parallel',
       }
       dag.nodes.get(innerSentinelEnd)!.metadata = {
         isSentinel: true,
-        isParallelSentinel: true,
         sentinelType: 'end',
-        parallelId: innerParallelId,
+        subflowId: innerParallelId,
+        subflowType: 'parallel',
       }
       dag.nodes.get(funcTemplate)!.metadata = {
         isParallelBranch: true,
-        parallelId: innerParallelId,
+        subflowId: innerParallelId,
+        subflowType: 'parallel',
         branchIndex: 0,
         branchTotal: 1,
         originalBlockId: functionId,
@@ -1478,28 +1616,31 @@ describe('EdgeConstructor', () => {
       dag.nodes.get(loopSentinelStart)!.metadata = {
         isSentinel: true,
         sentinelType: 'start',
-        loopId,
+        subflowId: loopId,
+        subflowType: 'loop',
       }
       dag.nodes.get(loopSentinelEnd)!.metadata = {
         isSentinel: true,
         sentinelType: 'end',
-        loopId,
+        subflowId: loopId,
+        subflowType: 'loop',
       }
       dag.nodes.get(parallelSentinelStart)!.metadata = {
         isSentinel: true,
-        isParallelSentinel: true,
         sentinelType: 'start',
-        parallelId: innerParallelId,
+        subflowId: innerParallelId,
+        subflowType: 'parallel',
       }
       dag.nodes.get(parallelSentinelEnd)!.metadata = {
         isSentinel: true,
-        isParallelSentinel: true,
         sentinelType: 'end',
-        parallelId: innerParallelId,
+        subflowId: innerParallelId,
+        subflowType: 'parallel',
       }
       dag.nodes.get(funcTemplate)!.metadata = {
         isParallelBranch: true,
-        parallelId: innerParallelId,
+        subflowId: innerParallelId,
+        subflowType: 'parallel',
         branchIndex: 0,
         branchTotal: 1,
         originalBlockId: functionId,
@@ -1592,25 +1733,27 @@ describe('EdgeConstructor', () => {
 
       dag.nodes.get(outerSentinelStart)!.metadata = {
         isSentinel: true,
-        isParallelSentinel: true,
         sentinelType: 'start',
-        parallelId: outerParallelId,
+        subflowId: outerParallelId,
+        subflowType: 'parallel',
       }
       dag.nodes.get(outerSentinelEnd)!.metadata = {
         isSentinel: true,
-        isParallelSentinel: true,
         sentinelType: 'end',
-        parallelId: outerParallelId,
+        subflowId: outerParallelId,
+        subflowType: 'parallel',
       }
       dag.nodes.get(innerSentinelStart)!.metadata = {
         isSentinel: true,
         sentinelType: 'start',
-        loopId: innerLoopId,
+        subflowId: innerLoopId,
+        subflowType: 'loop',
       }
       dag.nodes.get(innerSentinelEnd)!.metadata = {
         isSentinel: true,
         sentinelType: 'end',
-        loopId: innerLoopId,
+        subflowId: innerLoopId,
+        subflowType: 'loop',
       }
 
       const innerLoop: SerializedLoop = {
diff --git a/apps/sim/executor/dag/construction/edges.ts b/apps/sim/executor/dag/construction/edges.ts
index 9e9c4a567fc..018c1b79251 100644
--- a/apps/sim/executor/dag/construction/edges.ts
+++ b/apps/sim/executor/dag/construction/edges.ts
@@ -1,6 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
 import {
+  CONTROL_BACK_EDGE_HANDLES,
   EDGE,
   isConditionBlockType,
   isRouterBlockType,
@@ -222,16 +223,28 @@ export class EdgeConstructor {
       const sourceIsParallelBlock = parallelBlockIds.has(source)
       const targetIsParallelBlock = parallelBlockIds.has(target)
 
-      let loopSentinelStartId: string | undefined
+      if (this.edgeStaysWithinSameParallel(originalSource, originalTarget, dag)) {
+        const sourceId = this.resolveSubflowToSentinelEnd(originalSource, dag)
+        const targetId = this.resolveSubflowToSentinelStart(originalTarget, dag)
+        const resolvedSourceHandle = this.resolveParallelChildSourceHandle(
+          originalSource,
+          dag,
+          sourceHandle
+        )
+        this.addEdge(dag, sourceId, targetId, resolvedSourceHandle, targetHandle)
+        this.addSubflowStartExitBypass(dag, originalSource)
+        continue
+      }
 
       if (sourceIsLoopBlock) {
         const sentinelEndId = buildSentinelEndId(originalSource)
-        loopSentinelStartId = buildSentinelStartId(originalSource)
+        const loopSentinelStartId = buildSentinelStartId(originalSource)
         if (!dag.nodes.has(sentinelEndId) || !dag.nodes.has(loopSentinelStartId)) {
           continue
         }
         source = sentinelEndId
         sourceHandle = EDGE.LOOP_EXIT
+        this.addSubflowStartExitBypass(dag, originalSource)
       }
 
       if (targetIsLoopBlock) {
@@ -264,13 +277,12 @@ export class EdgeConstructor {
         target = sentinelStartId
       }
 
-      if (this.edgeCrossesLoopBoundary(originalSource, originalTarget, blocksInLoops, dag)) {
-        continue
+      if (sourceIsParallelBlock) {
+        this.addSubflowStartExitBypass(dag, originalSource)
       }
 
-      const sourceLoopNodes = dag.loopConfigs.get(originalSource)?.nodes
-      if (loopSentinelStartId && !sourceLoopNodes?.includes(originalTarget)) {
-        this.addEdge(dag, loopSentinelStartId, target, EDGE.LOOP_EXIT, targetHandle)
+      if (this.edgeCrossesLoopBoundary(originalSource, originalTarget, blocksInLoops, dag)) {
+        continue
       }
 
       if (!this.isEdgeReachable(source, target, reachableBlocks, dag)) {
@@ -308,6 +320,8 @@ export class EdgeConstructor {
         continue
       }
 
+      this.addSubflowStartExitBypass(dag, loopId)
+
       const { startNodes, terminalNodes } = this.findLoopBoundaryNodes(nodes, dag)
 
       for (const startNodeId of startNodes) {
@@ -326,12 +340,15 @@ export class EdgeConstructor {
             ? EDGE.PARALLEL_EXIT
             : EDGE.LOOP_EXIT
           this.addEdge(dag, resolvedId, sentinelEndId, handle)
+          this.addSubflowStartExitBypass(dag, terminalNodeId)
         } else {
           this.addEdge(dag, resolvedId, sentinelEndId)
         }
       }
 
-      this.addEdge(dag, sentinelEndId, sentinelStartId, EDGE.LOOP_CONTINUE, undefined, true)
+      this.addEdge(dag, sentinelEndId, sentinelStartId, EDGE.LOOP_CONTINUE, undefined, {
+        registerIncoming: false,
+      })
     }
   }
 
@@ -348,6 +365,8 @@ export class EdgeConstructor {
         continue
       }
 
+      this.addSubflowStartExitBypass(dag, parallelId)
+
       const { entryNodes, terminalNodes } = this.findParallelBoundaryNodes(nodes, dag)
 
       for (const entryNodeId of entryNodes) {
@@ -360,12 +379,17 @@ export class EdgeConstructor {
       for (const terminalNodeId of terminalNodes) {
         const sourceId = this.resolveSubflowToSentinelEnd(terminalNodeId, dag)
         if (dag.nodes.has(sourceId)) {
-          // Use the sourceHandle that matches the nested subflow's exit route.
-          // A nested loop sentinel-end outputs "loop_exit", not "parallel_exit".
-          const handle = dag.loopConfigs.has(terminalNodeId) ? EDGE.LOOP_EXIT : EDGE.PARALLEL_EXIT
+          const handle = this.resolveSubflowExitHandle(terminalNodeId, dag)
           this.addEdge(dag, sourceId, sentinelEndId, handle)
+          if (handle) {
+            this.addSubflowStartExitBypass(dag, terminalNodeId)
+          }
         }
       }
+
+      this.addEdge(dag, sentinelEndId, sentinelStartId, EDGE.PARALLEL_CONTINUE, undefined, {
+        registerIncoming: false,
+      })
     }
   }
 
@@ -566,9 +590,7 @@ export class EdgeConstructor {
 
       let hasOutgoingToLoop = false
       for (const [, edge] of node.outgoingEdges) {
-        const isBackEdge =
-          edge.sourceHandle === EDGE.LOOP_CONTINUE || edge.sourceHandle === EDGE.LOOP_CONTINUE_ALT
-        if (isBackEdge) continue
+        if (this.isControlBackEdge(edge.sourceHandle)) continue
 
         if (effectiveNodeSet.has(edge.target)) {
           hasOutgoingToLoop = true
@@ -620,10 +642,7 @@ export class EdgeConstructor {
       if (endNode) {
         let hasOutgoingToParallel = false
         for (const [, edge] of endNode.outgoingEdges) {
-          // Skip loop back-edges — they don't count as forward edges within the parallel
-          const isBackEdge =
-            edge.sourceHandle === EDGE.LOOP_CONTINUE || edge.sourceHandle === EDGE.LOOP_CONTINUE_ALT
-          if (isBackEdge) continue
+          if (this.isControlBackEdge(edge.sourceHandle)) continue
 
           const originalTargetId = normalizeNodeId(edge.target)
           if (nodesSet.has(originalTargetId)) {
@@ -667,6 +686,10 @@ export class EdgeConstructor {
     return { startNode: templateNode, endNode: templateNode }
   }
 
+  private isControlBackEdge(sourceHandle?: string): boolean {
+    return sourceHandle !== undefined && CONTROL_BACK_EDGE_HANDLES.has(sourceHandle)
+  }
+
   private getParallelId(blockId: string, dag: DAG): string | null {
     for (const [parallelId, parallelConfig] of dag.parallelConfigs) {
       if (parallelConfig.nodes.includes(blockId)) {
@@ -676,13 +699,66 @@ export class EdgeConstructor {
     return null
   }
 
+  private edgeStaysWithinSameParallel(source: string, target: string, dag: DAG): boolean {
+    const sourceParallelId = this.getParallelId(source, dag)
+    const targetParallelId = this.getParallelId(target, dag)
+    return !!sourceParallelId && sourceParallelId === targetParallelId
+  }
+
+  private resolveParallelChildSourceHandle(
+    source: string,
+    dag: DAG,
+    sourceHandle?: string
+  ): string | undefined {
+    if (dag.parallelConfigs.has(source)) {
+      return EDGE.PARALLEL_EXIT
+    }
+    if (dag.loopConfigs.has(source)) {
+      return EDGE.LOOP_EXIT
+    }
+    return sourceHandle
+  }
+
+  private resolveSubflowExitHandle(nodeId: string, dag: DAG): string | undefined {
+    if (dag.parallelConfigs.has(nodeId)) {
+      return EDGE.PARALLEL_EXIT
+    }
+    if (dag.loopConfigs.has(nodeId)) {
+      return EDGE.LOOP_EXIT
+    }
+    return undefined
+  }
+
+  private addSubflowStartExitBypass(dag: DAG, subflowId: string): void {
+    if (dag.parallelConfigs.has(subflowId)) {
+      const sourceId = buildParallelSentinelStartId(subflowId)
+      const targetId = buildParallelSentinelEndId(subflowId)
+      if (dag.nodes.has(sourceId) && dag.nodes.has(targetId)) {
+        this.addEdge(dag, sourceId, targetId, EDGE.PARALLEL_EXIT, undefined, {
+          registerIncoming: false,
+        })
+      }
+      return
+    }
+
+    if (dag.loopConfigs.has(subflowId)) {
+      const sourceId = buildSentinelStartId(subflowId)
+      const targetId = buildSentinelEndId(subflowId)
+      if (dag.nodes.has(sourceId) && dag.nodes.has(targetId)) {
+        this.addEdge(dag, sourceId, targetId, EDGE.LOOP_EXIT, undefined, {
+          registerIncoming: false,
+        })
+      }
+    }
+  }
+
   private addEdge(
     dag: DAG,
     sourceId: string,
     targetId: string,
     sourceHandle?: string,
     targetHandle?: string,
-    isLoopBackEdge = false
+    options: { registerIncoming?: boolean } = {}
   ): void {
     const sourceNode = dag.nodes.get(sourceId)
     const targetNode = dag.nodes.get(targetId)
@@ -698,10 +774,10 @@ export class EdgeConstructor {
       target: targetId,
       sourceHandle,
       targetHandle,
-      isActive: isLoopBackEdge ? false : undefined,
     })
 
-    if (!isLoopBackEdge) {
+    const { registerIncoming = true } = options
+    if (registerIncoming) {
       targetNode.incomingEdges.add(sourceId)
     }
   }
diff --git a/apps/sim/executor/dag/construction/loops.ts b/apps/sim/executor/dag/construction/loops.ts
index cb9715c90d8..87388b34519 100644
--- a/apps/sim/executor/dag/construction/loops.ts
+++ b/apps/sim/executor/dag/construction/loops.ts
@@ -1,10 +1,8 @@
-import { createLogger } from '@sim/logger'
-import { BlockType, LOOP, type SentinelType } from '@/executor/constants'
-import type { DAG, DAGNode } from '@/executor/dag/builder'
+import { BlockType, LOOP } from '@/executor/constants'
+import type { DAG } from '@/executor/dag/builder'
+import { createSubflowSentinelNode } from '@/executor/dag/construction/sentinels'
 import { buildSentinelEndId, buildSentinelStartId } from '@/executor/utils/subflow-utils'
 
-const logger = createLogger('LoopConstructor')
-
 export class LoopConstructor {
   execute(dag: DAG, reachableBlocks: Set<string>): void {
     for (const [loopId, loopConfig] of dag.loopConfigs) {
@@ -29,9 +27,10 @@ export class LoopConstructor {
 
     dag.nodes.set(
       startId,
-      this.createSentinelNode({
+      createSubflowSentinelNode({
         id: startId,
-        loopId,
+        subflowId: loopId,
+        subflowType: 'loop',
         sentinelType: LOOP.SENTINEL.START_TYPE,
         blockType: BlockType.SENTINEL_START,
         name: `${LOOP.SENTINEL.START_NAME_PREFIX} (${loopId})`,
@@ -40,42 +39,14 @@ export class LoopConstructor {
 
     dag.nodes.set(
       endId,
-      this.createSentinelNode({
+      createSubflowSentinelNode({
         id: endId,
-        loopId,
+        subflowId: loopId,
+        subflowType: 'loop',
         sentinelType: LOOP.SENTINEL.END_TYPE,
         blockType: BlockType.SENTINEL_END,
         name: `${LOOP.SENTINEL.END_NAME_PREFIX} (${loopId})`,
       })
     )
   }
-
-  private createSentinelNode(config: {
-    id: string
-    loopId: string
-    sentinelType: SentinelType
-    blockType: BlockType
-    name: string
-  }): DAGNode {
-    return {
-      id: config.id,
-      block: {
-        id: config.id,
-        enabled: true,
-        metadata: {
-          id: config.blockType,
-          name: config.name,
-          loopId: config.loopId,
-        },
-        config: { params: {} },
-      } as any,
-      incomingEdges: new Set(),
-      outgoingEdges: new Map(),
-      metadata: {
-        isSentinel: true,
-        sentinelType: config.sentinelType,
-        loopId: config.loopId,
-      },
-    }
-  }
 }
diff --git a/apps/sim/executor/dag/construction/nodes.test.ts b/apps/sim/executor/dag/construction/nodes.test.ts
new file mode 100644
index 00000000000..e1f47ed23bc
--- /dev/null
+++ b/apps/sim/executor/dag/construction/nodes.test.ts
@@ -0,0 +1,46 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { BlockType } from '@/executor/constants'
+import type { DAG } from '@/executor/dag/builder'
+import { NodeConstructor } from '@/executor/dag/construction/nodes'
+import type { SerializedWorkflow } from '@/serializer/types'
+
+describe('NodeConstructor', () => {
+  it('assigns nested loop nodes to the innermost loop metadata', () => {
+    const dag: DAG = {
+      nodes: new Map(),
+      loopConfigs: new Map([
+        ['outer-loop', { id: 'outer-loop', nodes: ['inner-loop', 'task'], iterations: 1 }],
+        ['inner-loop', { id: 'inner-loop', nodes: ['task'], iterations: 1 }],
+      ]),
+      parallelConfigs: new Map(),
+    }
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [
+        {
+          id: 'task',
+          position: { x: 0, y: 0 },
+          config: { tool: '', params: {} },
+          inputs: {},
+          outputs: {},
+          metadata: { id: BlockType.FUNCTION, name: 'Task' },
+          enabled: true,
+        },
+      ],
+      connections: [],
+      loops: {},
+      parallels: {},
+    }
+
+    new NodeConstructor().execute(workflow, dag, new Set(['task']))
+
+    expect(dag.nodes.get('task')?.metadata).toMatchObject({
+      isLoopNode: true,
+      subflowId: 'inner-loop',
+      subflowType: 'loop',
+    })
+  })
+})
diff --git a/apps/sim/executor/dag/construction/nodes.ts b/apps/sim/executor/dag/construction/nodes.ts
index 42c575600c9..a8ac2284826 100644
--- a/apps/sim/executor/dag/construction/nodes.ts
+++ b/apps/sim/executor/dag/construction/nodes.ts
@@ -104,7 +104,8 @@ export class NodeConstructor {
       outgoingEdges: new Map(),
       metadata: {
         isParallelBranch: true,
-        parallelId,
+        subflowId: parallelId,
+        subflowType: 'parallel',
         branchIndex: 0,
         branchTotal: 1,
         isPauseResponse: block.metadata?.id === BlockType.HUMAN_IN_THE_LOOP,
@@ -129,7 +130,7 @@ export class NodeConstructor {
       outgoingEdges: new Map(),
       metadata: {
         isLoopNode,
-        loopId,
+        ...(loopId && { subflowId: loopId, subflowType: 'loop' as const }),
         isPauseResponse: isPauseBlock,
         originalBlockId: block.id,
       },
@@ -137,12 +138,21 @@ export class NodeConstructor {
   }
 
   private findLoopIdForBlock(blockId: string, dag: DAG): string | undefined {
+    const candidates: string[] = []
     for (const [loopId, loopConfig] of dag.loopConfigs) {
       if (loopConfig.nodes.includes(blockId)) {
-        return loopId
+        candidates.push(loopId)
       }
     }
-    return undefined
+    if (candidates.length <= 1) return candidates[0]
+
+    return candidates.find((candidateId) =>
+      candidates.every((otherId) => {
+        if (otherId === candidateId) return true
+        const candidateConfig = dag.loopConfigs.get(candidateId)
+        return !candidateConfig?.nodes.includes(otherId)
+      })
+    )
   }
 
   private findParallelForBlock(blockId: string, dag: DAG): string | null {
diff --git a/apps/sim/executor/dag/construction/parallels.ts b/apps/sim/executor/dag/construction/parallels.ts
index ac4b6ea5d84..0f8bc9918f4 100644
--- a/apps/sim/executor/dag/construction/parallels.ts
+++ b/apps/sim/executor/dag/construction/parallels.ts
@@ -1,13 +1,11 @@
-import { createLogger } from '@sim/logger'
-import { BlockType, PARALLEL, type SentinelType } from '@/executor/constants'
-import type { DAG, DAGNode } from '@/executor/dag/builder'
+import { BlockType, PARALLEL } from '@/executor/constants'
+import type { DAG } from '@/executor/dag/builder'
+import { createSubflowSentinelNode } from '@/executor/dag/construction/sentinels'
 import {
   buildParallelSentinelEndId,
   buildParallelSentinelStartId,
 } from '@/executor/utils/subflow-utils'
 
-const logger = createLogger('ParallelConstructor')
-
 export class ParallelConstructor {
   execute(dag: DAG, reachableBlocks: Set<string>): void {
     for (const [parallelId, parallelConfig] of dag.parallelConfigs) {
@@ -32,9 +30,10 @@ export class ParallelConstructor {
 
     dag.nodes.set(
       startId,
-      this.createSentinelNode({
+      createSubflowSentinelNode({
         id: startId,
-        parallelId,
+        subflowId: parallelId,
+        subflowType: 'parallel',
         sentinelType: PARALLEL.SENTINEL.START_TYPE,
         blockType: BlockType.SENTINEL_START,
         name: `${PARALLEL.SENTINEL.START_NAME_PREFIX} (${parallelId})`,
@@ -43,43 +42,14 @@ export class ParallelConstructor {
 
     dag.nodes.set(
       endId,
-      this.createSentinelNode({
+      createSubflowSentinelNode({
         id: endId,
-        parallelId,
+        subflowId: parallelId,
+        subflowType: 'parallel',
         sentinelType: PARALLEL.SENTINEL.END_TYPE,
         blockType: BlockType.SENTINEL_END,
         name: `${PARALLEL.SENTINEL.END_NAME_PREFIX} (${parallelId})`,
       })
     )
   }
-
-  private createSentinelNode(config: {
-    id: string
-    parallelId: string
-    sentinelType: SentinelType
-    blockType: BlockType
-    name: string
-  }): DAGNode {
-    return {
-      id: config.id,
-      block: {
-        id: config.id,
-        enabled: true,
-        metadata: {
-          id: config.blockType,
-          name: config.name,
-          parallelId: config.parallelId,
-        },
-        config: { params: {} },
-      } as any,
-      incomingEdges: new Set(),
-      outgoingEdges: new Map(),
-      metadata: {
-        isSentinel: true,
-        isParallelSentinel: true,
-        sentinelType: config.sentinelType,
-        parallelId: config.parallelId,
-      },
-    }
-  }
 }
diff --git a/apps/sim/executor/dag/construction/sentinels.ts b/apps/sim/executor/dag/construction/sentinels.ts
new file mode 100644
index 00000000000..fc37a7f9a5d
--- /dev/null
+++ b/apps/sim/executor/dag/construction/sentinels.ts
@@ -0,0 +1,38 @@
+import type { BlockType, SentinelType } from '@/executor/constants'
+import type { DAGNode } from '@/executor/dag/builder'
+import type { SentinelSubflowType } from '@/executor/dag/types'
+
+interface SubflowSentinelNodeConfig {
+  id: string
+  subflowId: string
+  subflowType: SentinelSubflowType
+  sentinelType: SentinelType
+  blockType: BlockType
+  name: string
+}
+
+export function createSubflowSentinelNode(config: SubflowSentinelNodeConfig): DAGNode {
+  return {
+    id: config.id,
+    block: {
+      id: config.id,
+      enabled: true,
+      position: { x: 0, y: 0 },
+      metadata: {
+        id: config.blockType,
+        name: config.name,
+      },
+      config: { tool: config.blockType, params: {} },
+      inputs: {},
+      outputs: {},
+    },
+    incomingEdges: new Set(),
+    outgoingEdges: new Map(),
+    metadata: {
+      isSentinel: true,
+      sentinelType: config.sentinelType,
+      subflowId: config.subflowId,
+      subflowType: config.subflowType,
+    },
+  }
+}
diff --git a/apps/sim/executor/dag/types.ts b/apps/sim/executor/dag/types.ts
index 2bedb57f309..305ecd04c28 100644
--- a/apps/sim/executor/dag/types.ts
+++ b/apps/sim/executor/dag/types.ts
@@ -2,20 +2,20 @@ export interface DAGEdge {
   target: string
   sourceHandle?: string
   targetHandle?: string
-  isActive?: boolean
 }
 
+export type SentinelSubflowType = 'loop' | 'parallel'
+
 export interface NodeMetadata {
   isParallelBranch?: boolean
-  isParallelSentinel?: boolean
-  parallelId?: string
   branchIndex?: number
   branchTotal?: number
   distributionItem?: unknown
   isLoopNode?: boolean
-  loopId?: string
   isSentinel?: boolean
   sentinelType?: 'start' | 'end'
+  subflowType?: SentinelSubflowType
+  subflowId?: string
   isPauseResponse?: boolean
   isResumeTrigger?: boolean
   originalBlockId?: string
diff --git a/apps/sim/executor/execution/block-executor.test.ts b/apps/sim/executor/execution/block-executor.test.ts
index 5e5d130c1d3..94d291a18c5 100644
--- a/apps/sim/executor/execution/block-executor.test.ts
+++ b/apps/sim/executor/execution/block-executor.test.ts
@@ -126,4 +126,257 @@ describe('BlockExecutor', () => {
       totalCount: output.result.length,
     })
   })
+
+  it('persists stable outer-branch aliases for completed parallel branch outputs', async () => {
+    const block = createBlock()
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [block],
+      connections: [],
+      loops: {},
+      parallels: {},
+    }
+    const state = new ExecutionState()
+    const resolver = new VariableResolver(workflow, {}, state)
+    const output = { result: 'branch-2' }
+    const handler: BlockHandler = {
+      canHandle: () => true,
+      execute: async () => output,
+    }
+    const executor = new BlockExecutor(
+      [handler],
+      resolver,
+      {
+        workspaceId: 'workspace-1',
+        executionId: 'execution-1',
+        userId: 'user-1',
+        metadata: {
+          requestId: 'request-1',
+          executionId: 'execution-1',
+          workflowId: 'workflow-1',
+          workspaceId: 'workspace-1',
+          userId: 'user-1',
+          triggerType: 'manual',
+          useDraftState: false,
+          startTime: new Date().toISOString(),
+        },
+      },
+      state
+    )
+    const node = createNode(block)
+    node.id = 'function-block-1₍0₎'
+    node.metadata = {
+      isParallelBranch: true,
+      subflowId: 'parallel-1',
+      subflowType: 'parallel',
+      originalBlockId: block.id,
+      branchIndex: 2,
+    }
+
+    await executor.execute(createContext(state), node, block)
+
+    expect(state.getBlockOutput('function-block-1__obranch-2')).toEqual(output)
+    expect(state.getBlockOutput('function-block-1₍2₎')).toEqual(output)
+    expect(state.getBlockOutput('function-block-1₍0₎')).toEqual(output)
+  })
+
+  it('does not write global aliases for parallel branches inside cloned outer branches', async () => {
+    const block = createBlock()
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [block],
+      connections: [],
+      loops: {},
+      parallels: {},
+    }
+    const state = new ExecutionState()
+    const resolver = new VariableResolver(workflow, {}, state)
+    const output = { result: 'outer-2-inner-0' }
+    const handler: BlockHandler = {
+      canHandle: () => true,
+      execute: async () => output,
+    }
+    const executor = new BlockExecutor(
+      [handler],
+      resolver,
+      {
+        workspaceId: 'workspace-1',
+        executionId: 'execution-1',
+        userId: 'user-1',
+        metadata: {
+          requestId: 'request-1',
+          executionId: 'execution-1',
+          workflowId: 'workflow-1',
+          workspaceId: 'workspace-1',
+          userId: 'user-1',
+          triggerType: 'manual',
+          useDraftState: false,
+          startTime: new Date().toISOString(),
+        },
+      },
+      state
+    )
+    const node = createNode(block)
+    node.id = 'function-block-1__cloneabc__obranch-2₍0₎'
+    node.metadata = {
+      isParallelBranch: true,
+      subflowId: 'inner-parallel',
+      subflowType: 'parallel',
+      originalBlockId: block.id,
+      branchIndex: 0,
+    }
+
+    await executor.execute(createContext(state), node, block)
+
+    expect(state.getBlockOutput(node.id)).toEqual(output)
+    expect(state.getBlockOutput('function-block-1__obranch-0')).toBeUndefined()
+    expect(state.getBlockOutput('function-block-1₍0₎')).toBeUndefined()
+  })
+
+  it('does not let block completion callbacks overtake pending start callbacks', async () => {
+    const block = createBlock()
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [block],
+      connections: [],
+      loops: {},
+      parallels: {},
+    }
+    const state = new ExecutionState()
+    const resolver = new VariableResolver(workflow, {}, state)
+    const output = { result: 'done' }
+    const execute = vi.fn(async () => {
+      events.push('execute')
+      return output
+    })
+    const handler: BlockHandler = {
+      canHandle: () => true,
+      execute,
+    }
+
+    const events: string[] = []
+    let resolveStart!: () => void
+    const startGate = new Promise<void>((resolve) => {
+      resolveStart = resolve
+    })
+    const onBlockStart = vi.fn(async () => {
+      events.push('start-called')
+      await startGate
+      events.push('start-done')
+    })
+    const onBlockComplete = vi.fn(async () => {
+      events.push('complete')
+    })
+
+    const executor = new BlockExecutor(
+      [handler],
+      resolver,
+      {
+        workspaceId: 'workspace-1',
+        executionId: 'execution-1',
+        userId: 'user-1',
+        metadata: {
+          requestId: 'request-1',
+          executionId: 'execution-1',
+          workflowId: 'workflow-1',
+          workspaceId: 'workspace-1',
+          userId: 'user-1',
+          triggerType: 'manual',
+          useDraftState: false,
+          startTime: new Date().toISOString(),
+        },
+        onBlockStart,
+        onBlockComplete,
+      },
+      state
+    )
+
+    const execution = executor.execute(createContext(state), createNode(block), block)
+
+    expect(onBlockStart).toHaveBeenCalled()
+    expect(execute).not.toHaveBeenCalled()
+    expect(onBlockComplete).not.toHaveBeenCalled()
+
+    resolveStart()
+
+    await execution
+    await vi.waitFor(() => {
+      expect(onBlockComplete).toHaveBeenCalled()
+    })
+    expect(events).toEqual(['start-called', 'start-done', 'execute', 'complete'])
+  })
+
+  it('fires block completion callbacks for pausing blocks so clients receive pause output', async () => {
+    const block = {
+      ...createBlock(),
+      id: 'hitl-block-1',
+      metadata: { id: BlockType.HUMAN_IN_THE_LOOP, name: 'Human in the Loop' },
+      config: { tool: BlockType.HUMAN_IN_THE_LOOP, params: {} },
+    }
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [block],
+      connections: [],
+      loops: {},
+      parallels: {},
+    }
+    const state = new ExecutionState()
+    const resolver = new VariableResolver(workflow, {}, state)
+    const output = {
+      response: { status: 'paused' },
+      _pauseMetadata: {
+        contextId: 'pause-context-1',
+        blockId: block.id,
+        response: { status: 'paused' },
+        timestamp: new Date().toISOString(),
+        pauseKind: 'human' as const,
+      },
+    }
+    const handler: BlockHandler = {
+      canHandle: () => true,
+      execute: async () => output,
+    }
+    const onBlockStart = vi.fn(async () => {})
+    const onBlockComplete = vi.fn(async () => {})
+
+    const executor = new BlockExecutor(
+      [handler],
+      resolver,
+      {
+        workspaceId: 'workspace-1',
+        executionId: 'execution-1',
+        userId: 'user-1',
+        metadata: {
+          requestId: 'request-1',
+          executionId: 'execution-1',
+          workflowId: 'workflow-1',
+          workspaceId: 'workspace-1',
+          userId: 'user-1',
+          triggerType: 'manual',
+          useDraftState: false,
+          startTime: new Date().toISOString(),
+        },
+        onBlockStart,
+        onBlockComplete,
+      },
+      state
+    )
+
+    await executor.execute(createContext(state), createNode(block), block)
+
+    expect(onBlockStart).toHaveBeenCalled()
+    expect(onBlockComplete).toHaveBeenCalledWith(
+      block.id,
+      'Human in the Loop',
+      BlockType.HUMAN_IN_THE_LOOP,
+      expect.objectContaining({
+        output: expect.objectContaining({
+          response: { status: 'paused' },
+        }),
+      }),
+      undefined,
+      undefined
+    )
+    expect(state.getBlockOutput(block.id)).toEqual(output)
+  })
 })
diff --git a/apps/sim/executor/execution/block-executor.ts b/apps/sim/executor/execution/block-executor.ts
index 88aa9b20461..0fdd6be1530 100644
--- a/apps/sim/executor/execution/block-executor.ts
+++ b/apps/sim/executor/execution/block-executor.ts
@@ -46,6 +46,11 @@ import {
 } from '@/executor/utils/iteration-context'
 import { isJSONString } from '@/executor/utils/json'
 import { filterOutputForLog } from '@/executor/utils/output-filter'
+import {
+  buildBranchNodeId,
+  buildOuterBranchScopedId,
+  extractOuterBranchIndex,
+} from '@/executor/utils/subflow-utils'
 import {
   FUNCTION_BLOCK_CONTEXT_VARS_KEY,
   FUNCTION_BLOCK_DISPLAY_CODE_KEY,
@@ -98,10 +103,12 @@ export class BlockExecutor {
     const startTime = performance.now()
 
     let blockLog: BlockLog | undefined
+    let blockStartPromise: Promise<void> | undefined
     if (!isSentinel) {
       blockLog = this.createBlockLog(ctx, node.id, block, node, startedAt)
       ctx.blockLogs.push(blockLog)
-      this.fireBlockStartCallback(ctx, node, block, blockLog.executionOrder)
+      blockStartPromise = this.fireBlockStartCallback(ctx, node, block, blockLog.executionOrder)
+      await blockStartPromise
     }
 
     let resolvedInputs: Record<string, any> = {}
@@ -156,6 +163,7 @@ export class BlockExecutor {
         ctx,
         node,
         block,
+        blockStartPromise,
         startTime,
         blockLog,
         inputsForLog,
@@ -234,7 +242,7 @@ export class BlockExecutor {
       }
 
       const { childTraceSpans: _traces, ...outputForState } = normalizedOutput
-      this.state.setBlockOutput(node.id, outputForState as NormalizedBlockOutput, duration)
+      this.setNodeOutput(node, outputForState as NormalizedBlockOutput, duration)
 
       if (!isSentinel && blockLog) {
         const childWorkflowInstanceId =
@@ -245,6 +253,7 @@ export class BlockExecutor {
           block,
         })
         this.fireBlockCompleteCallback(
+          blockStartPromise,
           ctx,
           node,
           block,
@@ -265,6 +274,7 @@ export class BlockExecutor {
         ctx,
         node,
         block,
+        blockStartPromise,
         startTime,
         blockLog,
         inputsForLog,
@@ -278,8 +288,10 @@ export class BlockExecutor {
     const metadata = node?.metadata ?? {}
     return {
       nodeId: node.id,
-      loopId: metadata.loopId,
-      parallelId: metadata.parallelId,
+      loopId: metadata.subflowType === 'loop' ? metadata.subflowId : undefined,
+      parallelId: metadata.subflowType === 'parallel' ? metadata.subflowId : undefined,
+      subflowId: metadata.subflowId,
+      subflowType: metadata.subflowType,
       branchIndex: metadata.branchIndex,
       branchTotal: metadata.branchTotal,
       originalBlockId: metadata.originalBlockId,
@@ -287,6 +299,29 @@ export class BlockExecutor {
     }
   }
 
+  private setNodeOutput(node: DAGNode, output: NormalizedBlockOutput, duration = 0): void {
+    this.state.setBlockOutput(node.id, output, duration)
+
+    const originalBlockId = node.metadata.originalBlockId
+    const branchIndex = node.metadata.branchIndex
+    if (
+      node.metadata.isParallelBranch &&
+      originalBlockId &&
+      branchIndex !== undefined &&
+      extractOuterBranchIndex(node.id) === undefined
+    ) {
+      const globalBranchNodeId = buildBranchNodeId(originalBlockId, branchIndex)
+      if (globalBranchNodeId !== node.id) {
+        this.state.setBlockOutput(globalBranchNodeId, output, duration)
+      }
+      this.state.setBlockOutput(
+        buildOuterBranchScopedId(originalBlockId, branchIndex),
+        output,
+        duration
+      )
+    }
+  }
+
   private findHandler(block: SerializedBlock): BlockHandler | undefined {
     return this.blockHandlers.find((h) => h.canHandle(block))
   }
@@ -296,6 +331,7 @@ export class BlockExecutor {
     ctx: ExecutionContext,
     node: DAGNode,
     block: SerializedBlock,
+    blockStartPromise: Promise<void> | undefined,
     startTime: number,
     blockLog: BlockLog | undefined,
     inputsForLog: Record<string, any>,
@@ -322,7 +358,7 @@ export class BlockExecutor {
       }
     }
 
-    this.state.setBlockOutput(node.id, errorOutput, duration)
+    this.setNodeOutput(node, errorOutput, duration)
 
     if (blockLog) {
       blockLog.endedAt = endedAt
@@ -352,6 +388,7 @@ export class BlockExecutor {
         : undefined
       const displayOutput = filterOutputForLog(block.metadata?.id || '', errorOutput, { block })
       this.fireBlockCompleteCallback(
+        blockStartPromise,
         ctx,
         node,
         block,
@@ -412,12 +449,20 @@ export class BlockExecutor {
     let iterationIndex: number | undefined
 
     if (node?.metadata) {
-      if (node.metadata.branchIndex !== undefined && node.metadata.parallelId) {
+      if (
+        node.metadata.branchIndex !== undefined &&
+        node.metadata.subflowType === 'parallel' &&
+        node.metadata.subflowId
+      ) {
         blockName = `${blockName} (iteration ${node.metadata.branchIndex})`
         iterationIndex = node.metadata.branchIndex
-        parallelId = node.metadata.parallelId
-      } else if (node.metadata.isLoopNode && node.metadata.loopId) {
-        loopId = node.metadata.loopId
+        parallelId = node.metadata.subflowId
+      } else if (
+        node.metadata.isLoopNode &&
+        node.metadata.subflowType === 'loop' &&
+        node.metadata.subflowId
+      ) {
+        loopId = node.metadata.subflowId
         const loopScope = ctx.loopExecutions?.get(loopId)
         if (loopScope && loopScope.iteration !== undefined) {
           blockName = `${blockName} (iteration ${loopScope.iteration})`
@@ -510,23 +555,23 @@ export class BlockExecutor {
   }
 
   /**
-   * Fires the `onBlockStart` progress callback without blocking block execution.
-   * Any error is logged and swallowed so callback I/O never stalls the critical path.
+   * Fires the `onBlockStart` progress callback before block execution continues.
+   * Returning the promise lets completion callbacks preserve lifecycle ordering.
    */
   private fireBlockStartCallback(
     ctx: ExecutionContext,
     node: DAGNode,
     block: SerializedBlock,
     executionOrder: number
-  ): void {
-    if (!this.contextExtensions.onBlockStart) return
+  ): Promise<void> | undefined {
+    if (!this.contextExtensions.onBlockStart) return undefined
 
     const blockId = node.metadata?.originalBlockId ?? node.id
     const blockName = block.metadata?.name ?? blockId
     const blockType = block.metadata?.id ?? DEFAULTS.BLOCK_TYPE
     const iterationContext = getIterationContext(ctx, node?.metadata)
 
-    void this.contextExtensions
+    return this.contextExtensions
       .onBlockStart(
         blockId,
         blockName,
@@ -546,10 +591,11 @@ export class BlockExecutor {
 
   /**
    * Fires the `onBlockComplete` progress callback without blocking subsequent blocks.
-   * The callback typically performs DB writes for progress markers — awaiting it would
-   * add latency between blocks and skew wall-clock timing in the trace view.
+   * Completion is chained behind the matching start callback so SSE/log consumers
+   * never observe `block:completed` before `block:started` for the same execution.
    */
   private fireBlockCompleteCallback(
+    blockStartPromise: Promise<void> | undefined,
     ctx: ExecutionContext,
     node: DAGNode,
     block: SerializedBlock,
@@ -568,8 +614,9 @@ export class BlockExecutor {
     const blockType = block.metadata?.id ?? DEFAULTS.BLOCK_TYPE
     const iterationContext = getIterationContext(ctx, node?.metadata)
 
-    void this.contextExtensions
-      .onBlockComplete(
+    void (async () => {
+      await blockStartPromise
+      await this.contextExtensions.onBlockComplete?.(
         blockId,
         blockName,
         blockType,
@@ -585,13 +632,13 @@ export class BlockExecutor {
         iterationContext,
         ctx.childWorkflowContext
       )
-      .catch((error) => {
-        this.execLogger.warn('Block completion callback failed', {
-          blockId,
-          blockType,
-          error: toError(error).message,
-        })
+    })().catch((error) => {
+      this.execLogger.warn('Block completion callback failed', {
+        blockId,
+        blockType,
+        error: toError(error).message,
       })
+    })
   }
 
   private preparePauseResumeSelfReference(
diff --git a/apps/sim/executor/execution/edge-manager.test.ts b/apps/sim/executor/execution/edge-manager.test.ts
index 13c64b043aa..d1c05122a6c 100644
--- a/apps/sim/executor/execution/edge-manager.test.ts
+++ b/apps/sim/executor/execution/edge-manager.test.ts
@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest'
+import { EDGE } from '@/executor/constants'
 import type { DAG, DAGNode } from '@/executor/dag/builder'
 import type { DAGEdge } from '@/executor/dag/types'
 import type { SerializedBlock } from '@/serializer/types'
@@ -162,6 +163,33 @@ describe('EdgeManager', () => {
     })
   })
 
+  describe('Subflow control edges', () => {
+    it('does not activate loop exit edge without matching selected route', () => {
+      const loopStartId = 'loop-loop-1-sentinel-start'
+      const bodyId = 'body'
+      const afterLoopId = 'after-loop'
+      const loopStartNode = createMockNode(loopStartId, [
+        { target: bodyId },
+        { target: afterLoopId, sourceHandle: EDGE.LOOP_EXIT },
+      ])
+      const bodyNode = createMockNode(bodyId, [], [loopStartId])
+      const afterLoopNode = createMockNode(afterLoopId, [], [loopStartId])
+      const dag = createMockDAG(
+        new Map<string, DAGNode>([
+          [loopStartId, loopStartNode],
+          [bodyId, bodyNode],
+          [afterLoopId, afterLoopNode],
+        ])
+      )
+      const edgeManager = new EdgeManager(dag)
+
+      const readyNodes = edgeManager.processOutgoingEdges(loopStartNode, { sentinelStart: true })
+
+      expect(readyNodes).toContain(bodyId)
+      expect(readyNodes).not.toContain(afterLoopId)
+    })
+  })
+
   describe('Multiple condition edges to same target', () => {
     it('should not cascade-deactivate when multiple edges from same source go to same target', () => {
       const conditionId = 'condition-1'
@@ -598,6 +626,34 @@ describe('EdgeManager', () => {
       expect(readyNodes).toContain(function1Id)
     })
 
+    it('does not clear deactivated edges from prefix-sharing source node IDs', () => {
+      const shortSourceId = 'a'
+      const longSourceId = 'a-b'
+      const targetId = 'target'
+
+      const shortSourceNode = createMockNode(shortSourceId)
+      const longSourceNode = createMockNode(longSourceId, [
+        { target: targetId, sourceHandle: 'condition-if' },
+      ])
+      const targetNode = createMockNode(targetId, [], [longSourceId])
+
+      const dag = createMockDAG(
+        new Map<string, DAGNode>([
+          [shortSourceId, shortSourceNode],
+          [longSourceId, longSourceNode],
+          [targetId, targetNode],
+        ])
+      )
+      const edgeManager = new EdgeManager(dag)
+
+      edgeManager.processOutgoingEdges(longSourceNode, { selectedOption: 'else' })
+      expect(edgeManager.isNodeReady(targetNode)).toBe(true)
+
+      edgeManager.clearDeactivatedEdgesForNodes(new Set([shortSourceId]))
+
+      expect(edgeManager.isNodeReady(targetNode)).toBe(true)
+    })
+
     /**
      * Regression for the substring-match bug in clearDeactivatedEdgesForNodes.
      *
@@ -788,6 +844,37 @@ describe('EdgeManager', () => {
     })
   })
 
+  describe('restoreDeactivatedEdges', () => {
+    it('restores activated target state used by convergent routing after resume', () => {
+      const edgeManager = new EdgeManager(createMockDAG(new Map()))
+
+      edgeManager.restoreDeactivatedEdges([], ['join'])
+
+      expect(edgeManager.getNodesWithActivatedEdge()).toEqual(['join'])
+    })
+
+    it('normalizes legacy deactivated edge keys on restore', () => {
+      const sourceNode = createMockNode('source-node', [
+        { target: 'target-node', sourceHandle: 'condition-if' },
+      ])
+      const targetNode = createMockNode('target-node', [], ['source-node'])
+      const edgeManager = new EdgeManager(
+        createMockDAG(
+          new Map<string, DAGNode>([
+            [sourceNode.id, sourceNode],
+            [targetNode.id, targetNode],
+          ])
+        )
+      )
+
+      edgeManager.restoreDeactivatedEdges(['source-node-target-node-condition-if'])
+
+      expect(edgeManager.getDeactivatedEdges()).toEqual([
+        JSON.stringify(['source-node', 'target-node', 'condition-if']),
+      ])
+    })
+  })
+
   describe('Diamond pattern (convergent paths)', () => {
     it('should handle diamond: condition splits then converges at merge point', () => {
       const conditionId = 'condition-1'
@@ -1206,7 +1293,11 @@ describe('EdgeManager', () => {
       const edgeManager = new EdgeManager(dag)
 
       // Process without skipping backwards edges
-      const readyNodes = edgeManager.processOutgoingEdges(loopBodyNode, {}, false)
+      const readyNodes = edgeManager.processOutgoingEdges(
+        loopBodyNode,
+        { selectedRoute: EDGE.LOOP_CONTINUE },
+        false
+      )
 
       // Loop start should be activated
       expect(readyNodes).toContain(loopStartId)
@@ -1302,6 +1393,107 @@ describe('EdgeManager', () => {
       expect(readyNodes).not.toContain(target2Id)
       expect(readyNodes).toHaveLength(0)
     })
+
+    it('should handle no matching router route without queuing downstream sentinels', () => {
+      const routerId = 'router-1'
+      const routeTargetId = 'route-target'
+      const downstreamSentinelId = 'loop-downstream-sentinel-end'
+      const afterLoopId = 'after-loop'
+
+      const routerNode = createMockNode(routerId, [
+        { target: routeTargetId, sourceHandle: 'router-route1' },
+      ])
+      const routeTargetNode = createMockNode(
+        routeTargetId,
+        [{ target: downstreamSentinelId }],
+        [routerId]
+      )
+      const downstreamSentinelNode = createMockNode(
+        downstreamSentinelId,
+        [{ target: afterLoopId, sourceHandle: EDGE.LOOP_EXIT }],
+        [routeTargetId]
+      )
+      downstreamSentinelNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'end',
+        subflowId: 'downstream',
+        subflowType: 'loop',
+      }
+      const afterLoopNode = createMockNode(afterLoopId, [], [downstreamSentinelId])
+
+      const nodes = new Map<string, DAGNode>([
+        [routerId, routerNode],
+        [routeTargetId, routeTargetNode],
+        [downstreamSentinelId, downstreamSentinelNode],
+        [afterLoopId, afterLoopNode],
+      ])
+
+      const dag = createMockDAG(nodes)
+      const edgeManager = new EdgeManager(dag)
+      const readyNodes = edgeManager.processOutgoingEdges(routerNode, {
+        selectedRoute: 'missing-route',
+      })
+
+      expect(readyNodes).not.toContain(routeTargetId)
+      expect(readyNodes).not.toContain(downstreamSentinelId)
+      expect(readyNodes).toHaveLength(0)
+    })
+
+    it('should allow no matching router route to queue an enclosing subflow sentinel', () => {
+      const loopId = 'loop-1'
+      const routerId = 'router-1'
+      const routeTargetId = 'route-target'
+      const loopEndId = `loop-${loopId}-sentinel-end`
+      const loopStartId = `loop-${loopId}-sentinel-start`
+
+      const routerNode = createMockNode(
+        routerId,
+        [{ target: routeTargetId, sourceHandle: 'router-route1' }],
+        [loopStartId]
+      )
+      routerNode.metadata = {
+        subflowId: loopId,
+        subflowType: 'loop',
+      }
+      const routeTargetNode = createMockNode(routeTargetId, [{ target: loopEndId }], [routerId])
+      routeTargetNode.metadata = {
+        subflowId: loopId,
+        subflowType: 'loop',
+      }
+      const loopEndNode = createMockNode(
+        loopEndId,
+        [
+          { target: loopStartId, sourceHandle: EDGE.LOOP_CONTINUE },
+          { target: 'after-loop', sourceHandle: EDGE.LOOP_EXIT },
+        ],
+        [routeTargetId]
+      )
+      loopEndNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'end',
+        subflowId: loopId,
+        subflowType: 'loop',
+      }
+      const loopStartNode = createMockNode(loopStartId, [{ target: routerId }], [loopEndId])
+      const afterLoopNode = createMockNode('after-loop', [], [loopEndId])
+
+      const nodes = new Map<string, DAGNode>([
+        [routerId, routerNode],
+        [routeTargetId, routeTargetNode],
+        [loopEndId, loopEndNode],
+        [loopStartId, loopStartNode],
+        ['after-loop', afterLoopNode],
+      ])
+
+      const dag = createMockDAG(nodes)
+      const edgeManager = new EdgeManager(dag)
+      const readyNodes = edgeManager.processOutgoingEdges(routerNode, {
+        selectedRoute: 'missing-route',
+      })
+
+      expect(readyNodes).not.toContain(routeTargetId)
+      expect(readyNodes).toContain(loopEndId)
+    })
   })
 
   describe('Condition inside loop - loop control edges should not be cascade-deactivated', () => {
@@ -1430,6 +1622,35 @@ describe('EdgeManager', () => {
       expect(readyAfterParallelEnd).toContain(afterParallelId)
     })
 
+    it('should route parallel_continue back to parallel start without activating exit', () => {
+      const parallelStartId = 'parallel-start'
+      const parallelEndId = 'parallel-end'
+      const afterParallelId = 'after-parallel'
+
+      const parallelStartNode = createMockNode(parallelStartId)
+      const parallelEndNode = createMockNode(parallelEndId, [
+        { target: parallelStartId, sourceHandle: 'parallel_continue' },
+        { target: afterParallelId, sourceHandle: 'parallel_exit' },
+      ])
+      const afterParallelNode = createMockNode(afterParallelId, [], [parallelEndId])
+
+      const nodes = new Map<string, DAGNode>([
+        [parallelStartId, parallelStartNode],
+        [parallelEndId, parallelEndNode],
+        [afterParallelId, afterParallelNode],
+      ])
+
+      const dag = createMockDAG(nodes)
+      const edgeManager = new EdgeManager(dag)
+
+      const readyAfterParallelContinue = edgeManager.processOutgoingEdges(parallelEndNode, {
+        selectedRoute: 'parallel_continue',
+      })
+
+      expect(readyAfterParallelContinue).toContain(parallelStartId)
+      expect(readyAfterParallelContinue).not.toContain(afterParallelId)
+    })
+
     it('should handle condition with null selectedOption inside loop (dead-end branch)', () => {
       // When a condition selects a branch with no outgoing connection (dead-end),
       // selectedOption is null - cascade deactivation should make sentinel_end ready
@@ -1832,20 +2053,25 @@ describe('EdgeManager', () => {
       const func2Id = 'func2'
 
       const sentinelStartNode = createMockNode(sentinelStartId, [{ target: func1Id }])
-      sentinelStartNode.metadata = { isSentinel: true, sentinelType: 'start', loopId }
+      sentinelStartNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'start',
+        subflowId: loopId,
+        subflowType: 'loop',
+      }
 
       const func1Node = createMockNode(func1Id, [{ target: conditionId }], [sentinelStartId])
-      func1Node.metadata = { loopId, isLoopNode: true }
+      func1Node.metadata = { subflowId: loopId, subflowType: 'loop', isLoopNode: true }
 
       const conditionNode = createMockNode(
         conditionId,
         [{ target: func2Id, sourceHandle: 'condition-if' }],
         [func1Id]
       )
-      conditionNode.metadata = { loopId, isLoopNode: true }
+      conditionNode.metadata = { subflowId: loopId, subflowType: 'loop', isLoopNode: true }
 
       const func2Node = createMockNode(func2Id, [{ target: sentinelEndId }], [conditionId])
-      func2Node.metadata = { loopId, isLoopNode: true }
+      func2Node.metadata = { subflowId: loopId, subflowType: 'loop', isLoopNode: true }
 
       const sentinelEndNode = createMockNode(
         sentinelEndId,
@@ -1855,7 +2081,12 @@ describe('EdgeManager', () => {
         ],
         [func2Id]
       )
-      sentinelEndNode.metadata = { isSentinel: true, sentinelType: 'end', loopId }
+      sentinelEndNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'end',
+        subflowId: loopId,
+        subflowType: 'loop',
+      }
 
       const afterLoopNode = createMockNode('after-loop', [], [sentinelEndId])
 
@@ -1963,31 +2194,41 @@ describe('EdgeManager', () => {
       const funcId = 'func'
 
       const sentinelStartNode = createMockNode(sentinelStartId, [{ target: condition1Id }])
-      sentinelStartNode.metadata = { isSentinel: true, sentinelType: 'start', loopId }
+      sentinelStartNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'start',
+        subflowId: loopId,
+        subflowType: 'loop',
+      }
 
       const condition1Node = createMockNode(
         condition1Id,
         [{ target: condition2Id, sourceHandle: 'condition-if' }],
         [sentinelStartId]
       )
-      condition1Node.metadata = { loopId, isLoopNode: true }
+      condition1Node.metadata = { subflowId: loopId, subflowType: 'loop', isLoopNode: true }
 
       const condition2Node = createMockNode(
         condition2Id,
         [{ target: funcId, sourceHandle: 'condition-if' }],
         [condition1Id]
       )
-      condition2Node.metadata = { loopId, isLoopNode: true }
+      condition2Node.metadata = { subflowId: loopId, subflowType: 'loop', isLoopNode: true }
 
       const funcNode = createMockNode(funcId, [{ target: sentinelEndId }], [condition2Id])
-      funcNode.metadata = { loopId, isLoopNode: true }
+      funcNode.metadata = { subflowId: loopId, subflowType: 'loop', isLoopNode: true }
 
       const sentinelEndNode = createMockNode(
         sentinelEndId,
         [{ target: sentinelStartId, sourceHandle: 'loop_continue' }],
         [funcId]
       )
-      sentinelEndNode.metadata = { isSentinel: true, sentinelType: 'end', loopId }
+      sentinelEndNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'end',
+        subflowId: loopId,
+        subflowType: 'loop',
+      }
 
       const nodes = new Map<string, DAGNode>([
         [sentinelStartId, sentinelStartNode],
@@ -2036,34 +2277,62 @@ describe('EdgeManager', () => {
       const innerEndId = 'inner-end'
 
       const outerStartNode = createMockNode(outerStartId, [{ target: conditionId }])
-      outerStartNode.metadata = { isSentinel: true, sentinelType: 'start', loopId: outerLoopId }
+      outerStartNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'start',
+        subflowId: outerLoopId,
+        subflowType: 'loop',
+      }
 
       const conditionNode = createMockNode(
         conditionId,
         [{ target: innerStartId, sourceHandle: 'condition-if' }],
         [outerStartId]
       )
-      conditionNode.metadata = { loopId: outerLoopId, isLoopNode: true }
+      conditionNode.metadata = {
+        subflowId: outerLoopId,
+        subflowType: 'loop',
+        isLoopNode: true,
+      }
 
       const innerStartNode = createMockNode(innerStartId, [{ target: innerBodyId }], [conditionId])
-      innerStartNode.metadata = { isSentinel: true, sentinelType: 'start', loopId: innerLoopId }
+      innerStartNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'start',
+        subflowId: innerLoopId,
+        subflowType: 'loop',
+      }
 
       const innerBodyNode = createMockNode(innerBodyId, [{ target: innerEndId }], [innerStartId])
-      innerBodyNode.metadata = { loopId: innerLoopId, isLoopNode: true }
+      innerBodyNode.metadata = {
+        subflowId: innerLoopId,
+        subflowType: 'loop',
+        isLoopNode: true,
+      }
 
       const innerEndNode = createMockNode(
         innerEndId,
         [{ target: outerEndId, sourceHandle: 'loop_exit' }],
         [innerBodyId]
       )
-      innerEndNode.metadata = { isSentinel: true, sentinelType: 'end', loopId: innerLoopId }
+      innerEndNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'end',
+        subflowId: innerLoopId,
+        subflowType: 'loop',
+      }
 
       const outerEndNode = createMockNode(
         outerEndId,
         [{ target: outerStartId, sourceHandle: 'loop_continue' }],
         [innerEndId]
       )
-      outerEndNode.metadata = { isSentinel: true, sentinelType: 'end', loopId: outerLoopId }
+      outerEndNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'end',
+        subflowId: outerLoopId,
+        subflowType: 'loop',
+      }
 
       const nodes = new Map<string, DAGNode>([
         [outerStartId, outerStartNode],
diff --git a/apps/sim/executor/execution/edge-manager.ts b/apps/sim/executor/execution/edge-manager.ts
index 63a0748c8c6..86ce85f7eef 100644
--- a/apps/sim/executor/execution/edge-manager.ts
+++ b/apps/sim/executor/execution/edge-manager.ts
@@ -1,5 +1,5 @@
 import { createLogger } from '@sim/logger'
-import { EDGE } from '@/executor/constants'
+import { CONTROL_BACK_EDGE_HANDLES, EDGE, SUBFLOW_CONTROL_EDGE_HANDLES } from '@/executor/constants'
 import type { DAG, DAGNode } from '@/executor/dag/builder'
 import type { DAGEdge } from '@/executor/dag/types'
 import type { NormalizedBlockOutput } from '@/executor/types'
@@ -27,7 +27,7 @@ export class EdgeManager {
       }
 
       if (!this.shouldActivateEdge(edge, output)) {
-        if (!this.isLoopEdge(edge.sourceHandle)) {
+        if (!this.isSubflowControlEdge(edge.sourceHandle)) {
           edgesToDeactivate.push({ target: edge.target, handle: edge.sourceHandle })
         }
         continue
@@ -126,6 +126,25 @@ export class EdgeManager {
     this.nodesWithActivatedEdge.clear()
   }
 
+  getDeactivatedEdges(): string[] {
+    return Array.from(this.deactivatedEdges)
+  }
+
+  getNodesWithActivatedEdge(): string[] {
+    return Array.from(this.nodesWithActivatedEdge)
+  }
+
+  restoreDeactivatedEdges(edgeKeys?: string[], activatedNodeIds?: string[]): void {
+    this.deactivatedEdges = new Set(
+      (edgeKeys ?? []).map((edgeKey) => this.normalizeSerializedEdgeKey(edgeKey))
+    )
+    this.nodesWithActivatedEdge = new Set(activatedNodeIds ?? [])
+  }
+
+  markNodeWithActivatedEdge(nodeId: string): void {
+    this.nodesWithActivatedEdge.add(nodeId)
+  }
+
   /**
    * Clear deactivated edges for a set of nodes (used when restoring loop state for next iteration).
    *
@@ -134,15 +153,17 @@ export class EdgeManager {
    * remain deactivated — otherwise `countActiveIncomingEdges` would count a source that will never
    * fire again, stalling the loop on its next iteration.
    *
-   * Edge-key format is `${sourceId}-${targetId}-${handle}`, so `startsWith("${nodeId}-")` uniquely
-   * matches "node is source". An `includes("-${nodeId}-")` check would also match "node is target"
-   * and is unsafe for the reset semantics.
+   * Deactivated edge keys encode the source separately so node IDs with shared prefixes
+   * cannot clear each other's deactivated edges.
    */
   clearDeactivatedEdgesForNodes(nodeIds: Set<string>): void {
     const edgesToRemove: string[] = []
     for (const edgeKey of this.deactivatedEdges) {
+      const sourceId = this.parseEdgeKey(edgeKey)?.sourceId
+      if (!sourceId) continue
+
       for (const nodeId of nodeIds) {
-        if (edgeKey.startsWith(`${nodeId}-`)) {
+        if (sourceId === nodeId) {
           edgesToRemove.push(edgeKey)
           break
         }
@@ -170,37 +191,31 @@ export class EdgeManager {
     const sentinel = this.dag.nodes.get(sentinelId)
     if (!sentinel?.metadata.isSentinel) return false
 
-    const sourceLoopId = sourceNode.metadata.loopId
-    const sourceParallelId = sourceNode.metadata.parallelId
-    const sentinelLoopId = sentinel.metadata.loopId
-    const sentinelParallelId = sentinel.metadata.parallelId
+    const sourceSubflowType = sourceNode.metadata.subflowType
+    const sentinelSubflowType = sentinel.metadata.subflowType
+    const sourceSubflowId = sourceNode.metadata.subflowId
+    const sentinelSubflowId = sentinel.metadata.subflowId
 
-    if (sourceLoopId && sentinelLoopId && sourceLoopId === sentinelLoopId) return true
-    if (sourceParallelId && sentinelParallelId && sourceParallelId === sentinelParallelId)
+    if (
+      sourceSubflowType &&
+      sentinelSubflowType &&
+      sourceSubflowType === sentinelSubflowType &&
+      sourceSubflowId &&
+      sentinelSubflowId &&
+      sourceSubflowId === sentinelSubflowId
+    ) {
       return true
+    }
 
     return false
   }
 
-  private isLoopEdge(handle?: string): boolean {
-    return (
-      handle === EDGE.LOOP_CONTINUE ||
-      handle === EDGE.LOOP_CONTINUE_ALT ||
-      handle === EDGE.LOOP_EXIT
-    )
-  }
-
-  private isControlEdge(handle?: string): boolean {
-    return (
-      handle === EDGE.LOOP_CONTINUE ||
-      handle === EDGE.LOOP_CONTINUE_ALT ||
-      handle === EDGE.LOOP_EXIT ||
-      handle === EDGE.PARALLEL_EXIT
-    )
+  private isSubflowControlEdge(handle?: string): boolean {
+    return handle !== undefined && SUBFLOW_CONTROL_EDGE_HANDLES.has(handle)
   }
 
   private isBackwardsEdge(sourceHandle?: string): boolean {
-    return sourceHandle === EDGE.LOOP_CONTINUE || sourceHandle === EDGE.LOOP_CONTINUE_ALT
+    return sourceHandle !== undefined && CONTROL_BACK_EDGE_HANDLES.has(sourceHandle)
   }
 
   private isTerminalControlNode(nodeId: string): boolean {
@@ -208,7 +223,7 @@ export class EdgeManager {
     if (!node || node.outgoingEdges.size === 0) return false
 
     for (const [, edge] of node.outgoingEdges) {
-      if (!this.isControlEdge(edge.sourceHandle)) {
+      if (!this.isSubflowControlEdge(edge.sourceHandle)) {
         return false
       }
     }
@@ -231,6 +246,10 @@ export class EdgeManager {
     }
 
     if (output.selectedRoute === EDGE.PARALLEL_CONTINUE) {
+      return handle === EDGE.PARALLEL_CONTINUE
+    }
+
+    if (this.isSubflowControlEdge(handle)) {
       return false
     }
 
@@ -350,6 +369,44 @@ export class EdgeManager {
   }
 
   private createEdgeKey(sourceId: string, targetId: string, sourceHandle?: string): string {
-    return `${sourceId}-${targetId}-${sourceHandle ?? EDGE.DEFAULT}`
+    return JSON.stringify([sourceId, targetId, sourceHandle ?? EDGE.DEFAULT])
+  }
+
+  private parseEdgeKey(
+    edgeKey: string
+  ): { sourceId: string; targetId: string; handle: string } | null {
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(edgeKey)
+    } catch {
+      return null
+    }
+    if (
+      Array.isArray(parsed) &&
+      parsed.length === 3 &&
+      typeof parsed[0] === 'string' &&
+      typeof parsed[1] === 'string' &&
+      typeof parsed[2] === 'string'
+    ) {
+      return { sourceId: parsed[0], targetId: parsed[1], handle: parsed[2] }
+    }
+    return null
+  }
+
+  private normalizeSerializedEdgeKey(edgeKey: string): string {
+    if (this.parseEdgeKey(edgeKey)) {
+      return edgeKey
+    }
+
+    for (const [sourceId, sourceNode] of this.dag.nodes) {
+      for (const [, edge] of sourceNode.outgoingEdges) {
+        const legacyKey = `${sourceId}-${edge.target}-${edge.sourceHandle ?? EDGE.DEFAULT}`
+        if (legacyKey === edgeKey) {
+          return this.createEdgeKey(sourceId, edge.target, edge.sourceHandle)
+        }
+      }
+    }
+
+    return edgeKey
   }
 }
diff --git a/apps/sim/executor/execution/engine.test.ts b/apps/sim/executor/execution/engine.test.ts
index f1306a63326..b9c38ed14e7 100644
--- a/apps/sim/executor/execution/engine.test.ts
+++ b/apps/sim/executor/execution/engine.test.ts
@@ -28,6 +28,7 @@ vi.mock('@/lib/execution/cancellation', () => ({
 }))
 
 import { isExecutionCancelled, isRedisCancellationEnabled } from '@/lib/execution/cancellation'
+import { EDGE } from '@/executor/constants'
 import type { DAG, DAGNode } from '@/executor/dag/builder'
 import type { EdgeManager } from '@/executor/execution/edge-manager'
 import type { NodeExecutionOrchestrator } from '@/executor/orchestrators/node'
@@ -108,6 +109,9 @@ function createMockEdgeManager(
     restoreIncomingEdge: vi.fn(),
     clearDeactivatedEdges: vi.fn(),
     clearDeactivatedEdgesForNodes: vi.fn(),
+    getDeactivatedEdges: vi.fn(() => []),
+    getNodesWithActivatedEdge: vi.fn(() => []),
+    markNodeWithActivatedEdge: vi.fn(),
   } as unknown as MockEdgeManager
 }
 
@@ -150,7 +154,9 @@ describe('ExecutionEngine', () => {
       endNode.incomingEdges.add('start')
 
       const dag = createMockDAG([startNode, endNode])
-      const context = createMockContext()
+      const context = createMockContext({
+        decisions: { router: new Map(), condition: new Map() },
+      })
       const edgeManager = createMockEdgeManager((node) => {
         if (node.id === 'start') return ['end']
         return []
@@ -167,7 +173,9 @@ describe('ExecutionEngine', () => {
     it('should mark execution as successful when completed without cancellation', async () => {
       const startNode = createMockNode('start', 'starter')
       const dag = createMockDAG([startNode])
-      const context = createMockContext()
+      const context = createMockContext({
+        decisions: { router: new Map(), condition: new Map() },
+      })
       const edgeManager = createMockEdgeManager()
       const nodeOrchestrator = createMockNodeOrchestrator()
 
@@ -193,12 +201,36 @@ describe('ExecutionEngine', () => {
       const nodeOrchestrator = createMockNodeOrchestrator()
 
       const engine = new ExecutionEngine(context, dag, edgeManager, nodeOrchestrator)
-      const result = await engine.run()
+      const result = await engine.run('hitl')
 
       expect(result.success).toBe(true)
       expect(nodeOrchestrator.executionCount).toBe(0)
     })
 
+    it('marks resumed pause edge targets as activated before readiness checks', async () => {
+      const targetNode = createMockNode('join', 'function')
+      targetNode.incomingEdges.add('pause-block')
+      targetNode.incomingEdges.add('condition-block')
+      const dag = createMockDAG([targetNode])
+      const context = createMockContext({
+        metadata: {
+          executionId: 'test-execution',
+          startTime: new Date().toISOString(),
+          pendingBlocks: [],
+          remainingEdges: [{ source: 'pause-block', target: 'join' }],
+        } as any,
+      })
+      const edgeManager = createMockEdgeManager(() => [])
+      vi.mocked(edgeManager.isNodeReady).mockReturnValue(false)
+      const nodeOrchestrator = createMockNodeOrchestrator()
+
+      const engine = new ExecutionEngine(context, dag, edgeManager, nodeOrchestrator)
+      await engine.run()
+
+      expect(edgeManager.markNodeWithActivatedEdge).toHaveBeenCalledWith('join')
+      expect(nodeOrchestrator.executeNode).not.toHaveBeenCalled()
+    })
+
     it('should execute all nodes in a multi-node workflow', async () => {
       const nodes = [
         createMockNode('start', 'starter'),
@@ -227,6 +259,73 @@ describe('ExecutionEngine', () => {
       expect(result.success).toBe(true)
       expect(nodeOrchestrator.executionCount).toBe(4)
     })
+
+    it('records paused block completion before returning paused result', async () => {
+      const node = createMockNode('hitl', 'function')
+      const dag = createMockDAG([node])
+      const context = createMockContext({
+        decisions: { router: new Map(), condition: new Map() },
+      })
+      const edgeManager = createMockEdgeManager()
+      const nodeOrchestrator = createMockNodeOrchestrator()
+      const pauseOutput = {
+        response: { status: 'paused' },
+        _pauseMetadata: {
+          contextId: 'pause-1',
+          blockId: 'hitl',
+          response: { status: 'paused' },
+          timestamp: new Date().toISOString(),
+          pauseKind: 'hitl',
+        },
+      }
+      vi.mocked(nodeOrchestrator.executeNode).mockResolvedValue({
+        nodeId: 'hitl',
+        output: pauseOutput,
+        isFinalOutput: false,
+      })
+
+      const engine = new ExecutionEngine(context, dag, edgeManager, nodeOrchestrator)
+      const result = await engine.run('hitl')
+
+      expect(result.status).toBe('paused')
+      expect(nodeOrchestrator.handleNodeCompletion).toHaveBeenCalledWith(
+        context,
+        'hitl',
+        pauseOutput
+      )
+    })
+
+    it('does not stop run-until execution on parallel batch continuation', async () => {
+      const parallelEnd = createMockNode('parallel-end', 'parallel')
+      const nextNode = createMockNode('next', 'function')
+      parallelEnd.outgoingEdges.set('continue', {
+        target: 'next',
+        sourceHandle: EDGE.PARALLEL_CONTINUE,
+      })
+      nextNode.incomingEdges.add('parallel-end')
+      const dag = createMockDAG([parallelEnd, nextNode])
+      const context = createMockContext({
+        stopAfterBlockId: 'parallel-end',
+        decisions: { router: new Map(), condition: new Map() },
+      })
+      const edgeManager = createMockEdgeManager((node) =>
+        node.id === 'parallel-end' ? ['next'] : []
+      )
+      const nodeOrchestrator = createMockNodeOrchestrator()
+      vi.mocked(nodeOrchestrator.executeNode).mockImplementation(async (_ctx, nodeId) => ({
+        nodeId,
+        output:
+          nodeId === 'parallel-end'
+            ? { selectedRoute: EDGE.PARALLEL_CONTINUE }
+            : { result: 'done' },
+        isFinalOutput: nodeId === 'next',
+      }))
+
+      const engine = new ExecutionEngine(context, dag, edgeManager, nodeOrchestrator)
+      await engine.run('parallel-end')
+
+      expect(nodeOrchestrator.executeNode).toHaveBeenCalledWith(context, 'next')
+    })
   })
 
   describe('Cancellation via AbortSignal', () => {
@@ -301,7 +400,7 @@ describe('ExecutionEngine', () => {
       const duration = Date.now() - startTime
 
       expect(result.status).toBe('cancelled')
-      expect(duration).toBeLessThan(100)
+      expect(duration).toBeLessThan(200)
     })
 
     it('should return cancelled status even if error thrown during cancellation', async () => {
@@ -473,13 +572,23 @@ describe('ExecutionEngine', () => {
       const abortController = new AbortController()
 
       const loopStartNode = createMockNode('loop-start', 'loop_sentinel')
-      loopStartNode.metadata = { isSentinel: true, sentinelType: 'start', loopId: 'loop1' }
+      loopStartNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'start',
+        subflowId: 'loop1',
+        subflowType: 'loop',
+      }
 
       const loopBodyNode = createMockNode('loop-body', 'function')
-      loopBodyNode.metadata = { isLoopNode: true, loopId: 'loop1' }
+      loopBodyNode.metadata = { isLoopNode: true, subflowId: 'loop1', subflowType: 'loop' }
 
       const loopEndNode = createMockNode('loop-end', 'loop_sentinel')
-      loopEndNode.metadata = { isSentinel: true, sentinelType: 'end', loopId: 'loop1' }
+      loopEndNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'end',
+        subflowId: 'loop1',
+        subflowType: 'loop',
+      }
 
       loopStartNode.outgoingEdges.set('edge1', { target: 'loop-body' })
       loopBodyNode.outgoingEdges.set('edge2', { target: 'loop-end' })
@@ -953,13 +1062,23 @@ describe('ExecutionEngine', () => {
 
     it('should stop loop iteration when error occurs in loop body', async () => {
       const loopStartNode = createMockNode('loop-start', 'loop_sentinel')
-      loopStartNode.metadata = { isSentinel: true, sentinelType: 'start', loopId: 'loop1' }
+      loopStartNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'start',
+        subflowId: 'loop1',
+        subflowType: 'loop',
+      }
 
       const loopBodyNode = createMockNode('loop-body', 'function')
-      loopBodyNode.metadata = { isLoopNode: true, loopId: 'loop1' }
+      loopBodyNode.metadata = { isLoopNode: true, subflowId: 'loop1', subflowType: 'loop' }
 
       const loopEndNode = createMockNode('loop-end', 'loop_sentinel')
-      loopEndNode.metadata = { isSentinel: true, sentinelType: 'end', loopId: 'loop1' }
+      loopEndNode.metadata = {
+        isSentinel: true,
+        sentinelType: 'end',
+        subflowId: 'loop1',
+        subflowType: 'loop',
+      }
 
       const afterLoopNode = createMockNode('after-loop', 'function')
 
diff --git a/apps/sim/executor/execution/engine.ts b/apps/sim/executor/execution/engine.ts
index b279aae2252..737ad53922d 100644
--- a/apps/sim/executor/execution/engine.ts
+++ b/apps/sim/executor/execution/engine.ts
@@ -5,7 +5,7 @@ import {
   isExecutionCancelled,
   isRedisCancellationEnabled,
 } from '@/lib/execution/cancellation'
-import { BlockType } from '@/executor/constants'
+import { BlockType, EDGE } from '@/executor/constants'
 import type { DAG } from '@/executor/dag/builder'
 import type { EdgeManager } from '@/executor/execution/edge-manager'
 import { serializePauseSnapshot } from '@/executor/execution/snapshot-serializer'
@@ -290,6 +290,9 @@ export class ExecutionEngine {
         if (targetNode) {
           const hadEdge = targetNode.incomingEdges.has(edge.source)
           targetNode.incomingEdges.delete(edge.source)
+          if (hadEdge) {
+            this.edgeManager.markNodeWithActivatedEdge(targetNode.id)
+          }
 
           if (this.edgeManager.isNodeReady(targetNode)) {
             this.execLogger.info('Node became ready after edge removal', { nodeId: targetNode.id })
@@ -399,6 +402,8 @@ export class ExecutionEngine {
     }
 
     if (output._pauseMetadata) {
+      await this.nodeOrchestrator.handleNodeCompletion(this.context, nodeId, output)
+
       const pauseMetadata = output._pauseMetadata
       this.pausedBlocks.set(pauseMetadata.contextId, pauseMetadata)
       this.context.metadata.status = 'paused'
@@ -426,8 +431,9 @@ export class ExecutionEngine {
     if (this.context.stopAfterBlockId === nodeId) {
       // For loop/parallel sentinels, only stop if the subflow has fully exited (all iterations done)
       // shouldContinue: true means more iterations, shouldExit: true means loop is done
-      const shouldContinueLoop = output.shouldContinue === true
-      if (!shouldContinueLoop) {
+      const shouldContinue =
+        output.shouldContinue === true || output.selectedRoute === EDGE.PARALLEL_CONTINUE
+      if (!shouldContinue) {
         this.execLogger.info('Stopping execution after target block', { nodeId })
         this.stoppedEarlyFlag = true
         return
@@ -437,13 +443,6 @@ export class ExecutionEngine {
     const readyNodes = this.edgeManager.processOutgoingEdges(node, output, false)
 
     this.addMultipleToQueue(readyNodes)
-
-    if (this.context.pendingDynamicNodes && this.context.pendingDynamicNodes.length > 0) {
-      const dynamicNodes = this.context.pendingDynamicNodes
-      this.context.pendingDynamicNodes = []
-      this.execLogger.info('Adding dynamically expanded parallel nodes', { dynamicNodes })
-      this.addMultipleToQueue(dynamicNodes)
-    }
   }
 
   private buildPausedResult(startTime: number): ExecutionResult {
@@ -452,7 +451,7 @@ export class ExecutionEngine {
     this.context.metadata.duration = endTime - startTime
     this.context.metadata.status = 'paused'
 
-    const snapshotSeed = serializePauseSnapshot(this.context, [], this.dag)
+    const snapshotSeed = serializePauseSnapshot(this.context, [], this.dag, this.edgeManager)
     const pausePoints: PausePoint[] = Array.from(this.pausedBlocks.values()).map((pause) => ({
       contextId: pause.contextId,
       blockId: pause.blockId,
@@ -484,7 +483,8 @@ export class ExecutionEngine {
   }): SerializableExecutionState | undefined {
     try {
       const serializedSnapshot =
-        snapshotSeed?.snapshot ?? serializePauseSnapshot(this.context, [], this.dag).snapshot
+        snapshotSeed?.snapshot ??
+        serializePauseSnapshot(this.context, [], this.dag, this.edgeManager).snapshot
       const parsedSnapshot = JSON.parse(serializedSnapshot) as {
         state?: SerializableExecutionState
       }
diff --git a/apps/sim/executor/execution/executor.test.ts b/apps/sim/executor/execution/executor.test.ts
new file mode 100644
index 00000000000..3def9595076
--- /dev/null
+++ b/apps/sim/executor/execution/executor.test.ts
@@ -0,0 +1,332 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it, vi } from 'vitest'
+import { BlockType } from '@/executor/constants'
+import { DAGBuilder } from '@/executor/dag/builder'
+import { DAGExecutor } from '@/executor/execution/executor'
+import type { SerializableExecutionState } from '@/executor/execution/types'
+import type { ExecutionContext, ExecutionResult } from '@/executor/types'
+import { buildSentinelStartId } from '@/executor/utils/subflow-utils'
+import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
+
+function createExecutor(): DAGExecutor {
+  return new DAGExecutor({
+    workflow: {
+      version: '1',
+      blocks: [],
+      connections: [],
+    },
+  })
+}
+
+function createBlock(id: string, metadataId: string): SerializedBlock {
+  return {
+    id,
+    position: { x: 0, y: 0 },
+    config: { tool: 'noop', params: {} },
+    inputs: {},
+    outputs: {},
+    metadata: { id: metadataId, name: id },
+    enabled: true,
+  }
+}
+
+describe('DAGExecutor restored cloned subflow registration', () => {
+  it('registers restored cloned subflows under their parent parallel branch', () => {
+    const executor = createExecutor() as unknown as {
+      registerRestoredClonedSubflows: (
+        parentMap: Map<
+          string,
+          { parentId: string; parentType: 'loop' | 'parallel'; branchIndex?: number }
+        >,
+        clonedSubflows: Array<{
+          originalId: string
+          clonedId: string
+          outerBranchIndex: number
+          parentParallelId: string
+        }>
+      ) => void
+    }
+    const parentMap = new Map<
+      string,
+      { parentId: string; parentType: 'loop' | 'parallel'; branchIndex?: number }
+    >([['nested-loop', { parentId: 'parent-parallel', parentType: 'parallel' }]])
+
+    executor.registerRestoredClonedSubflows(parentMap, [
+      {
+        originalId: 'nested-loop',
+        clonedId: 'nested-loop__obranch-2',
+        outerBranchIndex: 2,
+        parentParallelId: 'parent-parallel',
+      },
+    ])
+
+    expect(parentMap.get('nested-loop__obranch-2')).toEqual({
+      parentId: 'parent-parallel',
+      parentType: 'parallel',
+      branchIndex: 2,
+    })
+  })
+
+  it('preserves cloned nested parent relationships within the same restored branch', () => {
+    const executor = createExecutor() as unknown as {
+      registerRestoredClonedSubflows: (
+        parentMap: Map<
+          string,
+          { parentId: string; parentType: 'loop' | 'parallel'; branchIndex?: number }
+        >,
+        clonedSubflows: Array<{
+          originalId: string
+          clonedId: string
+          outerBranchIndex: number
+          parentParallelId: string
+        }>
+      ) => void
+    }
+    const parentMap = new Map<
+      string,
+      { parentId: string; parentType: 'loop' | 'parallel'; branchIndex?: number }
+    >([
+      ['middle-loop', { parentId: 'parent-parallel', parentType: 'parallel' }],
+      ['inner-parallel', { parentId: 'middle-loop', parentType: 'loop' }],
+    ])
+
+    executor.registerRestoredClonedSubflows(parentMap, [
+      {
+        originalId: 'middle-loop',
+        clonedId: 'middle-loop__obranch-2',
+        outerBranchIndex: 2,
+        parentParallelId: 'parent-parallel',
+      },
+      {
+        originalId: 'inner-parallel',
+        clonedId: 'inner-parallel__obranch-2',
+        outerBranchIndex: 2,
+        parentParallelId: 'parent-parallel',
+      },
+    ])
+
+    expect(parentMap.get('inner-parallel__obranch-2')).toEqual({
+      parentId: 'middle-loop__obranch-2',
+      parentType: 'loop',
+      branchIndex: 0,
+    })
+  })
+
+  it('restores snapshot parallel batches with later global branch indexes', () => {
+    const parallelId = 'parallel-1'
+    const loopId = 'loop-1'
+    const taskId = 'task-1'
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [
+        createBlock('start', BlockType.STARTER),
+        createBlock(parallelId, BlockType.PARALLEL),
+        createBlock(loopId, BlockType.LOOP),
+        createBlock(taskId, BlockType.FUNCTION),
+      ],
+      connections: [
+        { source: 'start', target: parallelId },
+        { source: parallelId, target: loopId, sourceHandle: 'parallel-start-source' },
+        { source: loopId, target: taskId, sourceHandle: 'loop-start-source' },
+      ],
+      loops: {
+        [loopId]: {
+          id: loopId,
+          nodes: [taskId],
+          iterations: 1,
+          loopType: 'for',
+        },
+      },
+      parallels: {
+        [parallelId]: {
+          id: parallelId,
+          nodes: [loopId],
+          count: 4,
+          parallelType: 'count',
+        },
+      },
+    }
+    const dag = new DAGBuilder().build(workflow)
+    const executor = new DAGExecutor({ workflow }) as unknown as {
+      restoreSnapshotParallelBatches: (
+        dag: ReturnType<DAGBuilder['build']>,
+        snapshotState?: SerializableExecutionState
+      ) => Array<{
+        originalId: string
+        clonedId: string
+        outerBranchIndex: number
+        parentParallelId: string
+      }>
+    }
+
+    const restoredClones = executor.restoreSnapshotParallelBatches(dag, {
+      blockStates: {},
+      executedBlocks: [],
+      blockLogs: [],
+      decisions: { router: {}, condition: {} },
+      completedLoops: [],
+      activeExecutionPath: [],
+      parallelExecutions: {
+        [parallelId]: {
+          currentBatchStart: 2,
+          currentBatchSize: 1,
+          totalBranches: 4,
+          items: ['zero', 'one', 'two', 'three'],
+        },
+      },
+    })
+
+    expect(dag.nodes.has(buildSentinelStartId(`${loopId}__obranch-2`))).toBe(true)
+    expect(restoredClones).toContainEqual(
+      expect.objectContaining({
+        originalId: loopId,
+        clonedId: `${loopId}__obranch-2`,
+        outerBranchIndex: 2,
+        parentParallelId: parallelId,
+      })
+    )
+  })
+})
+
+describe('DAGExecutor run-from-block snapshot metadata', () => {
+  it('preserves reachable large value and file keys in run-from-block metadata', async () => {
+    const reachableLargeValue = {
+      __simLargeValueRef: true,
+      version: 1,
+      id: 'lv_ABCDEF123456',
+      kind: 'object',
+      size: 1024,
+      key: 'execution/ws/wf/exec/large-value-lv_ABCDEF123456.json',
+    }
+    const unreachableLargeValue = {
+      __simLargeValueRef: true,
+      version: 1,
+      id: 'lv_ZYXWVU654321',
+      kind: 'object',
+      size: 1024,
+      key: 'execution/ws/wf/exec/large-value-lv_ZYXWVU654321.json',
+    }
+    const reachableFile = {
+      id: 'file-1',
+      name: 'reachable.txt',
+      url: '/api/files/serve/reachable',
+      size: 10,
+      type: 'text/plain',
+      key: 'execution/ws/wf/exec/reachable.txt',
+    }
+    const unreachableFile = {
+      id: 'file-2',
+      name: 'unreachable.txt',
+      url: '/api/files/serve/unreachable',
+      size: 10,
+      type: 'text/plain',
+      key: 'execution/ws/wf/exec/unreachable.txt',
+    }
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [
+        createBlock('start', BlockType.STARTER),
+        createBlock('producer', BlockType.FUNCTION),
+        createBlock('consumer', BlockType.FUNCTION),
+        createBlock('unreachable', BlockType.FUNCTION),
+      ],
+      connections: [
+        { source: 'start', target: 'producer' },
+        { source: 'producer', target: 'consumer' },
+      ],
+      loops: {},
+      parallels: {},
+    }
+    const executor = new DAGExecutor({
+      workflow,
+      contextExtensions: {
+        workspaceId: 'ws',
+        executionId: 'exec',
+        largeValueKeys: ['existing-large-key'],
+        fileKeys: ['existing-file-key'],
+      },
+    }) as unknown as DAGExecutor & {
+      buildExecutionPipeline: (context: ExecutionContext) => { run: () => Promise<ExecutionResult> }
+    }
+    const run = vi.fn(async (): Promise<ExecutionResult> => {
+      return {
+        success: true,
+        output: { ok: true },
+        metadata: {} as ExecutionResult['metadata'],
+      }
+    })
+    executor.buildExecutionPipeline = vi.fn(() => ({ run }))
+    const sourceSnapshot: SerializableExecutionState = {
+      blockStates: {
+        producer: { output: { reachableLargeValue, reachableFile } },
+        consumer: { output: { previous: true } },
+        unreachable: { output: { unreachableLargeValue, unreachableFile } },
+      },
+      executedBlocks: ['producer', 'consumer', 'unreachable'],
+      blockLogs: [],
+      decisions: { router: {}, condition: {} },
+      completedLoops: [],
+      activeExecutionPath: [],
+    }
+
+    const result = await executor.executeFromBlock('wf', 'consumer', sourceSnapshot)
+
+    expect(result.metadata?.largeValueKeys).toEqual(['existing-large-key', reachableLargeValue.key])
+    expect(result.metadata?.fileKeys).toEqual(['existing-file-key', reachableFile.key])
+    expect(result.metadata?.largeValueKeys).not.toContain(unreachableLargeValue.key)
+    expect(result.metadata?.fileKeys).not.toContain(unreachableFile.key)
+  })
+
+  it('preserves reachable stable branch aliases in run-from-block snapshots', async () => {
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [
+        createBlock('start', BlockType.STARTER),
+        createBlock('producer', BlockType.FUNCTION),
+        createBlock('consumer', BlockType.FUNCTION),
+      ],
+      connections: [
+        { source: 'start', target: 'producer' },
+        { source: 'producer', target: 'consumer' },
+      ],
+      loops: {},
+      parallels: {},
+    }
+    let capturedContext: ExecutionContext | undefined
+    const executor = new DAGExecutor({ workflow }) as unknown as DAGExecutor & {
+      buildExecutionPipeline: (context: ExecutionContext) => { run: () => Promise<ExecutionResult> }
+    }
+    executor.buildExecutionPipeline = vi.fn((context: ExecutionContext) => {
+      capturedContext = context
+      return {
+        run: async (): Promise<ExecutionResult> => ({
+          success: true,
+          output: { ok: true },
+          metadata: {},
+        }),
+      }
+    })
+    const sourceSnapshot: SerializableExecutionState = {
+      blockStates: {
+        producer: { output: { result: 'latest-local-batch' } },
+        'producer__obranch-0': { output: { result: 'global-branch-0' } },
+        'unreachable__obranch-0': { output: { result: 'unreachable' } },
+        consumer: { output: { previous: true } },
+      },
+      executedBlocks: ['producer', 'producer__obranch-0', 'unreachable__obranch-0', 'consumer'],
+      blockLogs: [],
+      decisions: { router: {}, condition: {} },
+      completedLoops: [],
+      activeExecutionPath: [],
+    }
+
+    await executor.executeFromBlock('wf', 'consumer', sourceSnapshot)
+
+    expect(capturedContext?.blockStates.get('producer__obranch-0')?.output).toEqual({
+      result: 'global-branch-0',
+    })
+    expect(capturedContext?.blockStates.has('unreachable__obranch-0')).toBe(false)
+  })
+})
diff --git a/apps/sim/executor/execution/executor.ts b/apps/sim/executor/execution/executor.ts
index 0d4fb5364c4..d1cb77dbd9d 100644
--- a/apps/sim/executor/execution/executor.ts
+++ b/apps/sim/executor/execution/executor.ts
@@ -21,7 +21,7 @@ import { LoopOrchestrator } from '@/executor/orchestrators/loop'
 import { NodeExecutionOrchestrator } from '@/executor/orchestrators/node'
 import { ParallelOrchestrator } from '@/executor/orchestrators/parallel'
 import type { BlockState, ExecutionContext, ExecutionResult } from '@/executor/types'
-import { ParallelExpander } from '@/executor/utils/parallel-expansion'
+import { type ClonedSubflowInfo, ParallelExpander } from '@/executor/utils/parallel-expansion'
 import {
   computeExecutionSets,
   type RunFromBlockContext,
@@ -36,6 +36,8 @@ import {
 import {
   extractLoopIdFromSentinel,
   extractParallelIdFromSentinel,
+  stripCloneSuffixes,
+  stripOuterBranchSuffix,
 } from '@/executor/utils/subflow-utils'
 import { VariableResolver } from '@/executor/variables/resolver'
 import { navigatePathAsync } from '@/executor/variables/resolvers/reference-async.server'
@@ -44,6 +46,10 @@ import type { SubflowType } from '@/stores/workflows/workflow/types'
 
 const logger = createLogger('DAGExecutor')
 
+interface RestoredClonedSubflowInfo extends ClonedSubflowInfo {
+  parentParallelId: string
+}
+
 export interface DAGExecutorOptions {
   workflow: SerializedWorkflow
   envVarValues?: Record<string, string>
@@ -83,10 +89,14 @@ export class DAGExecutor {
       triggerBlockId,
       savedIncomingEdges,
     })
-    this.restoreSnapshotParallelBatches(dag, this.contextExtensions.snapshotState)
+    const restoredClonedSubflows = this.restoreSnapshotParallelBatches(
+      dag,
+      this.contextExtensions.snapshotState
+    )
     this.restoreSavedIncomingEdges(dag, savedIncomingEdges)
     const { context, state } = this.createExecutionContext(workflowId, triggerBlockId)
     context.subflowParentMap = this.buildSubflowParentMap(dag)
+    this.registerRestoredClonedSubflows(context.subflowParentMap, restoredClonedSubflows)
 
     const engine = this.buildExecutionPipeline(context, dag, state)
     return await engine.run(triggerBlockId)
@@ -148,13 +158,31 @@ export class DAGExecutor {
     // This preserves sibling branch outputs that dirty blocks may reference
     const filteredBlockStates: Record<string, any> = {}
     for (const [blockId, state] of Object.entries(sourceSnapshot.blockStates)) {
-      if (reachableUpstreamSet.has(blockId) || reachableContainerIds.has(blockId)) {
+      const aliasBaseId = stripOuterBranchSuffix(blockId)
+      const isReachableOuterBranchAlias =
+        aliasBaseId !== blockId &&
+        Array.from(reachableUpstreamSet).some(
+          (reachableId) => stripCloneSuffixes(reachableId) === aliasBaseId
+        )
+      if (
+        reachableUpstreamSet.has(blockId) ||
+        reachableContainerIds.has(blockId) ||
+        isReachableOuterBranchAlias
+      ) {
         filteredBlockStates[blockId] = state
       }
     }
-    const filteredExecutedBlocks = sourceSnapshot.executedBlocks.filter(
-      (id) => reachableUpstreamSet.has(id) || reachableContainerIds.has(id)
-    )
+    const filteredExecutedBlocks = sourceSnapshot.executedBlocks.filter((id) => {
+      const aliasBaseId = stripOuterBranchSuffix(id)
+      const isReachableOuterBranchAlias =
+        aliasBaseId !== id &&
+        Array.from(reachableUpstreamSet).some(
+          (reachableId) => stripCloneSuffixes(reachableId) === aliasBaseId
+        )
+      return (
+        reachableUpstreamSet.has(id) || reachableContainerIds.has(id) || isReachableOuterBranchAlias
+      )
+    })
 
     // Filter loop/parallel executions to only include reachable containers
     const filteredLoopExecutions: Record<string, any> = {}
@@ -227,7 +255,7 @@ export class DAGExecutor {
     mergeFileKeys(context, filteredFileKeys)
     context.subflowParentMap = this.buildSubflowParentMap(dag)
 
-    const engine = this.buildExecutionPipeline(context, dag, state)
+    const engine = this.buildExecutionPipeline(context, dag, state, filteredSnapshot)
     const result = await engine.run()
     if (result.metadata) {
       result.metadata.largeValueKeys = context.largeValueKeys
@@ -250,10 +278,11 @@ export class DAGExecutor {
   private restoreSnapshotParallelBatches(
     dag: DAG,
     snapshotState?: SerializableExecutionState
-  ): void {
-    if (!snapshotState?.parallelExecutions) return
+  ): RestoredClonedSubflowInfo[] {
+    if (!snapshotState?.parallelExecutions) return []
 
     const expander = new ParallelExpander()
+    const clonedSubflows: RestoredClonedSubflowInfo[] = []
     for (const [parallelId, scope] of Object.entries(snapshotState.parallelExecutions)) {
       const currentBatchSize = Number(scope.currentBatchSize ?? 0)
       if (!Number.isFinite(currentBatchSize) || currentBatchSize <= 0) continue
@@ -264,14 +293,62 @@ export class DAGExecutor {
         ? scope.items.slice(currentBatchStart, currentBatchStart + currentBatchSize)
         : undefined
 
-      expander.expandParallel(dag, parallelId, currentBatchSize, items, {
+      const restoredBatch = expander.expandParallel(dag, parallelId, currentBatchSize, items, {
         branchIndexOffset: currentBatchStart,
         totalBranches,
       })
+      clonedSubflows.push(
+        ...restoredBatch.clonedSubflows.map((clone) => ({
+          ...clone,
+          parentParallelId: parallelId,
+        }))
+      )
+    }
+
+    return clonedSubflows
+  }
+
+  private registerRestoredClonedSubflows(
+    parentMap: Map<string, { parentId: string; parentType: SubflowType; branchIndex?: number }>,
+    clonedSubflows: RestoredClonedSubflowInfo[]
+  ): void {
+    const branchCloneMaps = new Map<string, Map<number, Map<string, string>>>()
+
+    for (const clone of clonedSubflows) {
+      let parallelBranchMaps = branchCloneMaps.get(clone.parentParallelId)
+      if (!parallelBranchMaps) {
+        parallelBranchMaps = new Map()
+        branchCloneMaps.set(clone.parentParallelId, parallelBranchMaps)
+      }
+
+      let cloneMap = parallelBranchMaps.get(clone.outerBranchIndex)
+      if (!cloneMap) {
+        cloneMap = new Map()
+        parallelBranchMaps.set(clone.outerBranchIndex, cloneMap)
+      }
+
+      cloneMap.set(clone.originalId, clone.clonedId)
+    }
+
+    for (const clone of clonedSubflows) {
+      const originalEntry = parentMap.get(clone.originalId)
+      const cloneMap = branchCloneMaps.get(clone.parentParallelId)?.get(clone.outerBranchIndex)
+      const clonedParentId = originalEntry ? cloneMap?.get(originalEntry.parentId) : undefined
+
+      parentMap.set(clone.clonedId, {
+        parentId: clonedParentId ?? clone.parentParallelId,
+        parentType: clonedParentId && originalEntry ? originalEntry.parentType : 'parallel',
+        branchIndex: clonedParentId ? 0 : clone.outerBranchIndex,
+      })
     }
   }
 
-  private buildExecutionPipeline(context: ExecutionContext, dag: DAG, state: ExecutionState) {
+  private buildExecutionPipeline(
+    context: ExecutionContext,
+    dag: DAG,
+    state: ExecutionState,
+    snapshotState = this.contextExtensions.snapshotState
+  ) {
     const resolver = new VariableResolver(this.workflow, this.workflowVariables, state, {
       navigatePathAsync,
     })
@@ -289,7 +366,12 @@ export class DAGExecutor {
       dag,
       state,
       resolver,
-      this.contextExtensions
+      this.contextExtensions,
+      edgeManager
+    )
+    edgeManager.restoreDeactivatedEdges(
+      snapshotState?.deactivatedEdges,
+      snapshotState?.nodesWithActivatedEdge
     )
     const nodeOrchestrator = new NodeExecutionOrchestrator(
       dag,
@@ -460,8 +542,11 @@ export class DAGExecutor {
    */
   private buildSubflowParentMap(
     dag: DAG
-  ): Map<string, { parentId: string; parentType: SubflowType }> {
-    const parentMap = new Map<string, { parentId: string; parentType: SubflowType }>()
+  ): Map<string, { parentId: string; parentType: SubflowType; branchIndex?: number }> {
+    const parentMap = new Map<
+      string,
+      { parentId: string; parentType: SubflowType; branchIndex?: number }
+    >()
 
     // Scan loop configs: children can be loops or parallels
     for (const [loopId, config] of dag.loopConfigs) {
@@ -476,7 +561,7 @@ export class DAGExecutor {
     for (const [parallelId, config] of dag.parallelConfigs) {
       for (const nodeId of config.nodes ?? []) {
         if (dag.parallelConfigs.has(nodeId) || dag.loopConfigs.has(nodeId)) {
-          parentMap.set(nodeId, { parentId: parallelId, parentType: 'parallel' })
+          parentMap.set(nodeId, { parentId: parallelId, parentType: 'parallel', branchIndex: 0 })
         }
       }
     }
diff --git a/apps/sim/executor/execution/snapshot-serializer.test.ts b/apps/sim/executor/execution/snapshot-serializer.test.ts
index ffd53b32772..a7cbdf32ac7 100644
--- a/apps/sim/executor/execution/snapshot-serializer.test.ts
+++ b/apps/sim/executor/execution/snapshot-serializer.test.ts
@@ -2,6 +2,8 @@
  * @vitest-environment node
  */
 import { describe, expect, it, vi } from 'vitest'
+import type { DAG, DAGNode } from '@/executor/dag/builder'
+import { EdgeManager } from '@/executor/execution/edge-manager'
 import { serializePauseSnapshot } from '@/executor/execution/snapshot-serializer'
 import type { ExecutionContext } from '@/executor/types'
 
@@ -68,6 +70,57 @@ describe('serializePauseSnapshot', () => {
     })
   })
 
+  it('serializes deactivated edge state for resume', () => {
+    const context = createContext()
+    const sourceNode = {
+      id: 'condition',
+      block: {} as DAGNode['block'],
+      incomingEdges: new Set<string>(),
+      outgoingEdges: new Map([['if-edge', { target: 'target', sourceHandle: 'condition-if' }]]),
+      metadata: {},
+    }
+    const targetNode = {
+      id: 'target',
+      block: {} as DAGNode['block'],
+      incomingEdges: new Set(['condition']),
+      outgoingEdges: new Map(),
+      metadata: {},
+    }
+    const activeSourceNode = {
+      id: 'active-source',
+      block: {} as DAGNode['block'],
+      incomingEdges: new Set<string>(),
+      outgoingEdges: new Map([['active-edge', { target: 'active-target' }]]),
+      metadata: {},
+    }
+    const activeTargetNode = {
+      id: 'active-target',
+      block: {} as DAGNode['block'],
+      incomingEdges: new Set(['active-source']),
+      outgoingEdges: new Map(),
+      metadata: {},
+    }
+    const dag: DAG = {
+      nodes: new Map([
+        [sourceNode.id, sourceNode],
+        [targetNode.id, targetNode],
+        [activeSourceNode.id, activeSourceNode],
+        [activeTargetNode.id, activeTargetNode],
+      ]),
+      loopConfigs: new Map(),
+      parallelConfigs: new Map(),
+    }
+    const edgeManager = new EdgeManager(dag)
+    edgeManager.processOutgoingEdges(sourceNode, { selectedOption: 'else' })
+    edgeManager.processOutgoingEdges(activeSourceNode, { result: true })
+
+    const snapshot = serializePauseSnapshot(context, ['next-block'], dag, edgeManager)
+    const serialized = JSON.parse(snapshot.snapshot)
+
+    expect(serialized.state.deactivatedEdges).toHaveLength(1)
+    expect(serialized.state.nodesWithActivatedEdge).toEqual(['active-target'])
+  })
+
   it('rejects oversized snapshot values without full JSON serialization', () => {
     const stringifySpy = vi.spyOn(JSON, 'stringify').mockImplementation(() => {
       throw new Error('full stringify should not be used for compactness checks')
diff --git a/apps/sim/executor/execution/snapshot-serializer.ts b/apps/sim/executor/execution/snapshot-serializer.ts
index 1c63f9d98c4..8f845f3465a 100644
--- a/apps/sim/executor/execution/snapshot-serializer.ts
+++ b/apps/sim/executor/execution/snapshot-serializer.ts
@@ -1,5 +1,6 @@
 import { LARGE_VALUE_THRESHOLD_BYTES } from '@/lib/execution/payloads/large-value-ref'
 import type { DAG } from '@/executor/dag/builder'
+import type { EdgeManager } from '@/executor/execution/edge-manager'
 import { ExecutionSnapshot } from '@/executor/execution/snapshot'
 import type { ExecutionMetadata, SerializableExecutionState } from '@/executor/execution/types'
 import type { ExecutionContext, SerializedSnapshot } from '@/executor/types'
@@ -184,7 +185,8 @@ function serializeParallelExecutions(
 export function serializePauseSnapshot(
   context: ExecutionContext,
   triggerBlockIds: string[],
-  dag?: DAG
+  dag?: DAG,
+  edgeManager?: EdgeManager
 ): SerializedSnapshot {
   const metadataFromContext = context.metadata as ExecutionMetadata | undefined
   let useDraftState: boolean
@@ -220,6 +222,8 @@ export function serializePauseSnapshot(
     activeExecutionPath: Array.from(context.activeExecutionPath),
     pendingQueue: triggerBlockIds,
     dagIncomingEdges,
+    deactivatedEdges: edgeManager?.getDeactivatedEdges(),
+    nodesWithActivatedEdge: edgeManager?.getNodesWithActivatedEdge(),
   }
 
   assertSnapshotValueIsCompact(context.workflowVariables, 'workflow variables')
diff --git a/apps/sim/executor/execution/state.test.ts b/apps/sim/executor/execution/state.test.ts
new file mode 100644
index 00000000000..69627ef5901
--- /dev/null
+++ b/apps/sim/executor/execution/state.test.ts
@@ -0,0 +1,77 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { ExecutionState } from '@/executor/execution/state'
+
+describe('ExecutionState', () => {
+  it('returns exact suffixed cached node outputs', () => {
+    const state = new ExecutionState()
+    state.setBlockOutput('producer₍1₎', { value: 'branch-1' })
+    state.setBlockOutput('producer_loop1', { value: 'loop-1' })
+
+    expect(state.getBlockOutput('producer₍1₎')).toEqual({ value: 'branch-1' })
+    expect(state.getBlockOutput('producer_loop1')).toEqual({ value: 'loop-1' })
+  })
+
+  it('prefers branch-local cloned outputs when resolving original block references', () => {
+    const state = new ExecutionState()
+    state.setBlockOutput('producer', { value: 'branch-0' })
+    state.setBlockOutput('producer__cloneaaa__obranch-2', { value: 'branch-2' })
+
+    expect(state.getBlockOutput('producer', 'consumer__clonebbb__obranch-2')).toEqual({
+      value: 'branch-2',
+    })
+  })
+
+  it('keeps cloned parallel branch references scoped to the same branch index', () => {
+    const state = new ExecutionState()
+    state.setBlockOutput('producer__cloneaaa__obranch-2₍0₎', { value: 'branch-0' })
+    state.setBlockOutput('producer__cloneaaa__obranch-2₍1₎', { value: 'branch-1' })
+
+    expect(state.getBlockOutput('producer', 'consumer__clonebbb__obranch-2₍1₎')).toEqual({
+      value: 'branch-1',
+    })
+  })
+
+  it('does not fall back to another branch when cloned scoped output is missing', () => {
+    const state = new ExecutionState()
+    state.setBlockOutput('producer₍0₎', { value: 'wrong-branch' })
+
+    expect(state.getBlockOutput('producer', 'consumer__clonebbb__obranch-2')).toBeUndefined()
+  })
+
+  it('resolves regular sibling outputs from the same parent parallel branch', () => {
+    const state = new ExecutionState()
+    state.setBlockOutput('producer₍2₎', { value: 'parent-branch-2' })
+
+    expect(state.getBlockOutput('producer', 'consumer__clonebbb__obranch-2₍0₎')).toEqual({
+      value: 'parent-branch-2',
+    })
+  })
+
+  it('does not fall back to direct branch-zero output from cloned nodes', () => {
+    const state = new ExecutionState()
+    state.setBlockOutput('producer', { value: 'branch-0' })
+
+    expect(state.getBlockOutput('producer', 'consumer__clonebbb__obranch-2')).toBeUndefined()
+  })
+
+  it('resolves branch-zero sibling output deterministically for unsuffixed nested branch nodes', () => {
+    const state = new ExecutionState()
+    state.setBlockOutput('producer₍1₎', { value: 'branch-1' })
+    state.setBlockOutput('producer₍0₎', { value: 'branch-0' })
+
+    expect(state.getBlockOutput('producer', 'nested-condition')).toEqual({ value: 'branch-0' })
+  })
+
+  it('prefers stable branch-zero aliases when later batches reuse local branch ids', () => {
+    const state = new ExecutionState()
+    state.setBlockOutput('producer__obranch-0', { value: 'global-branch-0' })
+    state.setBlockOutput('producer₍0₎', { value: 'later-batch-local-0' })
+
+    expect(state.getBlockOutput('producer', 'after-parallel')).toEqual({
+      value: 'global-branch-0',
+    })
+  })
+})
diff --git a/apps/sim/executor/execution/state.ts b/apps/sim/executor/execution/state.ts
index eefe09338c2..c12cca8bb86 100644
--- a/apps/sim/executor/execution/state.ts
+++ b/apps/sim/executor/execution/state.ts
@@ -1,9 +1,25 @@
 import type { BlockStateController } from '@/executor/execution/types'
 import type { BlockState, NormalizedBlockOutput } from '@/executor/types'
+import {
+  buildOuterBranchScopedId,
+  extractOuterBranchIndex,
+  stripCloneSuffixes,
+} from '@/executor/utils/subflow-utils'
+
+const BRANCH_SUFFIX_PATTERN = /₍\d+₎/u
+const LOOP_SUFFIX_PATTERN = /_loop\d+/
 
 function normalizeLookupId(id: string): string {
   return id.replace(/₍\d+₎/gu, '').replace(/_loop\d+/g, '')
 }
+
+function extractBranchSuffix(id: string): string {
+  return id.match(BRANCH_SUFFIX_PATTERN)?.[0] ?? ''
+}
+
+function extractLoopSuffix(id: string): string {
+  return id.match(LOOP_SUFFIX_PATTERN)?.[0] ?? ''
+}
 export interface LoopScope {
   iteration: number
   currentIterationOutputs: Map<string, NormalizedBlockOutput>
@@ -14,6 +30,7 @@ export interface LoopScope {
   condition?: string
   loopType?: 'for' | 'forEach' | 'while' | 'doWhile'
   skipFirstConditionCheck?: boolean
+  skippedAtStart?: boolean
   /** Error message if loop validation failed (e.g., exceeded max iterations) */
   validationError?: string
 }
@@ -51,23 +68,40 @@ export class ExecutionState implements BlockStateController {
   }
 
   getBlockOutput(blockId: string, currentNodeId?: string): NormalizedBlockOutput | undefined {
+    const normalizedId = normalizeLookupId(blockId)
+    if (normalizedId !== blockId) {
+      return this.blockStates.get(blockId)?.output
+    }
+
+    if (currentNodeId) {
+      const scopedOutput = this.getScopedBlockOutput(blockId, currentNodeId)
+      if (scopedOutput !== undefined) {
+        return scopedOutput
+      }
+
+      if (extractOuterBranchIndex(currentNodeId) !== undefined) {
+        return undefined
+      }
+    }
+
     const direct = this.blockStates.get(blockId)?.output
     if (direct !== undefined) {
       return direct
     }
 
-    const normalizedId = normalizeLookupId(blockId)
-    if (normalizedId !== blockId) {
-      return undefined
-    }
+    if (currentNodeId && extractBranchSuffix(currentNodeId) === '') {
+      const stableBranchZeroOutput = this.blockStates.get(
+        buildOuterBranchScopedId(blockId, 0)
+      )?.output
+      if (stableBranchZeroOutput !== undefined) {
+        return stableBranchZeroOutput
+      }
 
-    if (currentNodeId) {
-      const currentSuffix = currentNodeId.replace(normalizedId, '').match(/₍\d+₎/g)?.[0] ?? ''
-      const loopSuffix = currentNodeId.match(/_loop\d+/)?.[0] ?? ''
-      const withSuffix = `${blockId}${currentSuffix}${loopSuffix}`
-      const suffixedOutput = this.blockStates.get(withSuffix)?.output
-      if (suffixedOutput !== undefined) {
-        return suffixedOutput
+      const branchZeroOutput = this.blockStates.get(
+        `${blockId}₍0₎${extractLoopSuffix(currentNodeId)}`
+      )?.output
+      if (branchZeroOutput !== undefined) {
+        return branchZeroOutput
       }
     }
 
@@ -80,6 +114,41 @@ export class ExecutionState implements BlockStateController {
     return undefined
   }
 
+  private getScopedBlockOutput(
+    blockId: string,
+    currentNodeId: string
+  ): NormalizedBlockOutput | undefined {
+    const currentBranchSuffix = extractBranchSuffix(currentNodeId)
+    const loopSuffix = extractLoopSuffix(currentNodeId)
+
+    const currentOuterBranchIndex = extractOuterBranchIndex(currentNodeId)
+    if (currentOuterBranchIndex !== undefined) {
+      for (const [storedId, state] of this.blockStates.entries()) {
+        if (stripCloneSuffixes(storedId) !== blockId) continue
+        if (extractOuterBranchIndex(storedId) !== currentOuterBranchIndex) continue
+        if (extractBranchSuffix(storedId) !== currentBranchSuffix) continue
+        if (extractLoopSuffix(storedId) !== loopSuffix) continue
+
+        return state.output
+      }
+
+      const siblingBranchOutput = this.blockStates.get(
+        `${blockId}₍${currentOuterBranchIndex}₎`
+      )?.output
+      if (siblingBranchOutput !== undefined) {
+        return siblingBranchOutput
+      }
+    } else {
+      const withSuffix = `${blockId}${currentBranchSuffix}${loopSuffix}`
+      const suffixedOutput = this.blockStates.get(withSuffix)?.output
+      if (suffixedOutput !== undefined) {
+        return suffixedOutput
+      }
+    }
+
+    return undefined
+  }
+
   setBlockOutput(blockId: string, output: NormalizedBlockOutput, executionTime = 0): void {
     this.blockStates.set(blockId, { output, executed: true, executionTime })
     this.executedBlocks.add(blockId)
diff --git a/apps/sim/executor/execution/types.ts b/apps/sim/executor/execution/types.ts
index 0f80918b1ef..004a0bb8a1c 100644
--- a/apps/sim/executor/execution/types.ts
+++ b/apps/sim/executor/execution/types.ts
@@ -61,6 +61,8 @@ export interface SerializableExecutionState {
   remainingEdges?: Edge[]
   resumeTerminalNoop?: boolean
   dagIncomingEdges?: Record<string, string[]>
+  deactivatedEdges?: string[]
+  nodesWithActivatedEdge?: string[]
   completedPauseContexts?: string[]
 }
 
@@ -99,9 +101,11 @@ export interface IterationContext {
 export interface WorkflowNodeMetadata
   extends Pick<
     NodeMetadata,
-    'loopId' | 'parallelId' | 'branchIndex' | 'branchTotal' | 'originalBlockId' | 'isLoopNode'
+    'subflowType' | 'subflowId' | 'branchIndex' | 'branchTotal' | 'originalBlockId' | 'isLoopNode'
   > {
   nodeId: string
+  loopId?: string
+  parallelId?: string
   executionOrder?: number
 }
 
diff --git a/apps/sim/executor/human-in-the-loop/utils.ts b/apps/sim/executor/human-in-the-loop/utils.ts
index 2d14788a63d..1b060cf833a 100644
--- a/apps/sim/executor/human-in-the-loop/utils.ts
+++ b/apps/sim/executor/human-in-the-loop/utils.ts
@@ -1,10 +1,12 @@
 import { PARALLEL } from '@/executor/constants'
-import type { NodeMetadata } from '@/executor/dag/types'
 import type { ExecutionContext, LoopPauseScope, ParallelPauseScope } from '@/executor/types'
 
-interface NodeMetadataLike
-  extends Pick<NodeMetadata, 'loopId' | 'parallelId' | 'branchIndex' | 'branchTotal'> {
+interface NodeMetadataLike {
   nodeId: string
+  loopId?: string
+  parallelId?: string
+  branchIndex?: number
+  branchTotal?: number
 }
 
 export function generatePauseContextId(
diff --git a/apps/sim/executor/orchestrators/loop.test.ts b/apps/sim/executor/orchestrators/loop.test.ts
index bd6ddd83c86..9180fc2bd8d 100644
--- a/apps/sim/executor/orchestrators/loop.test.ts
+++ b/apps/sim/executor/orchestrators/loop.test.ts
@@ -5,20 +5,57 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { clearLargeValueCacheForTests } from '@/lib/execution/payloads/cache'
 import { isLargeArrayManifest } from '@/lib/execution/payloads/large-array-manifest-metadata'
 import { EDGE } from '@/executor/constants'
+import type { DAG, DAGNode } from '@/executor/dag/builder'
+import type { EdgeManager } from '@/executor/execution/edge-manager'
+import type { BlockStateController } from '@/executor/execution/types'
 import { LoopOrchestrator } from '@/executor/orchestrators/loop'
 import type { ExecutionContext } from '@/executor/types'
 
-const { mockUploadFile } = vi.hoisted(() => ({
+const { mockExecuteInIsolatedVM, mockUploadFile } = vi.hoisted(() => ({
+  mockExecuteInIsolatedVM: vi.fn(),
   mockUploadFile: vi.fn(),
 }))
 
+vi.mock('@/lib/execution/isolated-vm', () => ({
+  executeInIsolatedVM: mockExecuteInIsolatedVM,
+}))
+
 vi.mock('@/lib/uploads', () => ({
   StorageService: {
     uploadFile: mockUploadFile,
   },
 }))
 
-function createContext(scope: Record<string, unknown>): ExecutionContext {
+function createNode(id: string): DAGNode {
+  return {
+    id,
+    block: {
+      id,
+      position: { x: 0, y: 0 },
+      enabled: true,
+      metadata: { id: 'function', name: id },
+      config: { params: {} },
+      inputs: {},
+      outputs: {},
+    },
+    incomingEdges: new Set(),
+    outgoingEdges: new Map(),
+    metadata: {},
+  }
+}
+
+function createState(): BlockStateController {
+  return {
+    getBlockOutput: vi.fn(),
+    hasExecuted: vi.fn(() => false),
+    setBlockOutput: vi.fn(),
+    setBlockState: vi.fn(),
+    deleteBlockState: vi.fn(),
+    unmarkExecuted: vi.fn(),
+  }
+}
+
+function createContext(scope: Record<string, unknown> = {}, loopId = 'loop-1'): ExecutionContext {
   return {
     workflowId: 'workflow-1',
     workspaceId: 'workspace-1',
@@ -33,27 +70,244 @@ function createContext(scope: Record<string, unknown>): ExecutionContext {
     decisions: { router: new Map(), condition: new Map() },
     completedLoops: new Set(),
     activeExecutionPath: new Set(),
-    loopExecutions: new Map([['loop-1', scope as any]]),
+    loopExecutions: new Map([[loopId, scope as any]]),
   } as ExecutionContext
 }
 
 function createOrchestrator(loopConfigs = new Map<string, any>()) {
-  const setBlockOutput = vi.fn()
+  const state = createState()
   const orchestrator = new LoopOrchestrator(
     { loopConfigs, parallelConfigs: new Map(), nodes: new Map() } as any,
-    { setBlockOutput, unmarkExecuted: vi.fn() } as any,
+    state,
     { resolveSingleReference: vi.fn() } as any
   )
-  return { orchestrator, setBlockOutput }
+  return { orchestrator, setBlockOutput: vi.mocked(state.setBlockOutput) }
 }
 
 describe('LoopOrchestrator', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     clearLargeValueCacheForTests()
+    mockExecuteInIsolatedVM.mockResolvedValue({ result: true })
     mockUploadFile.mockImplementation(async ({ customKey }) => ({ key: customKey }))
   })
 
+  it('does not restore parallel_continue back edges for nested parallels', () => {
+    const loopId = 'loop-1'
+    const parallelId = 'parallel-1'
+    const loopStartId = `loop-${loopId}-sentinel-start`
+    const loopEndId = `loop-${loopId}-sentinel-end`
+    const parallelStartId = `parallel-${parallelId}-sentinel-start`
+    const parallelEndId = `parallel-${parallelId}-sentinel-end`
+    const loopStart = createNode(loopStartId)
+    const loopEnd = createNode(loopEndId)
+    const parallelStart = createNode(parallelStartId)
+    const parallelEnd = createNode(parallelEndId)
+    loopStart.outgoingEdges.set(`${loopStartId}->${parallelStartId}`, { target: parallelStartId })
+    loopStart.outgoingEdges.set(`${loopStartId}->${loopEndId}-exit`, {
+      target: loopEndId,
+      sourceHandle: EDGE.LOOP_EXIT,
+    })
+    parallelStart.outgoingEdges.set(`${parallelStartId}->${parallelEndId}-exit`, {
+      target: parallelEndId,
+      sourceHandle: EDGE.PARALLEL_EXIT,
+    })
+    parallelEnd.outgoingEdges.set(`${parallelEndId}->${parallelStartId}-continue`, {
+      target: parallelStartId,
+      sourceHandle: EDGE.PARALLEL_CONTINUE,
+    })
+    parallelEnd.outgoingEdges.set(`${parallelEndId}->${loopEndId}-exit`, {
+      target: loopEndId,
+      sourceHandle: EDGE.PARALLEL_EXIT,
+    })
+
+    const dag: DAG = {
+      nodes: new Map([
+        [loopStartId, loopStart],
+        [loopEndId, loopEnd],
+        [parallelStartId, parallelStart],
+        [parallelEndId, parallelEnd],
+      ]),
+      loopConfigs: new Map([[loopId, { id: loopId, nodes: [parallelId], loopType: 'for' }]]),
+      parallelConfigs: new Map([
+        [parallelId, { id: parallelId, nodes: [], parallelType: 'count' }],
+      ]),
+    }
+    const edgeManager = {
+      clearDeactivatedEdgesForNodes: vi.fn(),
+    } as unknown as EdgeManager
+    const orchestrator = new LoopOrchestrator(dag, createState(), null as any, {}, edgeManager)
+
+    orchestrator.restoreLoopEdges(loopId)
+
+    expect(parallelStart.incomingEdges.has(loopStartId)).toBe(true)
+    expect(parallelStart.incomingEdges.has(parallelEndId)).toBe(false)
+    expect(loopEnd.incomingEdges.has(loopStartId)).toBe(false)
+    expect(parallelEnd.incomingEdges.has(parallelStartId)).toBe(false)
+    expect(loopEnd.incomingEdges.has(parallelEndId)).toBe(true)
+  })
+
+  it('resolves forEach collections with the loop start sentinel scope', async () => {
+    const loopId = 'loop-1'
+    const dag: DAG = {
+      nodes: new Map(),
+      loopConfigs: new Map([
+        [
+          loopId,
+          {
+            id: loopId,
+            nodes: ['task-1'],
+            loopType: 'forEach',
+            forEachItems: '<Producer.items>',
+          },
+        ],
+      ]),
+      parallelConfigs: new Map(),
+    }
+    const resolver = {
+      resolveSingleReference: vi.fn().mockResolvedValue(['item-1']),
+    }
+    const orchestrator = new LoopOrchestrator(dag, createState(), resolver as any, {}, {
+      clearDeactivatedEdgesForNodes: vi.fn(),
+    } as unknown as EdgeManager)
+    const ctx = createContext()
+
+    const scope = await orchestrator.initializeLoopScope(ctx, loopId)
+
+    expect(resolver.resolveSingleReference).toHaveBeenCalledWith(
+      expect.any(Object),
+      'loop-loop-1-sentinel-start',
+      '<Producer.items>',
+      undefined,
+      { allowLargeValueRefs: true }
+    )
+    expect(scope.maxIterations).toBe(1)
+  })
+
+  it('exits immediately when a loop was skipped at start', async () => {
+    const loopId = 'loop-1'
+    const state = createState()
+    const dag: DAG = {
+      nodes: new Map(),
+      loopConfigs: new Map([[loopId, { id: loopId, nodes: ['task-1'], loopType: 'while' }]]),
+      parallelConfigs: new Map(),
+    }
+    const resolver = {
+      resolveSingleReference: vi.fn().mockResolvedValue(1),
+    }
+    const orchestrator = new LoopOrchestrator(dag, state, resolver as any, {}, {
+      clearDeactivatedEdgesForNodes: vi.fn(),
+    } as unknown as EdgeManager)
+    const ctx = createContext(
+      {
+        iteration: 0,
+        currentIterationOutputs: new Map(),
+        allIterationOutputs: [],
+        loopType: 'while',
+        condition: '<loop.index> > 0',
+        skippedAtStart: true,
+      },
+      loopId
+    )
+
+    const result = await orchestrator.evaluateLoopContinuation(ctx, loopId)
+
+    expect(result).toMatchObject({
+      shouldContinue: false,
+      shouldExit: true,
+      selectedRoute: EDGE.LOOP_EXIT,
+      aggregatedResults: [],
+    })
+    expect(resolver.resolveSingleReference).not.toHaveBeenCalled()
+    expect(state.setBlockOutput).toHaveBeenCalledWith(loopId, { results: [] }, 0)
+  })
+
+  it('marks empty forEach loops as skipped at the initial condition check', async () => {
+    const { orchestrator, setBlockOutput } = createOrchestrator()
+    const scope = {
+      iteration: 0,
+      currentIterationOutputs: new Map(),
+      allIterationOutputs: [],
+      loopType: 'forEach',
+      items: [],
+      maxIterations: 0,
+      condition: '<loop.index> < 0',
+    } as { skippedAtStart?: boolean } & Record<string, unknown>
+    const ctx = createContext(scope)
+
+    const shouldExecute = await orchestrator.evaluateInitialCondition(ctx, 'loop-1')
+
+    expect(shouldExecute).toBe(false)
+    expect(scope.skippedAtStart).toBe(true)
+    expect(setBlockOutput).not.toHaveBeenCalled()
+
+    const result = await orchestrator.evaluateLoopContinuation(ctx, 'loop-1')
+
+    expect(result).toMatchObject({
+      shouldContinue: false,
+      shouldExit: true,
+      selectedRoute: EDGE.LOOP_EXIT,
+      aggregatedResults: [],
+    })
+    expect(scope.skippedAtStart).toBe(false)
+    expect(setBlockOutput).toHaveBeenCalledWith('loop-1', { results: [] }, 0)
+  })
+
+  it.each([
+    ['for loop with zero iterations', { loopType: 'for', maxIterations: 0 }],
+    ['while loop with no condition', { loopType: 'while' }],
+  ])('marks %s as skipped at the initial condition check', async (_name, overrides) => {
+    const { orchestrator, setBlockOutput } = createOrchestrator()
+    const scope = {
+      iteration: 0,
+      currentIterationOutputs: new Map(),
+      allIterationOutputs: [],
+      ...overrides,
+    } as { skippedAtStart?: boolean } & Record<string, unknown>
+    const ctx = createContext(scope)
+
+    const shouldExecute = await orchestrator.evaluateInitialCondition(ctx, 'loop-1')
+
+    expect(shouldExecute).toBe(false)
+    expect(scope.skippedAtStart).toBe(true)
+    expect(setBlockOutput).not.toHaveBeenCalled()
+
+    await orchestrator.evaluateLoopContinuation(ctx, 'loop-1')
+
+    expect(scope.skippedAtStart).toBe(false)
+    expect(setBlockOutput).toHaveBeenCalledWith('loop-1', { results: [] }, 0)
+  })
+
+  it('marks while loops with false initial conditions as skipped at start', async () => {
+    const state = createState()
+    const resolver = { resolveSingleReference: vi.fn().mockResolvedValue(false) }
+    mockExecuteInIsolatedVM.mockResolvedValueOnce({ result: false })
+    const orchestrator = new LoopOrchestrator(
+      { loopConfigs: new Map(), parallelConfigs: new Map(), nodes: new Map() },
+      state,
+      resolver as any
+    )
+    const scope = {
+      iteration: 0,
+      currentIterationOutputs: new Map(),
+      allIterationOutputs: [],
+      loopType: 'while',
+      condition: '<condition.output>',
+    } as { skippedAtStart?: boolean } & Record<string, unknown>
+    const ctx = createContext(scope)
+
+    const shouldExecute = await orchestrator.evaluateInitialCondition(ctx, 'loop-1')
+
+    expect(shouldExecute).toBe(false)
+    expect(scope.skippedAtStart).toBe(true)
+    expect(state.setBlockOutput).not.toHaveBeenCalled()
+    expect(mockExecuteInIsolatedVM).toHaveBeenCalledWith(
+      expect.objectContaining({
+        code: 'return Boolean(false)',
+      })
+    )
+  })
+
   it('exits doWhile loops when the configured iteration cap is reached', async () => {
     const { orchestrator } = createOrchestrator()
     const ctx = createContext({
@@ -89,7 +343,7 @@ describe('LoopOrchestrator', () => {
         ],
       ])
     )
-    const ctx = createContext({})
+    const ctx = createContext()
 
     const scope = await orchestrator.initializeLoopScope(ctx, 'loop-1')
 
@@ -111,7 +365,7 @@ describe('LoopOrchestrator', () => {
         ],
       ])
     )
-    const ctx = createContext({})
+    const ctx = createContext()
 
     const scope = await orchestrator.initializeLoopScope(ctx, 'loop-1')
 
diff --git a/apps/sim/executor/orchestrators/loop.ts b/apps/sim/executor/orchestrators/loop.ts
index 02ec0d9a73a..913de932915 100644
--- a/apps/sim/executor/orchestrators/loop.ts
+++ b/apps/sim/executor/orchestrators/loop.ts
@@ -5,7 +5,13 @@ import { isExecutionCancelled, isRedisCancellationEnabled } from '@/lib/executio
 import { executeInIsolatedVM } from '@/lib/execution/isolated-vm'
 import { compactSubflowResults } from '@/lib/execution/payloads/serializer'
 import { isLikelyReferenceSegment } from '@/lib/workflows/sanitization/references'
-import { buildLoopIndexCondition, DEFAULTS, EDGE, PARALLEL } from '@/executor/constants'
+import {
+  buildLoopIndexCondition,
+  CONTROL_BACK_EDGE_HANDLES,
+  DEFAULTS,
+  EDGE,
+  PARALLEL,
+} from '@/executor/constants'
 import type { DAG } from '@/executor/dag/builder'
 import type { EdgeManager } from '@/executor/execution/edge-manager'
 import type { LoopScope } from '@/executor/execution/state'
@@ -19,9 +25,10 @@ import {
   buildParallelSentinelStartId,
   buildSentinelEndId,
   buildSentinelStartId,
-  emitEmptySubflowEvents,
   emitSubflowSuccessEvents,
   extractBaseBlockId,
+  extractLoopIdFromSentinel,
+  extractParallelIdFromSentinel,
 } from '@/executor/utils/subflow-utils'
 import { resolveArrayInputAsync } from '@/executor/utils/subflow-utils.server'
 import type { VariableResolver } from '@/executor/variables/resolver'
@@ -134,7 +141,12 @@ export class LoopOrchestrator {
         }
         let items: any[]
         try {
-          items = await resolveArrayInputAsync(ctx, loopConfig.forEachItems, this.resolver)
+          items = await resolveArrayInputAsync(
+            ctx,
+            loopConfig.forEachItems,
+            this.resolver,
+            buildSentinelStartId(loopId)
+          )
         } catch (error) {
           const errorMessage = `ForEach loop resolution failed: ${toError(error).message}`
           logger.error(errorMessage, { loopId, forEachItems: loopConfig.forEachItems })
@@ -243,6 +255,11 @@ export class LoopOrchestrator {
       return await this.createExitResult(ctx, loopId, scope)
     }
 
+    if (scope.skippedAtStart) {
+      scope.skippedAtStart = false
+      return await this.createExitResult(ctx, loopId, scope)
+    }
+
     const iterationResults: NormalizedBlockOutput[] = []
     for (const blockOutput of scope.currentIterationOutputs.values()) {
       iterationResults.push(blockOutput)
@@ -579,11 +596,10 @@ export class LoopOrchestrator {
 
         for (const [, edge] of potentialSourceNode.outgoingEdges) {
           if (edge.target === nodeId) {
-            const isBackwardEdge =
-              edge.sourceHandle === EDGE.LOOP_CONTINUE ||
-              edge.sourceHandle === EDGE.LOOP_CONTINUE_ALT
-
-            if (!isBackwardEdge) {
+            if (
+              !this.isSubflowStartExitBypassEdge(potentialSourceId, nodeId, edge.sourceHandle) &&
+              (edge.sourceHandle === undefined || !CONTROL_BACK_EDGE_HANDLES.has(edge.sourceHandle))
+            ) {
               nodeToRestore.incomingEdges.add(potentialSourceId)
             }
           }
@@ -592,6 +608,32 @@ export class LoopOrchestrator {
     }
   }
 
+  private isSubflowStartExitBypassEdge(
+    sourceId: string,
+    targetId: string,
+    sourceHandle?: string
+  ): boolean {
+    if (sourceHandle === EDGE.LOOP_EXIT) {
+      const loopId = extractLoopIdFromSentinel(sourceId)
+      return (
+        !!loopId &&
+        sourceId === buildSentinelStartId(loopId) &&
+        targetId === buildSentinelEndId(loopId)
+      )
+    }
+
+    if (sourceHandle === EDGE.PARALLEL_EXIT) {
+      const parallelId = extractParallelIdFromSentinel(sourceId)
+      return (
+        !!parallelId &&
+        sourceId === buildParallelSentinelStartId(parallelId) &&
+        targetId === buildParallelSentinelEndId(parallelId)
+      )
+    }
+
+    return false
+  }
+
   getLoopScope(ctx: ExecutionContext, loopId: string): LoopScope | undefined {
     return ctx.loopExecutions?.get(loopId)
   }
@@ -615,8 +657,7 @@ export class LoopOrchestrator {
     if (scope.loopType === 'forEach') {
       if (!scope.items || scope.items.length === 0) {
         logger.info('ForEach loop has empty collection, skipping loop body', { loopId })
-        this.state.setBlockOutput(loopId, { results: [] }, DEFAULTS.EXECUTION_TIME)
-        await emitEmptySubflowEvents(ctx, loopId, 'loop', this.contextExtensions)
+        scope.skippedAtStart = true
         return false
       }
       return true
@@ -625,8 +666,7 @@ export class LoopOrchestrator {
     if (scope.loopType === 'for') {
       if (scope.maxIterations === 0) {
         logger.info('For loop has 0 iterations, skipping loop body', { loopId })
-        this.state.setBlockOutput(loopId, { results: [] }, DEFAULTS.EXECUTION_TIME)
-        await emitEmptySubflowEvents(ctx, loopId, 'loop', this.contextExtensions)
+        scope.skippedAtStart = true
         return false
       }
       return true
@@ -639,8 +679,7 @@ export class LoopOrchestrator {
     if (scope.loopType === 'while') {
       if (!scope.condition) {
         logger.warn('No condition defined for while loop', { loopId })
-        this.state.setBlockOutput(loopId, { results: [] }, DEFAULTS.EXECUTION_TIME)
-        await emitEmptySubflowEvents(ctx, loopId, 'loop', this.contextExtensions)
+        scope.skippedAtStart = true
         return false
       }
 
@@ -652,8 +691,8 @@ export class LoopOrchestrator {
       })
 
       if (!result) {
-        this.state.setBlockOutput(loopId, { results: [] }, DEFAULTS.EXECUTION_TIME)
-        await emitEmptySubflowEvents(ctx, loopId, 'loop', this.contextExtensions)
+        logger.info('While loop initial condition is false, skipping loop body', { loopId })
+        scope.skippedAtStart = true
       }
 
       return result
diff --git a/apps/sim/executor/orchestrators/node.test.ts b/apps/sim/executor/orchestrators/node.test.ts
new file mode 100644
index 00000000000..856dfe76dc3
--- /dev/null
+++ b/apps/sim/executor/orchestrators/node.test.ts
@@ -0,0 +1,464 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it, vi } from 'vitest'
+import { EDGE } from '@/executor/constants'
+import type { DAG, DAGNode } from '@/executor/dag/builder'
+import type { BlockExecutor } from '@/executor/execution/block-executor'
+import type { BlockStateController } from '@/executor/execution/types'
+import type { LoopOrchestrator } from '@/executor/orchestrators/loop'
+import { NodeExecutionOrchestrator } from '@/executor/orchestrators/node'
+import type { ParallelOrchestrator } from '@/executor/orchestrators/parallel'
+import type { ExecutionContext } from '@/executor/types'
+
+function createContext(): ExecutionContext {
+  return {
+    workflowId: 'workflow-1',
+    workspaceId: 'workspace-1',
+    executionId: 'execution-1',
+    userId: 'user-1',
+    blockStates: new Map(),
+    executedBlocks: new Set(),
+    blockLogs: [],
+    metadata: { duration: 0 },
+    environmentVariables: {},
+    decisions: {
+      router: new Map(),
+      condition: new Map(),
+    },
+    completedLoops: new Set(),
+    activeExecutionPath: new Set(),
+    workflow: {
+      version: '1',
+      blocks: [],
+      connections: [],
+      loops: {},
+      parallels: {},
+    },
+  }
+}
+
+function createState(): BlockStateController {
+  return {
+    getBlockOutput: vi.fn(),
+    hasExecuted: vi.fn(() => false),
+    setBlockOutput: vi.fn(),
+    setBlockState: vi.fn(),
+    deleteBlockState: vi.fn(),
+    unmarkExecuted: vi.fn(),
+  }
+}
+
+function createSentinelNode(id: string, sentinelType: 'start' | 'end'): DAGNode {
+  return {
+    id,
+    block: {
+      id,
+      position: { x: 0, y: 0 },
+      enabled: true,
+      metadata: { id: 'parallel', name: id },
+      config: { params: {} },
+      inputs: {},
+      outputs: {},
+    },
+    incomingEdges: new Set(),
+    outgoingEdges: new Map(),
+    metadata: {
+      isSentinel: true,
+      sentinelType,
+      subflowId: 'parallel-1',
+      subflowType: 'parallel',
+    },
+  }
+}
+
+function createOrchestrator(
+  dag: DAG,
+  state: BlockStateController,
+  parallelOrchestrator: Partial<ParallelOrchestrator>,
+  loopOrchestratorOverrides: Partial<LoopOrchestrator> = {}
+): NodeExecutionOrchestrator {
+  const blockExecutor = { execute: vi.fn() } as unknown as BlockExecutor
+  const loopOrchestrator = {
+    getLoopScope: vi.fn(),
+    initializeLoopScope: vi.fn(),
+    evaluateInitialCondition: vi.fn(),
+    evaluateLoopContinuation: vi.fn(),
+    clearLoopExecutionState: vi.fn(),
+    restoreLoopEdges: vi.fn(),
+    storeLoopNodeOutput: vi.fn(),
+    ...loopOrchestratorOverrides,
+  } as unknown as LoopOrchestrator
+
+  return new NodeExecutionOrchestrator(
+    dag,
+    state,
+    blockExecutor,
+    loopOrchestrator,
+    parallelOrchestrator as ParallelOrchestrator
+  )
+}
+
+describe('NodeExecutionOrchestrator parallel sentinel batching', () => {
+  it('returns loop_exit from a loop start sentinel when the initial condition is false', async () => {
+    const startNode = {
+      ...createSentinelNode('loop-loop-1-sentinel-start', 'start'),
+      metadata: {
+        isSentinel: true,
+        sentinelType: 'start' as const,
+        subflowId: 'loop-1',
+        subflowType: 'loop' as const,
+      },
+    }
+    const dag: DAG = {
+      nodes: new Map([[startNode.id, startNode]]),
+      loopConfigs: new Map(),
+      parallelConfigs: new Map(),
+    }
+    const state = createState()
+    const loopOrchestrator = {
+      getLoopScope: vi.fn(() => ({})),
+      evaluateInitialCondition: vi.fn().mockResolvedValue(false),
+    }
+    const orchestrator = createOrchestrator(dag, state, {}, loopOrchestrator)
+
+    const result = await orchestrator.executeNode(createContext(), startNode.id)
+
+    expect(result.output).toMatchObject({
+      shouldExit: true,
+      selectedRoute: EDGE.LOOP_EXIT,
+    })
+  })
+
+  it('prepares the current batch when executing a parallel start sentinel', async () => {
+    const startNode = createSentinelNode('parallel-parallel-1-sentinel-start', 'start')
+    const dag: DAG = {
+      nodes: new Map([[startNode.id, startNode]]),
+      loopConfigs: new Map(),
+      parallelConfigs: new Map(),
+    }
+    const state = createState()
+    const parallelOrchestrator = {
+      getParallelScope: vi.fn(() => ({ parallelId: 'parallel-1', totalBranches: 2 })),
+      initializeParallelScope: vi.fn(),
+      prepareCurrentBatch: vi.fn(),
+    }
+    const orchestrator = createOrchestrator(dag, state, parallelOrchestrator)
+
+    const result = await orchestrator.executeNode(createContext(), startNode.id)
+
+    expect(result.output).toEqual({ sentinelStart: true })
+    expect(parallelOrchestrator.prepareCurrentBatch).toHaveBeenCalledWith(
+      expect.any(Object),
+      'parallel-1'
+    )
+  })
+
+  it('returns parallel_exit from an empty parallel start sentinel without preparing a batch', async () => {
+    const startNode = createSentinelNode('parallel-parallel-1-sentinel-start', 'start')
+    const dag: DAG = {
+      nodes: new Map([[startNode.id, startNode]]),
+      loopConfigs: new Map(),
+      parallelConfigs: new Map(),
+    }
+    const state = createState()
+    const parallelOrchestrator = {
+      getParallelScope: vi.fn(() => ({
+        parallelId: 'parallel-1',
+        totalBranches: 0,
+        isEmpty: true,
+      })),
+      initializeParallelScope: vi.fn(),
+      prepareCurrentBatch: vi.fn(),
+    }
+    const orchestrator = createOrchestrator(dag, state, parallelOrchestrator)
+
+    const result = await orchestrator.executeNode(createContext(), startNode.id)
+
+    expect(result.output).toMatchObject({
+      shouldExit: true,
+      selectedRoute: EDGE.PARALLEL_EXIT,
+    })
+    expect(parallelOrchestrator.prepareCurrentBatch).not.toHaveBeenCalled()
+  })
+
+  it('prepares a batch continuation when parallel end selects parallel_continue', async () => {
+    const endNode = createSentinelNode('parallel-parallel-1-sentinel-end', 'end')
+    const dag: DAG = {
+      nodes: new Map([[endNode.id, endNode]]),
+      loopConfigs: new Map(),
+      parallelConfigs: new Map(),
+    }
+    const state = createState()
+    const parallelOrchestrator = {
+      getParallelScope: vi.fn(),
+      prepareForBatchContinuation: vi.fn(),
+    }
+    const orchestrator = createOrchestrator(dag, state, parallelOrchestrator)
+
+    await orchestrator.handleNodeCompletion(createContext(), endNode.id, {
+      selectedRoute: EDGE.PARALLEL_CONTINUE,
+    })
+
+    expect(state.setBlockOutput).toHaveBeenCalledWith(endNode.id, {
+      selectedRoute: EDGE.PARALLEL_CONTINUE,
+    })
+    expect(parallelOrchestrator.prepareForBatchContinuation).toHaveBeenCalledWith('parallel-1')
+  })
+
+  it('marks terminal parallel exit output as final when only the continue back edge remains', async () => {
+    const endNode = createSentinelNode('parallel-parallel-1-sentinel-end', 'end')
+    endNode.outgoingEdges.set('continue', {
+      target: 'parallel-parallel-1-sentinel-start',
+      sourceHandle: EDGE.PARALLEL_CONTINUE,
+    })
+    const dag: DAG = {
+      nodes: new Map([[endNode.id, endNode]]),
+      loopConfigs: new Map(),
+      parallelConfigs: new Map(),
+    }
+    const parallelOrchestrator = {
+      getParallelScope: vi.fn(() => ({ parallelId: 'parallel-1', totalBranches: 1 })),
+      aggregateParallelResults: vi.fn().mockResolvedValue({
+        allBranchesComplete: true,
+        results: [['result']],
+        totalBranches: 1,
+      }),
+    }
+    const orchestrator = createOrchestrator(dag, createState(), parallelOrchestrator)
+
+    const result = await orchestrator.executeNode(createContext(), endNode.id)
+
+    expect(result.isFinalOutput).toBe(true)
+    expect(result.output).toMatchObject({
+      results: [['result']],
+      selectedRoute: EDGE.PARALLEL_EXIT,
+    })
+  })
+
+  it('does not mark a continuing parallel batch as final output', async () => {
+    const endNode = createSentinelNode('parallel-parallel-1-sentinel-end', 'end')
+    endNode.outgoingEdges.set('continue', {
+      target: 'parallel-parallel-1-sentinel-start',
+      sourceHandle: EDGE.PARALLEL_CONTINUE,
+    })
+    const dag: DAG = {
+      nodes: new Map([[endNode.id, endNode]]),
+      loopConfigs: new Map(),
+      parallelConfigs: new Map(),
+    }
+    const parallelOrchestrator = {
+      getParallelScope: vi.fn(() => ({ parallelId: 'parallel-1', totalBranches: 3 })),
+      aggregateParallelResults: vi.fn().mockResolvedValue({
+        allBranchesComplete: false,
+        totalBranches: 3,
+      }),
+    }
+    const orchestrator = createOrchestrator(dag, createState(), parallelOrchestrator)
+
+    const result = await orchestrator.executeNode(createContext(), endNode.id)
+
+    expect(result.isFinalOutput).toBe(false)
+    expect(result.output).toMatchObject({
+      selectedRoute: EDGE.PARALLEL_CONTINUE,
+    })
+  })
+
+  it('records completed nested subflow sentinels as parent parallel branch output', async () => {
+    const endNode = {
+      ...createSentinelNode('loop-nested-loop-sentinel-end', 'end'),
+      metadata: {
+        isSentinel: true,
+        sentinelType: 'end' as const,
+        subflowId: 'nested-loop',
+        subflowType: 'loop' as const,
+      },
+    }
+    const dag: DAG = {
+      nodes: new Map([[endNode.id, endNode]]),
+      loopConfigs: new Map(),
+      parallelConfigs: new Map(),
+    }
+    const state = createState()
+    const parallelOrchestrator = {
+      getParallelScope: vi.fn(),
+      handleParallelBranchCompletion: vi.fn(),
+      prepareForBatchContinuation: vi.fn(),
+    }
+    const orchestrator = createOrchestrator(dag, state, parallelOrchestrator)
+    const ctx = createContext()
+    ctx.subflowParentMap = new Map([
+      ['nested-loop', { parentId: 'parent-parallel', parentType: 'parallel', branchIndex: 3 }],
+    ])
+
+    await orchestrator.handleNodeCompletion(ctx, endNode.id, {
+      results: ['loop-result'],
+      shouldExit: true,
+      selectedRoute: EDGE.LOOP_EXIT,
+    })
+
+    expect(parallelOrchestrator.handleParallelBranchCompletion).toHaveBeenCalledWith(
+      ctx,
+      'parent-parallel',
+      endNode.id,
+      { results: ['loop-result'] },
+      3
+    )
+  })
+
+  it('does not record continuing nested parallel batches as parent parallel branch output', async () => {
+    const endNode = {
+      ...createSentinelNode('parallel-nested-parallel-sentinel-end', 'end'),
+      metadata: {
+        isSentinel: true,
+        sentinelType: 'end' as const,
+        subflowId: 'nested-parallel',
+        subflowType: 'parallel' as const,
+      },
+    }
+    const dag: DAG = {
+      nodes: new Map([[endNode.id, endNode]]),
+      loopConfigs: new Map(),
+      parallelConfigs: new Map(),
+    }
+    const state = createState()
+    const parallelOrchestrator = {
+      getParallelScope: vi.fn(),
+      handleParallelBranchCompletion: vi.fn(),
+      prepareForBatchContinuation: vi.fn(),
+    }
+    const orchestrator = createOrchestrator(dag, state, parallelOrchestrator)
+    const ctx = createContext()
+    ctx.subflowParentMap = new Map([
+      ['nested-parallel', { parentId: 'parent-parallel', parentType: 'parallel', branchIndex: 3 }],
+    ])
+
+    await orchestrator.handleNodeCompletion(ctx, endNode.id, {
+      sentinelEnd: true,
+      selectedRoute: EDGE.PARALLEL_CONTINUE,
+    })
+
+    expect(parallelOrchestrator.handleParallelBranchCompletion).not.toHaveBeenCalled()
+  })
+
+  it('writes stable outer-branch output aliases for completed parallel branch nodes', async () => {
+    const branchNode: DAGNode = {
+      id: 'worker₍0₎',
+      block: {
+        id: 'worker',
+        position: { x: 0, y: 0 },
+        enabled: true,
+        metadata: { id: 'function', name: 'Worker' },
+        config: { params: {} },
+        inputs: {},
+        outputs: {},
+      },
+      incomingEdges: new Set(),
+      outgoingEdges: new Map(),
+      metadata: {
+        isParallelBranch: true,
+        subflowId: 'parallel-1',
+        subflowType: 'parallel',
+        originalBlockId: 'worker',
+        branchIndex: 2,
+      },
+    }
+    const dag: DAG = {
+      nodes: new Map([[branchNode.id, branchNode]]),
+      loopConfigs: new Map(),
+      parallelConfigs: new Map(),
+    }
+    const state = createState()
+    const parallelOrchestrator = {
+      getParallelScope: vi.fn(() => ({ parallelId: 'parallel-1', totalBranches: 3 })),
+      initializeParallelScope: vi.fn(),
+      handleParallelBranchCompletion: vi.fn(),
+    }
+    const orchestrator = createOrchestrator(dag, state, parallelOrchestrator)
+    const output = { result: 'branch-2' }
+    const ctx = createContext()
+
+    await orchestrator.handleNodeCompletion(ctx, branchNode.id, output)
+
+    expect(parallelOrchestrator.handleParallelBranchCompletion).toHaveBeenCalledWith(
+      ctx,
+      'parallel-1',
+      branchNode.id,
+      output
+    )
+    expect(state.setBlockOutput).toHaveBeenCalledWith('worker__obranch-2', output)
+    expect(state.setBlockOutput).toHaveBeenCalledWith(branchNode.id, output)
+  })
+
+  it('records completed nested subflow sentinels as parent loop iteration output', async () => {
+    const endNode = {
+      ...createSentinelNode('parallel-nested-parallel-sentinel-end', 'end'),
+      metadata: {
+        isSentinel: true,
+        sentinelType: 'end' as const,
+        subflowId: 'nested-parallel',
+        subflowType: 'parallel' as const,
+      },
+    }
+    const dag: DAG = {
+      nodes: new Map([[endNode.id, endNode]]),
+      loopConfigs: new Map(),
+      parallelConfigs: new Map(),
+    }
+    const state = createState()
+    const loopOrchestrator = {
+      storeLoopNodeOutput: vi.fn(),
+    }
+    const orchestrator = createOrchestrator(dag, state, {}, loopOrchestrator)
+    const ctx = createContext()
+    ctx.subflowParentMap = new Map([
+      ['nested-parallel', { parentId: 'parent-loop', parentType: 'loop' }],
+    ])
+
+    await orchestrator.handleNodeCompletion(ctx, endNode.id, {
+      results: ['parallel-result'],
+      sentinelEnd: true,
+      selectedRoute: EDGE.PARALLEL_EXIT,
+    })
+
+    expect(loopOrchestrator.storeLoopNodeOutput).toHaveBeenCalledWith(
+      ctx,
+      'parent-loop',
+      'nested-parallel',
+      { results: ['parallel-result'] }
+    )
+  })
+
+  it('does not record continuing nested loop iterations as parent loop output', async () => {
+    const endNode = {
+      ...createSentinelNode('loop-nested-loop-sentinel-end', 'end'),
+      metadata: {
+        isSentinel: true,
+        sentinelType: 'end' as const,
+        subflowId: 'nested-loop',
+        subflowType: 'loop' as const,
+      },
+    }
+    const dag: DAG = {
+      nodes: new Map([[endNode.id, endNode]]),
+      loopConfigs: new Map(),
+      parallelConfigs: new Map(),
+    }
+    const state = createState()
+    const loopOrchestrator = {
+      storeLoopNodeOutput: vi.fn(),
+    }
+    const orchestrator = createOrchestrator(dag, state, {}, loopOrchestrator)
+    const ctx = createContext()
+    ctx.subflowParentMap = new Map([
+      ['nested-loop', { parentId: 'parent-loop', parentType: 'loop' }],
+    ])
+
+    await orchestrator.handleNodeCompletion(ctx, endNode.id, {
+      shouldContinue: true,
+      selectedRoute: EDGE.LOOP_CONTINUE,
+    })
+
+    expect(loopOrchestrator.storeLoopNodeOutput).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/sim/executor/orchestrators/node.ts b/apps/sim/executor/orchestrators/node.ts
index 4db656c3254..56229908445 100644
--- a/apps/sim/executor/orchestrators/node.ts
+++ b/apps/sim/executor/orchestrators/node.ts
@@ -7,7 +7,11 @@ import type { BlockStateController } from '@/executor/execution/types'
 import type { LoopOrchestrator } from '@/executor/orchestrators/loop'
 import type { ParallelOrchestrator } from '@/executor/orchestrators/parallel'
 import type { ExecutionContext, NormalizedBlockOutput } from '@/executor/types'
-import { extractBaseBlockId } from '@/executor/utils/subflow-utils'
+import {
+  buildOuterBranchScopedId,
+  extractBaseBlockId,
+  extractOuterBranchIndex,
+} from '@/executor/utils/subflow-utils'
 
 const logger = createLogger('NodeExecutionOrchestrator')
 
@@ -25,6 +29,10 @@ function getResultCount(value: unknown): number {
   return Array.isArray(value) ? value.length : 0
 }
 
+function getSubflowResultOutput(output: NormalizedBlockOutput): NormalizedBlockOutput {
+  return { results: output.results ?? [] }
+}
+
 export interface NodeExecutionResult {
   nodeId: string
   output: NormalizedBlockOutput
@@ -66,19 +74,20 @@ export class NodeExecutionOrchestrator {
       }
     }
 
-    const loopId = node.metadata.loopId
+    const loopId = node.metadata.subflowType === 'loop' ? node.metadata.subflowId : undefined
     if (loopId && !this.loopOrchestrator.getLoopScope(ctx, loopId)) {
       await this.loopOrchestrator.initializeLoopScope(ctx, loopId)
     }
 
-    const parallelId = node.metadata.parallelId
+    const parallelId =
+      node.metadata.subflowType === 'parallel' ? node.metadata.subflowId : undefined
     if (parallelId && !this.parallelOrchestrator.getParallelScope(ctx, parallelId)) {
       await this.parallelOrchestrator.initializeParallelScope(ctx, parallelId)
     }
 
     if (node.metadata.isSentinel) {
       const output = await this.handleSentinel(ctx, node)
-      const isFinalOutput = node.outgoingEdges.size === 0
+      const isFinalOutput = this.isFinalSentinelOutput(node, output)
       return {
         nodeId,
         output,
@@ -95,42 +104,57 @@ export class NodeExecutionOrchestrator {
     }
   }
 
+  private isFinalSentinelOutput(node: DAGNode, output: NormalizedBlockOutput): boolean {
+    const selectedRoute = output.selectedRoute
+    if (selectedRoute === EDGE.LOOP_CONTINUE || selectedRoute === EDGE.PARALLEL_CONTINUE) {
+      return false
+    }
+
+    if (selectedRoute === EDGE.LOOP_EXIT || selectedRoute === EDGE.PARALLEL_EXIT) {
+      return !Array.from(node.outgoingEdges.values()).some(
+        (edge) => edge.sourceHandle === selectedRoute
+      )
+    }
+
+    return node.outgoingEdges.size === 0
+  }
+
   private async handleSentinel(
     ctx: ExecutionContext,
     node: DAGNode
   ): Promise<NormalizedBlockOutput> {
     const sentinelType = node.metadata.sentinelType
-    const loopId = node.metadata.loopId
-    const parallelId = node.metadata.parallelId
-    const isParallelSentinel = node.metadata.isParallelSentinel
+    const subflowType = node.metadata.subflowType
+    const subflowId = node.metadata.subflowId
+
+    if (!subflowType || !subflowId) {
+      logger.warn('Sentinel missing subflow metadata', { nodeId: node.id, sentinelType })
+      return {}
+    }
 
-    if (isParallelSentinel) {
-      return await this.handleParallelSentinel(ctx, node, sentinelType, parallelId)
+    if (subflowType === 'parallel') {
+      return await this.handleParallelSentinel(ctx, node, sentinelType, subflowId)
     }
 
     switch (sentinelType) {
       case 'start': {
-        if (loopId) {
-          const shouldExecute = await this.loopOrchestrator.evaluateInitialCondition(ctx, loopId)
-          if (!shouldExecute) {
-            logger.info('Loop initial condition false, skipping loop body', { loopId })
-            return {
-              sentinelStart: true,
-              shouldExit: true,
-              selectedRoute: EDGE.LOOP_EXIT,
-            }
+        const shouldExecute = await this.loopOrchestrator.evaluateInitialCondition(ctx, subflowId)
+        if (!shouldExecute) {
+          logger.info('Loop initial condition false, skipping loop body', { loopId: subflowId })
+          return {
+            sentinelStart: true,
+            shouldExit: true,
+            selectedRoute: EDGE.LOOP_EXIT,
           }
         }
         return { sentinelStart: true }
       }
 
       case 'end': {
-        if (!loopId) {
-          logger.warn('Sentinel end called without loopId')
-          return { shouldExit: true, selectedRoute: EDGE.LOOP_EXIT }
-        }
-
-        const continuationResult = await this.loopOrchestrator.evaluateLoopContinuation(ctx, loopId)
+        const continuationResult = await this.loopOrchestrator.evaluateLoopContinuation(
+          ctx,
+          subflowId
+        )
 
         if (continuationResult.shouldContinue) {
           return {
@@ -161,13 +185,8 @@ export class NodeExecutionOrchestrator {
     ctx: ExecutionContext,
     node: DAGNode,
     sentinelType: string | undefined,
-    parallelId: string | undefined
+    parallelId: string
   ): Promise<NormalizedBlockOutput> {
-    if (!parallelId) {
-      logger.warn('Parallel sentinel called without parallelId')
-      return {}
-    }
-
     if (sentinelType === 'start') {
       if (!this.parallelOrchestrator.getParallelScope(ctx, parallelId)) {
         const parallelConfig = this.dag.parallelConfigs.get(parallelId)
@@ -186,6 +205,7 @@ export class NodeExecutionOrchestrator {
         }
       }
 
+      this.parallelOrchestrator.prepareCurrentBatch(ctx, parallelId)
       return { sentinelStart: true }
     }
 
@@ -222,18 +242,21 @@ export class NodeExecutionOrchestrator {
       return
     }
 
-    const loopId = node.metadata.loopId
+    const loopId = node.metadata.subflowType === 'loop' ? node.metadata.subflowId : undefined
     const isParallelBranch = node.metadata.isParallelBranch
     const isSentinel = node.metadata.isSentinel
     if (isSentinel) {
       this.handleRegularNodeCompletion(ctx, node, output)
+      this.handleParentSubflowCompletion(ctx, node, output)
     } else if (loopId) {
       this.handleLoopNodeCompletion(ctx, node, output, loopId)
     } else if (isParallelBranch) {
-      const parallelId = this.findParallelIdForNode(node.id)
+      const parallelId =
+        node.metadata.subflowType === 'parallel' ? node.metadata.subflowId : undefined
       if (parallelId) {
         await this.handleParallelNodeCompletion(ctx, node, output, parallelId)
       } else {
+        logger.warn('Parallel branch missing subflow metadata', { nodeId: node.id })
         this.handleRegularNodeCompletion(ctx, node, output)
       }
     } else {
@@ -262,9 +285,60 @@ export class NodeExecutionOrchestrator {
       await this.parallelOrchestrator.initializeParallelScope(ctx, parallelId)
     }
     this.parallelOrchestrator.handleParallelBranchCompletion(ctx, parallelId, node.id, output)
+    const branchIndex = node.metadata.branchIndex
+    if (branchIndex !== undefined && extractOuterBranchIndex(node.id) === undefined) {
+      const originalBlockId = node.metadata.originalBlockId ?? extractBaseBlockId(node.id)
+      this.state.setBlockOutput(buildOuterBranchScopedId(originalBlockId, branchIndex), output)
+    }
     this.state.setBlockOutput(node.id, output)
   }
 
+  private handleParentSubflowCompletion(
+    ctx: ExecutionContext,
+    node: DAGNode,
+    output: NormalizedBlockOutput
+  ): void {
+    if (node.metadata.sentinelType !== 'end' || !node.metadata.subflowId) {
+      return
+    }
+
+    if (
+      output.selectedRoute === EDGE.LOOP_CONTINUE ||
+      output.selectedRoute === EDGE.LOOP_CONTINUE_ALT ||
+      output.selectedRoute === EDGE.PARALLEL_CONTINUE
+    ) {
+      return
+    }
+
+    const subflowId = node.metadata.subflowId
+    const parentEntry = ctx.subflowParentMap?.get(subflowId)
+    if (!parentEntry) {
+      return
+    }
+
+    if (parentEntry.parentType === 'parallel') {
+      if (parentEntry.branchIndex === undefined) {
+        return
+      }
+
+      this.parallelOrchestrator.handleParallelBranchCompletion(
+        ctx,
+        parentEntry.parentId,
+        node.id,
+        getSubflowResultOutput(output),
+        parentEntry.branchIndex
+      )
+      return
+    }
+
+    this.loopOrchestrator.storeLoopNodeOutput(
+      ctx,
+      parentEntry.parentId,
+      subflowId,
+      getSubflowResultOutput(output)
+    )
+  }
+
   private handleRegularNodeCompletion(
     ctx: ExecutionContext,
     node: DAGNode,
@@ -274,27 +348,30 @@ export class NodeExecutionOrchestrator {
 
     if (
       node.metadata.isSentinel &&
+      node.metadata.subflowType === 'loop' &&
       node.metadata.sentinelType === 'end' &&
       output.selectedRoute === 'loop_continue'
     ) {
-      const loopId = node.metadata.loopId
-      if (loopId) {
-        this.loopOrchestrator.clearLoopExecutionState(loopId, ctx)
-        this.loopOrchestrator.restoreLoopEdges(loopId)
+      const loopId = node.metadata.subflowId
+      if (!loopId) {
+        logger.warn('Loop sentinel missing subflow metadata', { nodeId: node.id })
+        return
       }
+      this.loopOrchestrator.clearLoopExecutionState(loopId, ctx)
+      this.loopOrchestrator.restoreLoopEdges(loopId)
     }
 
     if (
-      node.metadata.isParallelSentinel &&
+      node.metadata.subflowType === 'parallel' &&
       node.metadata.sentinelType === 'end' &&
       output.selectedRoute === EDGE.PARALLEL_CONTINUE
     ) {
-      this.state.deleteBlockState(node.id)
+      const parallelId = node.metadata.subflowId
+      if (!parallelId) {
+        logger.warn('Parallel sentinel missing subflow metadata', { nodeId: node.id })
+        return
+      }
+      this.parallelOrchestrator.prepareForBatchContinuation(parallelId)
     }
   }
-
-  private findParallelIdForNode(nodeId: string): string | undefined {
-    const baseId = extractBaseBlockId(nodeId)
-    return this.parallelOrchestrator.findParallelIdForNode(baseId)
-  }
 }
diff --git a/apps/sim/executor/orchestrators/parallel.test.ts b/apps/sim/executor/orchestrators/parallel.test.ts
index 96aa1ae684d..40f1d0fa11e 100644
--- a/apps/sim/executor/orchestrators/parallel.test.ts
+++ b/apps/sim/executor/orchestrators/parallel.test.ts
@@ -2,11 +2,18 @@
  * @vitest-environment node
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { DAG } from '@/executor/dag/builder'
+import { DEFAULTS } from '@/executor/constants'
+import type { DAG, DAGNode } from '@/executor/dag/builder'
 import type { BlockStateWriter, ContextExtensions } from '@/executor/execution/types'
 import { ParallelOrchestrator } from '@/executor/orchestrators/parallel'
 import type { ExecutionContext } from '@/executor/types'
-import { buildBranchNodeId } from '@/executor/utils/subflow-utils'
+import {
+  buildBranchNodeId,
+  buildParallelSentinelEndId,
+  buildParallelSentinelStartId,
+  buildSentinelEndId,
+  buildSentinelStartId,
+} from '@/executor/utils/subflow-utils'
 
 const { mockCompactSubflowResults } = vi.hoisted(() => ({
   mockCompactSubflowResults: vi.fn(async (results: unknown) => results),
@@ -34,6 +41,24 @@ function createDag(): DAG {
   }
 }
 
+function createDagNode(id: string, metadata: DAGNode['metadata'] = {}): DAGNode {
+  return {
+    id,
+    block: {
+      id,
+      position: { x: 0, y: 0 },
+      config: { tool: '', params: {} },
+      inputs: {},
+      outputs: {},
+      metadata: { id: 'function', name: id },
+      enabled: true,
+    },
+    incomingEdges: new Set(),
+    outgoingEdges: new Map(),
+    metadata,
+  }
+}
+
 function createState(): BlockStateWriter {
   return {
     setBlockOutput: vi.fn(),
@@ -43,6 +68,12 @@ function createState(): BlockStateWriter {
   }
 }
 
+function createEdgeManager() {
+  return {
+    clearDeactivatedEdgesForNodes: vi.fn(),
+  }
+}
+
 function createContext(overrides: Partial<ExecutionContext> = {}): ExecutionContext {
   return {
     workflowId: 'workflow-1',
@@ -87,14 +118,8 @@ describe('ParallelOrchestrator', () => {
     mockCompactSubflowResults.mockImplementation(async (results: unknown) => results)
   })
 
-  it('awaits empty-subflow lifecycle callbacks before returning the empty scope', async () => {
-    let releaseStart: (() => void) | undefined
-    const onBlockStart = vi.fn(
-      () =>
-        new Promise<void>((resolve) => {
-          releaseStart = resolve
-        })
-    )
+  it('defers empty-subflow lifecycle callbacks to the sentinel end path', async () => {
+    const onBlockStart = vi.fn()
     const onBlockComplete = vi.fn()
     const contextExtensions: ContextExtensions = {
       onBlockStart,
@@ -108,19 +133,14 @@ describe('ParallelOrchestrator', () => {
     )
     const ctx = createContext()
 
-    const initializePromise = orchestrator.initializeParallelScope(ctx, 'parallel-1')
-    await vi.waitFor(() => expect(onBlockStart).toHaveBeenCalledTimes(1))
+    const scope = await orchestrator.initializeParallelScope(ctx, 'parallel-1')
 
+    expect(onBlockStart).not.toHaveBeenCalled()
     expect(onBlockComplete).not.toHaveBeenCalled()
-
-    releaseStart?.()
-    const scope = await initializePromise
-
-    expect(onBlockComplete).toHaveBeenCalledTimes(1)
     expect(scope.isEmpty).toBe(true)
   })
 
-  it('swallows helper callback failures on empty parallel paths', async () => {
+  it('returns an empty scope without emitting start-side lifecycle callbacks', async () => {
     const contextExtensions: ContextExtensions = {
       onBlockStart: vi.fn().mockRejectedValue(new Error('start failed')),
       onBlockComplete: vi.fn().mockRejectedValue(new Error('complete failed')),
@@ -138,6 +158,36 @@ describe('ParallelOrchestrator', () => {
       parallelId: 'parallel-1',
       isEmpty: true,
     })
+    expect(contextExtensions.onBlockStart).not.toHaveBeenCalled()
+    expect(contextExtensions.onBlockComplete).not.toHaveBeenCalled()
+  })
+
+  it('resolves collection distributions with the parallel start sentinel scope', async () => {
+    const dag = createDag()
+    const parallelConfig = dag.parallelConfigs.get('parallel-1')!
+    parallelConfig.distribution = '<Producer.items>'
+    const resolver = {
+      resolveSingleReference: vi.fn().mockResolvedValue(['item-1', 'item-2']),
+    }
+    const orchestrator = new ParallelOrchestrator(
+      dag,
+      createState(),
+      resolver as any,
+      {},
+      undefined,
+      createEdgeManager() as any
+    )
+
+    const scope = await orchestrator.initializeParallelScope(createContext(), 'parallel-1')
+
+    expect(resolver.resolveSingleReference).toHaveBeenCalledWith(
+      expect.any(Object),
+      'parallel-parallel-1-sentinel-start',
+      '<Producer.items>',
+      undefined,
+      { allowLargeValueRefs: true }
+    )
+    expect(scope.totalBranches).toBe(2)
   })
 
   it('records resumed later-batch outputs under restored global branch indexes', () => {
@@ -184,6 +234,116 @@ describe('ParallelOrchestrator', () => {
     expect(scope?.branchOutputs.has(0)).toBe(false)
   })
 
+  it('clamps batch size and caps current batch to total branch count', async () => {
+    const dag = createDag()
+    const parallelConfig = dag.parallelConfigs.get('parallel-1')!
+    parallelConfig.parallelType = 'count'
+    parallelConfig.count = 9
+    parallelConfig.batchSize = 0
+
+    const orchestrator = new ParallelOrchestrator(dag, createState(), null, {})
+    const zeroBatchScope = await orchestrator.initializeParallelScope(createContext(), 'parallel-1')
+
+    expect(zeroBatchScope.batchSize).toBe(1)
+    expect(zeroBatchScope.currentBatchSize).toBe(1)
+
+    parallelConfig.batchSize = 50
+    const oversizedBatchScope = await orchestrator.initializeParallelScope(
+      createContext(),
+      'parallel-1'
+    )
+
+    expect(oversizedBatchScope.currentBatchSize).toBe(9)
+  })
+
+  it.each([
+    ['oversized numeric batch size', 999, DEFAULTS.MAX_PARALLEL_BRANCHES],
+    ['negative batch size', -1, 1],
+    ['undefined batch size', undefined, DEFAULTS.MAX_PARALLEL_BRANCHES],
+    ['nonnumeric batch size', 'not-a-number', DEFAULTS.MAX_PARALLEL_BRANCHES],
+  ])('normalizes %s', async (_name, batchSize, expectedBatchSize) => {
+    const dag = createDag()
+    const parallelConfig = dag.parallelConfigs.get('parallel-1')!
+    parallelConfig.parallelType = 'count'
+    parallelConfig.count = DEFAULTS.MAX_PARALLEL_BRANCHES + 10
+    parallelConfig.batchSize = batchSize as never
+
+    const orchestrator = new ParallelOrchestrator(dag, createState(), null, {})
+    const scope = await orchestrator.initializeParallelScope(createContext(), 'parallel-1')
+
+    expect(scope.batchSize).toBe(expectedBatchSize)
+    expect(scope.currentBatchSize).toBe(expectedBatchSize)
+  })
+
+  it('advances batch state at sentinel end and prepares the next batch at sentinel start', async () => {
+    const dag = createDag()
+    const templateBranchId = buildBranchNodeId('task-1', 0)
+    const secondBranchId = buildBranchNodeId('task-1', 1)
+    dag.nodes.set(templateBranchId, {
+      id: templateBranchId,
+      block: {
+        id: 'task-1',
+        position: { x: 0, y: 0 },
+        config: { tool: '', params: {} },
+        inputs: {},
+        outputs: {},
+        metadata: { id: 'function', name: 'Task 1' },
+        enabled: true,
+      },
+      incomingEdges: new Set(),
+      outgoingEdges: new Map(),
+      metadata: {
+        subflowId: 'parallel-1',
+        subflowType: 'parallel',
+        isParallelBranch: true,
+        branchIndex: 0,
+      },
+    })
+    const state = createState()
+    const edgeManager = createEdgeManager()
+    const orchestrator = new ParallelOrchestrator(dag, state, null, {}, edgeManager)
+    const scope = {
+      parallelId: 'parallel-1',
+      totalBranches: 4,
+      batchSize: 2,
+      currentBatchStart: 0,
+      currentBatchSize: 2,
+      accumulatedOutputs: new Map<number, any[]>(),
+      branchOutputs: new Map<number, any[]>([
+        [0, [{ output: 'branch-0' }]],
+        [1, [{ output: 'branch-1' }]],
+      ]),
+    }
+    const ctx = createContext({
+      parallelExecutions: new Map([['parallel-1', scope]]),
+    })
+
+    const result = await orchestrator.aggregateParallelResults(ctx, 'parallel-1')
+
+    expect(result.allBranchesComplete).toBe(false)
+    expect(scope.currentBatchStart).toBe(2)
+    expect(scope.currentBatchSize).toBe(2)
+    expect(ctx.parallelBlockMapping?.size ?? 0).toBe(0)
+
+    orchestrator.prepareCurrentBatch(ctx, 'parallel-1')
+
+    expect(ctx.parallelBlockMapping?.get(templateBranchId)).toMatchObject({
+      originalBlockId: 'task-1',
+      parallelId: 'parallel-1',
+      iterationIndex: 2,
+    })
+    expect(ctx.parallelBlockMapping?.get(secondBranchId)).toMatchObject({
+      originalBlockId: 'task-1',
+      parallelId: 'parallel-1',
+      iterationIndex: 3,
+    })
+    expect(state.deleteBlockState).toHaveBeenCalledWith(templateBranchId)
+    expect(state.deleteBlockState).toHaveBeenCalledWith(secondBranchId)
+    expect(edgeManager.clearDeactivatedEdgesForNodes).toHaveBeenCalledWith(
+      new Set([templateBranchId, secondBranchId])
+    )
+  })
+
   it('resets only incoming batch branch state when scheduling later batches', async () => {
     const dag = createDag()
     const incomingBranchId = buildBranchNodeId('task-1', 0)
@@ -201,7 +361,12 @@ describe('ParallelOrchestrator', () => {
       },
       incomingEdges: new Set(),
       outgoingEdges: new Set(),
-      metadata: { parallelId: 'parallel-1', isParallelBranch: true, branchIndex: 0 },
+      metadata: {
+        subflowId: 'parallel-1',
+        subflowType: 'parallel',
+        isParallelBranch: true,
+        branchIndex: 0,
+      },
     })
     dag.nodes.set(previousBranchId, {
       id: previousBranchId,
@@ -216,36 +381,34 @@ describe('ParallelOrchestrator', () => {
       },
       incomingEdges: new Set(),
       outgoingEdges: new Set(),
-      metadata: { parallelId: 'parallel-1', isParallelBranch: true, branchIndex: 1 },
+      metadata: {
+        subflowId: 'parallel-1',
+        subflowType: 'parallel',
+        isParallelBranch: true,
+        branchIndex: 1,
+      },
     })
     const state = createState()
     const orchestrator = new ParallelOrchestrator(dag, state, null, {})
 
-    await (
-      orchestrator as unknown as {
-        scheduleNextBatch(
-          ctx: ExecutionContext,
-          scope: NonNullable<ExecutionContext['parallelExecutions']> extends Map<
-            string,
-            infer Scope
-          >
-            ? Scope
-            : never,
-          nextBatchStart: number
-        ): Promise<void>
-      }
-    ).scheduleNextBatch(
-      createContext(),
-      {
-        parallelId: 'parallel-1',
-        totalBranches: 3,
-        batchSize: 1,
-        currentBatchStart: 0,
-        currentBatchSize: 2,
-        accumulatedOutputs: new Map([[1, [{ output: 'previous' }]]]),
-        branchOutputs: new Map(),
-      },
-      2
+    orchestrator.prepareCurrentBatch(
+      createContext({
+        parallelExecutions: new Map([
+          [
+            'parallel-1',
+            {
+              parallelId: 'parallel-1',
+              totalBranches: 3,
+              batchSize: 1,
+              currentBatchStart: 2,
+              currentBatchSize: 1,
+              accumulatedOutputs: new Map([[1, [{ output: 'previous' }]]]),
+              branchOutputs: new Map(),
+            },
+          ],
+        ]),
+      }),
+      'parallel-1'
     )
 
     expect(state.deleteBlockState).toHaveBeenCalledWith(incomingBranchId)
@@ -254,6 +417,139 @@ describe('ParallelOrchestrator', () => {
     expect(state.unmarkExecuted).not.toHaveBeenCalledWith(previousBranchId)
   })
 
+  it('marks expanded branch nodes dirty when running from a dirty parallel container', () => {
+    const dag = createDag()
+    const templateBranchId = buildBranchNodeId('task-1', 0)
+    const secondBranchId = buildBranchNodeId('task-1', 1)
+    dag.nodes.set(templateBranchId, {
+      id: templateBranchId,
+      block: {
+        id: 'task-1',
+        position: { x: 0, y: 0 },
+        config: { tool: '', params: {} },
+        inputs: {},
+        outputs: {},
+        metadata: { id: 'function', name: 'Task 1' },
+        enabled: true,
+      },
+      incomingEdges: new Set(),
+      outgoingEdges: new Map(),
+      metadata: {
+        subflowId: 'parallel-1',
+        subflowType: 'parallel',
+        isParallelBranch: true,
+        branchIndex: 0,
+      },
+    })
+    const dirtySet = new Set(['parallel-1'])
+    const orchestrator = new ParallelOrchestrator(dag, createState(), null, {})
+
+    orchestrator.prepareCurrentBatch(
+      createContext({
+        runFromBlockContext: { startBlockId: 'parallel-1', dirtySet },
+        parallelExecutions: new Map([
+          [
+            'parallel-1',
+            {
+              parallelId: 'parallel-1',
+              totalBranches: 2,
+              batchSize: 2,
+              currentBatchStart: 0,
+              currentBatchSize: 2,
+              branchOutputs: new Map(),
+            },
+          ],
+        ]),
+      }),
+      'parallel-1'
+    )
+
+    expect(dirtySet.has(templateBranchId)).toBe(true)
+    expect(dirtySet.has(secondBranchId)).toBe(true)
+  })
+
+  it('marks cloned nested loop body nodes dirty for non-zero branches', () => {
+    const dag = createDag()
+    const parallelId = 'parallel-1'
+    const loopId = 'loop-1'
+    const taskId = 'task-1'
+    const parallelStartId = buildParallelSentinelStartId(parallelId)
+    const parallelEndId = buildParallelSentinelEndId(parallelId)
+    const loopStartId = buildSentinelStartId(loopId)
+    const loopEndId = buildSentinelEndId(loopId)
+
+    dag.parallelConfigs.set(parallelId, {
+      id: parallelId,
+      nodes: [loopId],
+      count: 2,
+      parallelType: 'count',
+    })
+    dag.loopConfigs.set(loopId, {
+      id: loopId,
+      nodes: [taskId],
+      loopType: 'for',
+      iterations: 1,
+    })
+    dag.nodes.set(parallelStartId, createDagNode(parallelStartId))
+    dag.nodes.set(parallelEndId, createDagNode(parallelEndId))
+    dag.nodes.set(
+      loopStartId,
+      createDagNode(loopStartId, {
+        isSentinel: true,
+        sentinelType: 'start',
+        subflowId: loopId,
+        subflowType: 'loop',
+      })
+    )
+    dag.nodes.set(
+      taskId,
+      createDagNode(taskId, {
+        isLoopNode: true,
+        subflowId: loopId,
+        subflowType: 'loop',
+        originalBlockId: taskId,
+      })
+    )
+    dag.nodes.set(
+      loopEndId,
+      createDagNode(loopEndId, {
+        isSentinel: true,
+        sentinelType: 'end',
+        subflowId: loopId,
+        subflowType: 'loop',
+      })
+    )
+    dag.nodes.get(loopStartId)!.outgoingEdges.set(`${loopStartId}->${taskId}`, { target: taskId })
+    dag.nodes.get(taskId)!.incomingEdges.add(loopStartId)
+    dag.nodes.get(taskId)!.outgoingEdges.set(`${taskId}->${loopEndId}`, { target: loopEndId })
+    dag.nodes.get(loopEndId)!.incomingEdges.add(taskId)
+
+    const dirtySet = new Set([parallelId])
+    const orchestrator = new ParallelOrchestrator(dag, createState(), null, {})
+    orchestrator.prepareCurrentBatch(
+      createContext({
+        runFromBlockContext: { startBlockId: parallelId, dirtySet },
+        parallelExecutions: new Map([
+          [
+            parallelId,
+            {
+              parallelId,
+              totalBranches: 2,
+              batchSize: 2,
+              currentBatchStart: 0,
+              currentBatchSize: 2,
+              branchOutputs: new Map(),
+            },
+          ],
+        ]),
+      }),
+      parallelId
+    )
+
+    expect([...dirtySet]).toContain(taskId)
+    expect([...dirtySet].some((nodeId) => nodeId.startsWith(`${taskId}__clone`))).toBe(true)
+  })
+
   it('compacts accumulated outputs before scheduling later batches', async () => {
     const dag = createDag()
     const templateBranchId = buildBranchNodeId('task-1', 0)
@@ -270,7 +566,12 @@ describe('ParallelOrchestrator', () => {
       },
       incomingEdges: new Set(),
       outgoingEdges: new Set(),
-      metadata: { parallelId: 'parallel-1', isParallelBranch: true, branchIndex: 0 },
+      metadata: {
+        subflowId: 'parallel-1',
+        subflowType: 'parallel',
+        isParallelBranch: true,
+        branchIndex: 0,
+      },
     })
     const orchestrator = new ParallelOrchestrator(dag, createState(), null, {})
     const previousOutputs = [{ output: 'previous' }]
diff --git a/apps/sim/executor/orchestrators/parallel.ts b/apps/sim/executor/orchestrators/parallel.ts
index 36e5b124589..933bc1f3129 100644
--- a/apps/sim/executor/orchestrators/parallel.ts
+++ b/apps/sim/executor/orchestrators/parallel.ts
@@ -3,15 +3,20 @@ import { toError } from '@sim/utils/errors'
 import { compactSubflowResults } from '@/lib/execution/payloads/serializer'
 import { DEFAULTS } from '@/executor/constants'
 import type { DAG } from '@/executor/dag/builder'
+import type { EdgeManager } from '@/executor/execution/edge-manager'
 import type { ParallelScope } from '@/executor/execution/state'
 import type { BlockStateWriter, ContextExtensions } from '@/executor/execution/types'
 import type { ExecutionContext, NormalizedBlockOutput } from '@/executor/types'
-import type { ParallelConfigWithNodes } from '@/executor/types/parallel'
 import { type ClonedSubflowInfo, ParallelExpander } from '@/executor/utils/parallel-expansion'
 import {
   addSubflowErrorLog,
-  emitEmptySubflowEvents,
+  buildBranchNodeId,
+  buildParallelSentinelEndId,
+  buildParallelSentinelStartId,
+  buildSentinelEndId,
+  buildSentinelStartId,
   emitSubflowSuccessEvents,
+  extractBaseBlockId,
   extractBranchIndex,
 } from '@/executor/utils/subflow-utils'
 import { resolveArrayInputAsync } from '@/executor/utils/subflow-utils.server'
@@ -42,7 +47,8 @@ export class ParallelOrchestrator {
     private dag: DAG,
     private state: BlockStateWriter,
     private resolver: VariableResolver | null = null,
-    private contextExtensions: ContextExtensions | null = null
+    private contextExtensions: ContextExtensions | null = null,
+    private edgeManager: Pick<EdgeManager, 'clearDeactivatedEdgesForNodes'> | null = null
   ) {}
 
   async initializeParallelScope(ctx: ExecutionContext, parallelId: string): Promise<ParallelScope> {
@@ -96,10 +102,6 @@ export class ParallelOrchestrator {
       }
       ctx.parallelExecutions.set(parallelId, scope)
 
-      this.state.setBlockOutput(parallelId, { results: [] })
-
-      await emitEmptySubflowEvents(ctx, parallelId, 'parallel', this.contextExtensions)
-
       logger.info('Parallel scope initialized with empty distribution, skipping body', {
         parallelId,
         branchCount: 0,
@@ -110,18 +112,6 @@ export class ParallelOrchestrator {
 
     const batchSize = this.resolveBatchSize(parallelConfig.batchSize)
     const currentBatchSize = Math.min(batchSize, branchCount)
-    const batchItems = items?.slice(0, currentBatchSize)
-    const { entryNodes, clonedSubflows, allBranchNodes } = this.expander.expandParallel(
-      this.dag,
-      parallelId,
-      currentBatchSize,
-      batchItems,
-      { branchIndexOffset: 0, totalBranches: branchCount }
-    )
-
-    this.registerClonedSubflows(ctx, parallelId, clonedSubflows)
-    this.registerBranchMappings(ctx, parallelId, allBranchNodes)
-
     const scope: ParallelScope = {
       parallelId,
       totalBranches: branchCount,
@@ -138,26 +128,60 @@ export class ParallelOrchestrator {
     }
     ctx.parallelExecutions.set(parallelId, scope)
 
-    const newEntryNodes = entryNodes.filter((nodeId) => !nodeId.endsWith('__branch-0'))
-    if (newEntryNodes.length > 0) {
-      if (!ctx.pendingDynamicNodes) {
-        ctx.pendingDynamicNodes = []
-      }
-      ctx.pendingDynamicNodes.push(...newEntryNodes)
-    }
-
     logger.info('Parallel scope initialized', {
       parallelId,
       branchCount,
       batchSize,
       currentBatchSize,
-      entryNodeCount: entryNodes.length,
-      newEntryNodes: newEntryNodes.length,
     })
 
     return scope
   }
 
+  prepareCurrentBatch(ctx: ExecutionContext, parallelId: string): void {
+    const scope = ctx.parallelExecutions?.get(parallelId)
+    if (!scope || scope.isEmpty) {
+      return
+    }
+
+    const currentBatchStart = scope.currentBatchStart ?? 0
+    const currentBatchSize =
+      scope.currentBatchSize ??
+      Math.min(scope.batchSize ?? DEFAULT_PARALLEL_BATCH_SIZE, scope.totalBranches)
+
+    if (currentBatchSize <= 0) {
+      return
+    }
+
+    const batchItems = scope.items?.slice(currentBatchStart, currentBatchStart + currentBatchSize)
+    const { clonedSubflows, allBranchNodes, entryNodes, terminalNodes } =
+      this.expander.expandParallel(this.dag, parallelId, currentBatchSize, batchItems, {
+        branchIndexOffset: currentBatchStart,
+        totalBranches: scope.totalBranches,
+      })
+
+    this.markRunFromBlockBatchDirty(
+      ctx,
+      parallelId,
+      allBranchNodes,
+      entryNodes,
+      terminalNodes,
+      clonedSubflows
+    )
+    this.registerClonedSubflows(ctx, parallelId, clonedSubflows)
+    this.registerBranchMappings(ctx, parallelId, allBranchNodes)
+    this.resetBatchExecutionState(allBranchNodes)
+    this.edgeManager?.clearDeactivatedEdgesForNodes(new Set(allBranchNodes))
+
+    logger.info('Prepared parallel batch', {
+      parallelId,
+      currentBatchStart,
+      currentBatchSize,
+      totalBranches: scope.totalBranches,
+      branchNodeCount: allBranchNodes.length,
+    })
+  }
+
   private async resolveBranchCount(
     ctx: ExecutionContext,
     config: SerializedParallel,
@@ -219,7 +243,12 @@ export class ParallelOrchestrator {
         'Parallel collection distribution is empty. Provide an array or a reference that resolves to a collection.'
       )
     }
-    return resolveArrayInputAsync(ctx, config.distribution, this.resolver)
+    return resolveArrayInputAsync(
+      ctx,
+      config.distribution,
+      this.resolver,
+      buildParallelSentinelStartId(config.id)
+    )
   }
 
   private resolveBatchSize(batchSize: unknown): number {
@@ -278,6 +307,78 @@ export class ParallelOrchestrator {
     }
   }
 
+  private markRunFromBlockBatchDirty(
+    ctx: ExecutionContext,
+    parallelId: string,
+    allBranchNodes: string[],
+    entryNodes: string[],
+    terminalNodes: string[],
+    clonedSubflows: ClonedSubflowInfo[]
+  ): void {
+    const dirtySet = ctx.runFromBlockContext?.dirtySet
+    if (!dirtySet) return
+
+    const parallelStartId = buildParallelSentinelStartId(parallelId)
+    const parallelEndId = buildParallelSentinelEndId(parallelId)
+    if (
+      !dirtySet.has(parallelId) &&
+      !dirtySet.has(parallelStartId) &&
+      !dirtySet.has(parallelEndId)
+    ) {
+      return
+    }
+
+    for (const nodeId of allBranchNodes) dirtySet.add(nodeId)
+    for (const nodeId of entryNodes) dirtySet.add(nodeId)
+    for (const nodeId of terminalNodes) dirtySet.add(nodeId)
+
+    const config = this.dag.parallelConfigs.get(parallelId)
+    for (const nodeId of config?.nodes ?? []) {
+      if (this.dag.parallelConfigs.has(nodeId) || this.dag.loopConfigs.has(nodeId)) {
+        this.collectSubflowNodeIds(nodeId, dirtySet)
+      }
+    }
+
+    for (const clone of clonedSubflows) {
+      dirtySet.add(clone.clonedId)
+      this.collectSubflowNodeIds(clone.clonedId, dirtySet)
+    }
+  }
+
+  private collectSubflowNodeIds(
+    subflowId: string,
+    nodeIds: Set<string>,
+    visited = new Set<string>()
+  ): void {
+    if (visited.has(subflowId)) return
+    visited.add(subflowId)
+
+    if (this.dag.parallelConfigs.has(subflowId)) {
+      nodeIds.add(buildParallelSentinelStartId(subflowId))
+      nodeIds.add(buildParallelSentinelEndId(subflowId))
+      for (const childId of this.dag.parallelConfigs.get(subflowId)?.nodes ?? []) {
+        if (this.dag.parallelConfigs.has(childId) || this.dag.loopConfigs.has(childId)) {
+          this.collectSubflowNodeIds(childId, nodeIds, visited)
+        } else {
+          nodeIds.add(buildBranchNodeId(childId, 0))
+        }
+      }
+      return
+    }
+
+    if (this.dag.loopConfigs.has(subflowId)) {
+      nodeIds.add(buildSentinelStartId(subflowId))
+      nodeIds.add(buildSentinelEndId(subflowId))
+      for (const childId of this.dag.loopConfigs.get(subflowId)?.nodes ?? []) {
+        if (this.dag.parallelConfigs.has(childId) || this.dag.loopConfigs.has(childId)) {
+          this.collectSubflowNodeIds(childId, nodeIds, visited)
+        } else {
+          nodeIds.add(childId)
+        }
+      }
+    }
+  }
+
   /**
    * Stores a node's output in the branch outputs for later aggregation.
    * Aggregation is triggered by the sentinel-end node via the edge mechanism,
@@ -288,7 +389,8 @@ export class ParallelOrchestrator {
     ctx: ExecutionContext,
     parallelId: string,
     nodeId: string,
-    output: NormalizedBlockOutput
+    output: NormalizedBlockOutput,
+    branchIndexOverride?: number
   ): void {
     const scope = ctx.parallelExecutions?.get(parallelId)
     if (!scope) {
@@ -298,9 +400,10 @@ export class ParallelOrchestrator {
 
     const mappedBranch = ctx.parallelBlockMapping?.get(nodeId)
     const branchIndex =
-      mappedBranch?.parallelId === parallelId
+      branchIndexOverride ??
+      (mappedBranch?.parallelId === parallelId
         ? mappedBranch.iterationIndex
-        : (this.dag.nodes.get(nodeId)?.metadata.branchIndex ?? extractBranchIndex(nodeId))
+        : (this.dag.nodes.get(nodeId)?.metadata.branchIndex ?? extractBranchIndex(nodeId)))
     if (branchIndex === null) {
       logger.warn('Could not extract branch index from node ID', { nodeId })
       return
@@ -360,7 +463,7 @@ export class ParallelOrchestrator {
           accumulatedOutputs.set(branchIdx, compactedAccumulated[position])
         })
       }
-      await this.scheduleNextBatch(ctx, scope, nextBatchStart)
+      this.advanceToNextBatch(scope, nextBatchStart)
       return {
         allBranchesComplete: false,
         completedBranches: accumulatedOutputs.size,
@@ -400,37 +503,15 @@ export class ParallelOrchestrator {
     }
   }
 
-  private async scheduleNextBatch(
-    ctx: ExecutionContext,
-    scope: ParallelScope,
-    nextBatchStart: number
-  ): Promise<void> {
+  private advanceToNextBatch(scope: ParallelScope, nextBatchStart: number): void {
     const batchSize = scope.batchSize ?? DEFAULT_PARALLEL_BATCH_SIZE
     const remaining = scope.totalBranches - nextBatchStart
     const currentBatchSize = Math.min(batchSize, remaining)
-    const batchItems = scope.items?.slice(nextBatchStart, nextBatchStart + currentBatchSize)
-
-    const { entryNodes, clonedSubflows, allBranchNodes } = this.expander.expandParallel(
-      this.dag,
-      scope.parallelId,
-      currentBatchSize,
-      batchItems,
-      { branchIndexOffset: nextBatchStart, totalBranches: scope.totalBranches }
-    )
-
-    this.registerClonedSubflows(ctx, scope.parallelId, clonedSubflows)
-    this.registerBranchMappings(ctx, scope.parallelId, allBranchNodes)
-    this.resetBatchExecutionState(allBranchNodes)
 
     scope.currentBatchStart = nextBatchStart
     scope.currentBatchSize = currentBatchSize
 
-    if (!ctx.pendingDynamicNodes) {
-      ctx.pendingDynamicNodes = []
-    }
-    ctx.pendingDynamicNodes.push(...entryNodes)
-
-    logger.info('Scheduled next parallel batch', {
+    logger.info('Advanced to next parallel batch', {
       parallelId: scope.parallelId,
       nextBatchStart,
       currentBatchSize,
@@ -438,6 +519,12 @@ export class ParallelOrchestrator {
     })
   }
 
+  prepareForBatchContinuation(parallelId: string): void {
+    this.state.unmarkExecuted(buildParallelSentinelStartId(parallelId))
+    this.state.unmarkExecuted(buildParallelSentinelEndId(parallelId))
+    this.state.deleteBlockState(buildParallelSentinelEndId(parallelId))
+  }
+
   private resetBatchExecutionState(branchNodeIds: string[]): void {
     for (const nodeId of branchNodeIds) {
       const node = this.dag.nodes.get(nodeId)
@@ -470,7 +557,7 @@ export class ParallelOrchestrator {
       }
 
       ctx.parallelBlockMapping.set(nodeId, {
-        originalBlockId: node?.metadata.originalBlockId ?? nodeId,
+        originalBlockId: node?.metadata.originalBlockId ?? extractBaseBlockId(nodeId),
         parallelId,
         iterationIndex: branchIndex,
       })
@@ -488,7 +575,8 @@ export class ParallelOrchestrator {
       return null
     }
 
-    const parallelId = node.metadata.parallelId
+    const parallelId =
+      node.metadata.subflowType === 'parallel' ? node.metadata.subflowId : undefined
     if (!parallelId) {
       return null
     }
@@ -504,14 +592,4 @@ export class ParallelOrchestrator {
   getParallelScope(ctx: ExecutionContext, parallelId: string): ParallelScope | undefined {
     return ctx.parallelExecutions?.get(parallelId)
   }
-
-  findParallelIdForNode(baseNodeId: string): string | undefined {
-    for (const [parallelId, config] of this.dag.parallelConfigs) {
-      const parallelConfig = config as ParallelConfigWithNodes
-      if (parallelConfig.nodes?.includes(baseNodeId)) {
-        return parallelId
-      }
-    }
-    return undefined
-  }
 }
diff --git a/apps/sim/executor/types.ts b/apps/sim/executor/types.ts
index ba6e80983f7..4995ad7ea29 100644
--- a/apps/sim/executor/types.ts
+++ b/apps/sim/executor/types.ts
@@ -341,6 +341,7 @@ export interface ExecutionContext {
       items?: any[]
       condition?: string
       skipFirstConditionCheck?: boolean
+      skippedAtStart?: boolean
       loopType?: 'for' | 'forEach' | 'while' | 'doWhile'
     }
   >
@@ -357,6 +358,8 @@ export interface ExecutionContext {
       branchOutputs: Map<number, any[]>
       parallelType?: 'count' | 'collection'
       items?: any[]
+      validationError?: string
+      isEmpty?: boolean
     }
   >
 
@@ -416,9 +419,6 @@ export interface ExecutionContext {
    */
   abortSignal?: AbortSignal
 
-  // Dynamically added nodes that need to be scheduled (e.g., from parallel expansion)
-  pendingDynamicNodes?: string[]
-
   /**
    * When true, UserFile objects in block outputs will be hydrated with base64 content
    * before being stored in execution state. This ensures base64 is available for
diff --git a/apps/sim/executor/utils/block-reference.ts b/apps/sim/executor/utils/block-reference.ts
index 082a9339782..95a49d3d0de 100644
--- a/apps/sim/executor/utils/block-reference.ts
+++ b/apps/sim/executor/utils/block-reference.ts
@@ -1,3 +1,4 @@
+import { HttpError } from '@/lib/core/utils/http-error'
 import { USER_FILE_ACCESSIBLE_PROPERTIES } from '@/lib/workflows/types'
 import { normalizeName } from '@/executor/constants'
 import {
@@ -30,7 +31,7 @@ export interface BlockReferenceResult {
   blockId: string
 }
 
-export class InvalidFieldError extends Error {
+export class InvalidFieldError extends HttpError {
   readonly statusCode = 400
 
   constructor(
diff --git a/apps/sim/executor/utils/iteration-context.test.ts b/apps/sim/executor/utils/iteration-context.test.ts
index 59321a16bc4..a0ac472f8aa 100644
--- a/apps/sim/executor/utils/iteration-context.test.ts
+++ b/apps/sim/executor/utils/iteration-context.test.ts
@@ -50,7 +50,8 @@ describe('getIterationContext', () => {
     const metadata: IterationNodeMetadata = {
       branchIndex: 1,
       branchTotal: 3,
-      parallelId: 'p1',
+      subflowId: 'p1',
+      subflowType: 'parallel',
     }
     const result = getIterationContext(ctx, metadata)
     expect(result).toEqual({
@@ -77,7 +78,8 @@ describe('getIterationContext', () => {
     })
     const metadata: IterationNodeMetadata = {
       isLoopNode: true,
-      loopId: 'l1',
+      subflowId: 'l1',
+      subflowType: 'loop',
     }
     const result = getIterationContext(ctx, metadata)
     expect(result).toEqual({
@@ -124,7 +126,7 @@ describe('buildUnifiedParentIterations', () => {
   it('resolves parallel-in-parallel parent chain', () => {
     const ctx = makeCtx({
       subflowParentMap: new Map([
-        ['inner-p__obranch-2', { parentId: 'outer-p', parentType: 'parallel' }],
+        ['inner-p__obranch-2', { parentId: 'outer-p', parentType: 'parallel', branchIndex: 2 }],
       ]),
       parallelExecutions: new Map([
         [
@@ -151,7 +153,7 @@ describe('buildUnifiedParentIterations', () => {
   it('resolves loop-in-parallel (cross-type nesting)', () => {
     const ctx = makeCtx({
       subflowParentMap: new Map([
-        ['loop-1__obranch-1', { parentId: 'parallel-1', parentType: 'parallel' }],
+        ['loop-1__obranch-1', { parentId: 'parallel-1', parentType: 'parallel', branchIndex: 1 }],
       ]),
       parallelExecutions: new Map([
         [
@@ -205,8 +207,8 @@ describe('buildUnifiedParentIterations', () => {
     const ctx = makeCtx({
       subflowParentMap: new Map([
         ['inner-p', { parentId: 'mid-loop', parentType: 'loop' }],
-        ['mid-loop', { parentId: 'outer-p', parentType: 'parallel' }],
-        ['mid-loop__obranch-2', { parentId: 'outer-p', parentType: 'parallel' }],
+        ['mid-loop', { parentId: 'outer-p', parentType: 'parallel', branchIndex: 0 }],
+        ['mid-loop__obranch-2', { parentId: 'outer-p', parentType: 'parallel', branchIndex: 2 }],
       ]),
       loopExecutions: new Map([
         [
@@ -251,8 +253,8 @@ describe('buildUnifiedParentIterations', () => {
     // P1 → P2 → P3, with P2__obranch-1 and P3__clone0__obranch-1
     const ctx = makeCtx({
       subflowParentMap: new Map([
-        ['P2', { parentId: 'P1', parentType: 'parallel' }],
-        ['P3', { parentId: 'P2', parentType: 'parallel' }],
+        ['P2', { parentId: 'P1', parentType: 'parallel', branchIndex: 0 }],
+        ['P3', { parentId: 'P2', parentType: 'parallel', branchIndex: 0 }],
         ['P2__obranch-1', { parentId: 'P1', parentType: 'parallel', branchIndex: 1 }],
         [
           'P3__clone0__obranch-1',
@@ -340,7 +342,7 @@ describe('buildUnifiedParentIterations', () => {
   it('includes parent iterations in getIterationContext for loop-in-parallel', () => {
     const ctx = makeCtx({
       subflowParentMap: new Map([
-        ['loop-1__obranch-2', { parentId: 'parallel-1', parentType: 'parallel' }],
+        ['loop-1__obranch-2', { parentId: 'parallel-1', parentType: 'parallel', branchIndex: 2 }],
       ]),
       parallelExecutions: new Map([
         [
@@ -367,7 +369,8 @@ describe('buildUnifiedParentIterations', () => {
 
     const metadata: IterationNodeMetadata = {
       isLoopNode: true,
-      loopId: 'loop-1__obranch-2',
+      subflowId: 'loop-1__obranch-2',
+      subflowType: 'loop',
     }
     const result = getIterationContext(ctx, metadata)
     expect(result).toEqual({
@@ -415,7 +418,8 @@ describe('buildUnifiedParentIterations', () => {
     const metadata: IterationNodeMetadata = {
       branchIndex: 1,
       branchTotal: 3,
-      parallelId: 'parallel-1',
+      subflowId: 'parallel-1',
+      subflowType: 'parallel',
     }
     const result = getIterationContext(ctx, metadata)
     expect(result).toEqual({
@@ -451,7 +455,7 @@ describe('buildContainerIterationContext', () => {
   it('resolves loop nested inside parallel', () => {
     const ctx = makeCtx({
       subflowParentMap: new Map([
-        ['loop-1__obranch-2', { parentId: 'parallel-1', parentType: 'parallel' }],
+        ['loop-1__obranch-2', { parentId: 'parallel-1', parentType: 'parallel', branchIndex: 2 }],
       ]),
       parallelExecutions: new Map([
         [
@@ -499,7 +503,9 @@ describe('buildContainerIterationContext', () => {
 
   it('returns undefined when parent scope is missing', () => {
     const ctx = makeCtx({
-      subflowParentMap: new Map([['loop-1', { parentId: 'parallel-1', parentType: 'parallel' }]]),
+      subflowParentMap: new Map([
+        ['loop-1', { parentId: 'parallel-1', parentType: 'parallel', branchIndex: 0 }],
+      ]),
       parallelExecutions: new Map(),
     })
     expect(buildContainerIterationContext(ctx, 'loop-1')).toBeUndefined()
@@ -537,7 +543,7 @@ describe('buildContainerIterationContext', () => {
   it('uses branch index 0 for non-cloned container in parallel parent', () => {
     const ctx = makeCtx({
       subflowParentMap: new Map([
-        ['inner-loop', { parentId: 'outer-parallel', parentType: 'parallel' }],
+        ['inner-loop', { parentId: 'outer-parallel', parentType: 'parallel', branchIndex: 0 }],
       ]),
       parallelExecutions: new Map([
         [
diff --git a/apps/sim/executor/utils/iteration-context.ts b/apps/sim/executor/utils/iteration-context.ts
index edf9a0e517c..17532cec57e 100644
--- a/apps/sim/executor/utils/iteration-context.ts
+++ b/apps/sim/executor/utils/iteration-context.ts
@@ -2,7 +2,7 @@ import { DEFAULTS } from '@/executor/constants'
 import type { NodeMetadata } from '@/executor/dag/types'
 import type { IterationContext, ParentIteration } from '@/executor/execution/types'
 import type { ExecutionContext } from '@/executor/types'
-import { extractOuterBranchIndex, findEffectiveContainerId } from '@/executor/utils/subflow-utils'
+import { findEffectiveContainerId } from '@/executor/utils/subflow-utils'
 
 /** Maximum ancestor depth to prevent runaway traversal in deeply nested subflows. */
 const MAX_PARENT_DEPTH = DEFAULTS.MAX_NESTING_DEPTH
@@ -13,7 +13,7 @@ const MAX_PARENT_DEPTH = DEFAULTS.MAX_NESTING_DEPTH
  */
 export type IterationNodeMetadata = Pick<
   NodeMetadata,
-  'loopId' | 'parallelId' | 'branchIndex' | 'branchTotal' | 'isLoopNode'
+  'subflowType' | 'subflowId' | 'branchIndex' | 'branchTotal' | 'isLoopNode'
 >
 
 /**
@@ -28,27 +28,27 @@ export function getIterationContext(
   if (!metadata) return undefined
 
   if (metadata.branchIndex !== undefined && metadata.branchTotal !== undefined) {
-    const parentIterations = metadata.parallelId
-      ? buildUnifiedParentIterations(ctx, metadata.parallelId)
-      : []
+    const parallelId = metadata.subflowType === 'parallel' ? metadata.subflowId : undefined
+    const parentIterations = parallelId ? buildUnifiedParentIterations(ctx, parallelId) : []
     return {
       iterationCurrent: metadata.branchIndex,
       iterationTotal: metadata.branchTotal,
       iterationType: 'parallel',
-      iterationContainerId: metadata.parallelId,
+      iterationContainerId: parallelId,
       ...(parentIterations.length > 0 && { parentIterations }),
     }
   }
 
-  if (metadata.isLoopNode && metadata.loopId) {
-    const loopScope = ctx.loopExecutions?.get(metadata.loopId)
+  const loopId = metadata.subflowType === 'loop' ? metadata.subflowId : undefined
+  if (metadata.isLoopNode && loopId) {
+    const loopScope = ctx.loopExecutions?.get(loopId)
     if (loopScope && loopScope.iteration !== undefined) {
-      const parentIterations = buildUnifiedParentIterations(ctx, metadata.loopId)
+      const parentIterations = buildUnifiedParentIterations(ctx, loopId)
       return {
         iterationCurrent: loopScope.iteration,
         iterationTotal: loopScope.maxIterations,
         iterationType: 'loop',
-        iterationContainerId: metadata.loopId,
+        iterationContainerId: loopId,
         ...(parentIterations.length > 0 && { parentIterations }),
       }
     }
@@ -70,23 +70,15 @@ export function buildContainerIterationContext(
   if (!parentEntry) return undefined
 
   if (parentEntry.parentType === 'parallel') {
-    // Use stored parentId directly when branchIndex is available (set during expansion),
-    // otherwise fall back to findEffectiveContainerId for backward compatibility.
-    const hasBranchIndex = parentEntry.branchIndex !== undefined
-    const effectiveParentId = hasBranchIndex
-      ? parentEntry.parentId
-      : ctx.parallelExecutions
-        ? findEffectiveContainerId(parentEntry.parentId, containerId, ctx.parallelExecutions)
-        : parentEntry.parentId
-    const parentScope = ctx.parallelExecutions?.get(effectiveParentId)
-    if (parentScope) {
+    if (parentEntry.branchIndex !== undefined) {
+      const parentScope = ctx.parallelExecutions?.get(parentEntry.parentId)
+      if (!parentScope) return undefined
+
       return {
-        iterationCurrent: hasBranchIndex
-          ? parentEntry.branchIndex!
-          : (extractOuterBranchIndex(containerId) ?? 0),
+        iterationCurrent: parentEntry.branchIndex,
         iterationTotal: parentScope.totalBranches,
         iterationType: 'parallel',
-        iterationContainerId: effectiveParentId,
+        iterationContainerId: parentEntry.parentId,
       }
     }
   } else if (parentEntry.parentType === 'loop') {
@@ -150,21 +142,15 @@ export function buildUnifiedParentIterations(
         })
       }
     } else {
-      // Use stored parentId directly when branchIndex is available (set during expansion),
-      // otherwise fall back to findEffectiveContainerId for backward compatibility.
-      const hasBranchIndex = entry.branchIndex !== undefined
-      const effectiveParentId = hasBranchIndex
-        ? parentId
-        : ctx.parallelExecutions
-          ? findEffectiveContainerId(parentId, currentId, ctx.parallelExecutions)
-          : parentId
+      if (entry.branchIndex === undefined) {
+        currentId = parentId
+        continue
+      }
+      const effectiveParentId = parentId
       const parentScope = ctx.parallelExecutions?.get(effectiveParentId)
       if (parentScope) {
-        const outerBranchIndex = hasBranchIndex
-          ? entry.branchIndex!
-          : (extractOuterBranchIndex(currentId) ?? 0)
         parents.unshift({
-          iterationCurrent: outerBranchIndex,
+          iterationCurrent: entry.branchIndex,
           iterationTotal: parentScope.totalBranches,
           iterationType: 'parallel',
           iterationContainerId: effectiveParentId,
diff --git a/apps/sim/executor/utils/parallel-expansion.test.ts b/apps/sim/executor/utils/parallel-expansion.test.ts
index 67f0e865aef..7edb1e6d38f 100644
--- a/apps/sim/executor/utils/parallel-expansion.test.ts
+++ b/apps/sim/executor/utils/parallel-expansion.test.ts
@@ -10,6 +10,7 @@ import {
   buildBranchNodeId,
   buildParallelSentinelEndId,
   buildParallelSentinelStartId,
+  buildSentinelStartId,
   stripCloneSuffixes,
 } from '@/executor/utils/subflow-utils'
 import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
@@ -27,6 +28,55 @@ function createBlock(id: string, metadataId: string): SerializedBlock {
 }
 
 describe('Nested parallel expansion + edge resolution', () => {
+  it('waits for every branch terminal before queuing the parallel end sentinel', () => {
+    const parallelId = 'parallel-1'
+    const taskId = 'task-1'
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [
+        createBlock('start', BlockType.STARTER),
+        createBlock(parallelId, BlockType.PARALLEL),
+        createBlock(taskId, BlockType.FUNCTION),
+      ],
+      connections: [
+        { source: 'start', target: parallelId },
+        {
+          source: parallelId,
+          target: taskId,
+          sourceHandle: 'parallel-start-source',
+        },
+      ],
+      loops: {},
+      parallels: {
+        [parallelId]: {
+          id: parallelId,
+          nodes: [taskId],
+          count: 2,
+          parallelType: 'count',
+        },
+      },
+    }
+
+    const dag = new DAGBuilder().build(workflow)
+    const expander = new ParallelExpander()
+    const { terminalNodes } = expander.expandParallel(dag, parallelId, 2)
+    const edgeManager = new EdgeManager(dag)
+    const parallelEndId = buildParallelSentinelEndId(parallelId)
+
+    expect(terminalNodes).toEqual([buildBranchNodeId(taskId, 0), buildBranchNodeId(taskId, 1)])
+    expect(dag.nodes.get(parallelEndId)?.incomingEdges).toEqual(new Set(terminalNodes))
+
+    const firstBranchReady = edgeManager.processOutgoingEdges(dag.nodes.get(terminalNodes[0])!, {
+      value: 'first',
+    })
+    expect(firstBranchReady).not.toContain(parallelEndId)
+
+    const secondBranchReady = edgeManager.processOutgoingEdges(dag.nodes.get(terminalNodes[1])!, {
+      value: 'second',
+    })
+    expect(secondBranchReady).toContain(parallelEndId)
+  })
+
   it('outer parallel expansion clones inner subflow per branch and edge manager resolves correctly', () => {
     const outerParallelId = 'outer-parallel'
     const innerParallelId = 'inner-parallel'
@@ -105,6 +155,10 @@ describe('Nested parallel expansion + edge resolution', () => {
     const clonedInnerEndId = buildParallelSentinelEndId(clonedInnerParallelId)
 
     expect(outerStartTargets).toContain(clonedInnerStartId) // branch 1
+    expect(dag.nodes.get(clonedInnerStartId)?.metadata).toMatchObject({
+      subflowId: clonedInnerParallelId,
+      subflowType: 'parallel',
+    })
 
     // Verify cloned parallel config was registered
     expect(dag.parallelConfigs.has(clonedInnerParallelId)).toBe(true)
@@ -207,6 +261,78 @@ describe('Nested parallel expansion + edge resolution', () => {
     expect(readyAfterClonedInnerEnd).toContain(outerEndId)
   })
 
+  it('preserves regular-to-nested subflow dependencies across expanded branches', () => {
+    const outerParallelId = 'outer-parallel'
+    const innerParallelId = 'inner-parallel'
+    const prepareId = 'prepare'
+    const finishId = 'finish'
+    const innerTaskId = 'inner-task'
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [
+        createBlock('start', BlockType.STARTER),
+        createBlock(outerParallelId, BlockType.PARALLEL),
+        createBlock(prepareId, BlockType.FUNCTION),
+        createBlock(innerParallelId, BlockType.PARALLEL),
+        createBlock(innerTaskId, BlockType.FUNCTION),
+        createBlock(finishId, BlockType.FUNCTION),
+      ],
+      connections: [
+        { source: 'start', target: outerParallelId },
+        { source: outerParallelId, target: prepareId, sourceHandle: 'parallel-start-source' },
+        { source: prepareId, target: innerParallelId },
+        { source: innerParallelId, target: finishId },
+        { source: innerParallelId, target: innerTaskId, sourceHandle: 'parallel-start-source' },
+      ],
+      loops: {},
+      parallels: {
+        [innerParallelId]: {
+          id: innerParallelId,
+          nodes: [innerTaskId],
+          count: 1,
+          parallelType: 'count',
+        },
+        [outerParallelId]: {
+          id: outerParallelId,
+          nodes: [prepareId, innerParallelId, finishId],
+          count: 2,
+          parallelType: 'count',
+        },
+      },
+    }
+
+    const dag = new DAGBuilder().build(workflow)
+    const expander = new ParallelExpander()
+    const result = expander.expandParallel(dag, outerParallelId, 2)
+
+    const clonedInnerId = result.clonedSubflows[0].clonedId
+    const prepareBranchOne = dag.nodes.get(buildBranchNodeId(prepareId, 1))!
+    const clonedInnerStart = buildParallelSentinelStartId(clonedInnerId)
+    const clonedInnerEnd = buildParallelSentinelEndId(clonedInnerId)
+    const finishBranchOne = buildBranchNodeId(finishId, 1)
+
+    expect(
+      Array.from(prepareBranchOne.outgoingEdges.values()).map((edge) => edge.target)
+    ).toContain(clonedInnerStart)
+    expect(
+      Array.from(dag.nodes.get(clonedInnerEnd)!.outgoingEdges.values()).map((edge) => edge.target)
+    ).toContain(finishBranchOne)
+    expect(
+      Array.from(dag.nodes.get(clonedInnerEnd)!.outgoingEdges.values()).map((edge) => edge.target)
+    ).not.toContain(buildBranchNodeId(finishId, 0))
+
+    const outerStartTargets = Array.from(
+      dag.nodes.get(buildParallelSentinelStartId(outerParallelId))!.outgoingEdges.values()
+    ).map((edge) => edge.target)
+    expect(outerStartTargets).toEqual([buildBranchNodeId(prepareId, 0), prepareBranchOne.id])
+
+    const outerEndIncoming = dag.nodes.get(
+      buildParallelSentinelEndId(outerParallelId)
+    )!.incomingEdges
+    expect(outerEndIncoming.has(buildBranchNodeId(finishId, 0))).toBe(true)
+    expect(outerEndIncoming.has(finishBranchOne)).toBe(true)
+  })
+
   it('uses global branch indexes for nested subflow clones in later batches', () => {
     const outerParallelId = 'outer-parallel'
     const innerParallelId = 'inner-parallel'
@@ -266,6 +392,241 @@ describe('Nested parallel expansion + edge resolution', () => {
     ])
   })
 
+  it('clears stale regular-to-nested edges when local branch nodes are reused in later batches', () => {
+    const outerParallelId = 'outer-parallel'
+    const innerParallelId = 'inner-parallel'
+    const prepareId = 'prepare'
+    const innerTaskId = 'inner-task'
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [
+        createBlock('start', BlockType.STARTER),
+        createBlock(outerParallelId, BlockType.PARALLEL),
+        createBlock(prepareId, BlockType.FUNCTION),
+        createBlock(innerParallelId, BlockType.PARALLEL),
+        createBlock(innerTaskId, BlockType.FUNCTION),
+      ],
+      connections: [
+        { source: 'start', target: outerParallelId },
+        { source: outerParallelId, target: prepareId, sourceHandle: 'parallel-start-source' },
+        { source: prepareId, target: innerParallelId },
+        { source: innerParallelId, target: innerTaskId, sourceHandle: 'parallel-start-source' },
+      ],
+      loops: {},
+      parallels: {
+        [innerParallelId]: {
+          id: innerParallelId,
+          nodes: [innerTaskId],
+          count: 1,
+          parallelType: 'count',
+        },
+        [outerParallelId]: {
+          id: outerParallelId,
+          nodes: [prepareId, innerParallelId],
+          count: 5,
+          parallelType: 'count',
+        },
+      },
+    }
+
+    const dag = new DAGBuilder().build(workflow)
+    const expander = new ParallelExpander()
+    expander.expandParallel(dag, outerParallelId, 2, undefined, {
+      branchIndexOffset: 0,
+      totalBranches: 5,
+    })
+    expander.expandParallel(dag, outerParallelId, 2, undefined, {
+      branchIndexOffset: 2,
+      totalBranches: 5,
+    })
+    expander.expandParallel(dag, outerParallelId, 1, undefined, {
+      branchIndexOffset: 4,
+      totalBranches: 5,
+    })
+
+    const prepareBranchZero = dag.nodes.get(buildBranchNodeId(prepareId, 0))!
+    const originalInnerStart = buildParallelSentinelStartId(innerParallelId)
+    const staleClonedInnerStart = buildParallelSentinelStartId(`${innerParallelId}__obranch-2`)
+    const clonedInnerStart = buildParallelSentinelStartId(`${innerParallelId}__obranch-4`)
+    const prepareTargets = Array.from(prepareBranchZero.outgoingEdges.values()).map(
+      (edge) => edge.target
+    )
+
+    expect(prepareTargets).toEqual([clonedInnerStart])
+    expect(dag.nodes.get(originalInnerStart)!.incomingEdges.has(prepareBranchZero.id)).toBe(false)
+    expect(dag.nodes.get(staleClonedInnerStart)!.incomingEdges.has(prepareBranchZero.id)).toBe(
+      false
+    )
+    expect(dag.nodes.get(clonedInnerStart)!.incomingEdges.has(prepareBranchZero.id)).toBe(true)
+  })
+
+  it('preserves internal edge topology when expanding cloned nested parallels', () => {
+    const outerParallelId = 'outer-parallel'
+    const innerParallelId = 'inner-parallel'
+    const firstTaskId = 'first-task'
+    const secondTaskId = 'second-task'
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [
+        createBlock('start', BlockType.STARTER),
+        createBlock(outerParallelId, BlockType.PARALLEL),
+        createBlock(innerParallelId, BlockType.PARALLEL),
+        createBlock(firstTaskId, BlockType.FUNCTION),
+        createBlock(secondTaskId, BlockType.FUNCTION),
+      ],
+      connections: [
+        { source: 'start', target: outerParallelId },
+        { source: outerParallelId, target: innerParallelId, sourceHandle: 'parallel-start-source' },
+        { source: innerParallelId, target: firstTaskId, sourceHandle: 'parallel-start-source' },
+        { source: firstTaskId, target: secondTaskId },
+      ],
+      loops: {},
+      parallels: {
+        [innerParallelId]: {
+          id: innerParallelId,
+          nodes: [firstTaskId, secondTaskId],
+          count: 2,
+          parallelType: 'count',
+        },
+        [outerParallelId]: {
+          id: outerParallelId,
+          nodes: [innerParallelId],
+          count: 3,
+          parallelType: 'count',
+        },
+      },
+    }
+
+    const dag = new DAGBuilder().build(workflow)
+    const expander = new ParallelExpander()
+    const outerResult = expander.expandParallel(dag, outerParallelId, 1, undefined, {
+      branchIndexOffset: 2,
+      totalBranches: 3,
+    })
+    const clonedInnerId = outerResult.clonedSubflows[0].clonedId
+    const clonedInnerConfig = dag.parallelConfigs.get(clonedInnerId)!
+    const [clonedFirstTaskId, clonedSecondTaskId] = clonedInnerConfig.nodes
+
+    const innerResult = expander.expandParallel(dag, clonedInnerId, 2)
+
+    const firstTaskBranchOneId = buildBranchNodeId(clonedFirstTaskId, 1)
+    const secondTaskBranchOneId = buildBranchNodeId(clonedSecondTaskId, 1)
+    const firstTaskBranchOne = dag.nodes.get(firstTaskBranchOneId)!
+    const secondTaskBranchOne = dag.nodes.get(secondTaskBranchOneId)!
+
+    expect(innerResult.entryNodes).toEqual([
+      buildBranchNodeId(clonedFirstTaskId, 0),
+      firstTaskBranchOneId,
+    ])
+    expect(
+      Array.from(firstTaskBranchOne.outgoingEdges.values()).map((edge) => edge.target)
+    ).toContain(secondTaskBranchOneId)
+    expect(secondTaskBranchOne.incomingEdges.has(firstTaskBranchOneId)).toBe(true)
+    expect(innerResult.entryNodes).not.toContain(secondTaskBranchOneId)
+  })
+
+  it('clears stale sentinel-end incoming edges when a later batch is smaller', () => {
+    const parallelId = 'parallel-1'
+    const functionId = 'func-1'
+
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [
+        createBlock('start', BlockType.STARTER),
+        createBlock(parallelId, BlockType.PARALLEL),
+        createBlock(functionId, BlockType.FUNCTION),
+      ],
+      connections: [
+        { source: 'start', target: parallelId },
+        { source: parallelId, target: functionId, sourceHandle: 'parallel-start-source' },
+      ],
+      loops: {},
+      parallels: {
+        [parallelId]: {
+          id: parallelId,
+          nodes: [functionId],
+          count: 4,
+          parallelType: 'count',
+        },
+      },
+    }
+
+    const builder = new DAGBuilder()
+    const dag = builder.build(workflow)
+    const expander = new ParallelExpander()
+    const sentinelEnd = dag.nodes.get(buildParallelSentinelEndId(parallelId))!
+
+    expander.expandParallel(dag, parallelId, 3, undefined, {
+      branchIndexOffset: 0,
+      totalBranches: 4,
+    })
+    expect(sentinelEnd.incomingEdges).toEqual(
+      new Set([
+        buildBranchNodeId(functionId, 0),
+        buildBranchNodeId(functionId, 1),
+        buildBranchNodeId(functionId, 2),
+      ])
+    )
+
+    expander.expandParallel(dag, parallelId, 1, undefined, {
+      branchIndexOffset: 3,
+      totalBranches: 4,
+    })
+    expect(sentinelEnd.incomingEdges).toEqual(new Set([buildBranchNodeId(functionId, 0)]))
+  })
+
+  it('updates unified subflow metadata on cloned nested loop sentinels', () => {
+    const parallelId = 'parallel-1'
+    const loopId = 'loop-1'
+    const functionId = 'func-1'
+
+    const workflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [
+        createBlock('start', BlockType.STARTER),
+        createBlock(parallelId, BlockType.PARALLEL),
+        createBlock(loopId, BlockType.LOOP),
+        createBlock(functionId, BlockType.FUNCTION),
+      ],
+      connections: [
+        { source: 'start', target: parallelId },
+        { source: parallelId, target: loopId, sourceHandle: 'parallel-start-source' },
+        { source: loopId, target: functionId, sourceHandle: 'loop-start-source' },
+      ],
+      loops: {
+        [loopId]: {
+          id: loopId,
+          nodes: [functionId],
+          iterations: 1,
+          loopType: 'for',
+        },
+      },
+      parallels: {
+        [parallelId]: {
+          id: parallelId,
+          nodes: [loopId],
+          count: 2,
+          parallelType: 'count',
+        },
+      },
+    }
+
+    const builder = new DAGBuilder()
+    const dag = builder.build(workflow)
+    const expander = new ParallelExpander()
+
+    const result = expander.expandParallel(dag, parallelId, 2)
+    const clonedLoopId = result.clonedSubflows.find(
+      (clone) => clone.originalId === loopId
+    )?.clonedId
+
+    expect(clonedLoopId).toBe(`${loopId}__obranch-1`)
+    expect(dag.nodes.get(buildSentinelStartId(clonedLoopId!))?.metadata).toMatchObject({
+      subflowId: clonedLoopId,
+      subflowType: 'loop',
+    })
+  })
+
   it('3-level nesting: pre-expansion clone IDs do not collide with runtime expansion', () => {
     const p1 = 'p1'
     const p2 = 'p2'
@@ -312,6 +673,11 @@ describe('Nested parallel expansion + edge resolution', () => {
     expect(p3Clone).toBeDefined()
     expect(p3Clone.clonedId).toMatch(/^p3__clone[0-9a-f]{24}__obranch-1$/)
     expect(stripCloneSuffixes(p3Clone.clonedId)).toBe('p3')
+    expect(
+      Array.from(
+        dag.nodes.get(buildParallelSentinelEndId(p3Clone.clonedId))!.outgoingEdges.values()
+      ).map((edge) => edge.target)
+    ).toContain(buildParallelSentinelEndId(p2Clone.clonedId))
 
     // Step 2: Expand P2 (original, branch 0 of P1) — this creates P3__obranch-1 at runtime
     const p2Result = expander.expandParallel(dag, p2, 2)
diff --git a/apps/sim/executor/utils/parallel-expansion.ts b/apps/sim/executor/utils/parallel-expansion.ts
index f98c9f49e57..e4f7182aad7 100644
--- a/apps/sim/executor/utils/parallel-expansion.ts
+++ b/apps/sim/executor/utils/parallel-expansion.ts
@@ -1,8 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { sha256Hex } from '@sim/security/hash'
-import { EDGE } from '@/executor/constants'
+import { CONTROL_BACK_EDGE_HANDLES, EDGE } from '@/executor/constants'
 import type { DAG, DAGNode } from '@/executor/dag/builder'
-import type { SerializedBlock } from '@/serializer/types'
 import {
   buildBranchNodeId,
   buildClonedSubflowId,
@@ -12,7 +11,11 @@ import {
   buildSentinelStartId,
   extractBaseBlockId,
   isLoopSentinelNodeId,
-} from './subflow-utils'
+  isParallelSentinelNodeId,
+  normalizeNodeId,
+  stripOuterBranchSuffix,
+} from '@/executor/utils/subflow-utils'
+import type { SerializedBlock } from '@/serializer/types'
 
 const logger = createLogger('ParallelExpansion')
 
@@ -61,7 +64,6 @@ export class ParallelExpander {
       }
     }
 
-    const regularSet = new Set(regularBlocks)
     const allBranchNodes: string[] = []
     const branchIndexOffset = options.branchIndexOffset ?? 0
     const branchTotal = options.totalBranches ?? branchCount
@@ -102,38 +104,19 @@ export class ParallelExpander {
       }
     }
 
-    this.wireInternalEdges(dag, regularBlocks, regularSet, branchCount)
-
-    const { entryNodes, terminalNodes } =
-      regularBlocks.length > 0
-        ? this.identifyBoundaryNodes(dag, regularBlocks, regularSet, branchCount)
-        : { entryNodes: [] as string[], terminalNodes: [] as string[] }
-
     // Clone nested subflow graphs per outer branch so each branch runs independently.
     // Branch 0 uses the original sentinel/template nodes; branches 1..N get full clones.
     const clonedSubflows: ClonedSubflowInfo[] = []
 
     for (const subflowId of nestedSubflows) {
-      const isParallel = dag.parallelConfigs.has(subflowId)
-      const startId = isParallel
-        ? buildParallelSentinelStartId(subflowId)
-        : buildSentinelStartId(subflowId)
-      const endId = isParallel
-        ? buildParallelSentinelEndId(subflowId)
-        : buildSentinelEndId(subflowId)
-
       for (let i = 0; i < branchCount; i++) {
         const globalBranchIndex = branchIndexOffset + i
         if (globalBranchIndex === 0) {
-          if (dag.nodes.has(startId)) entryNodes.push(startId)
-          if (dag.nodes.has(endId)) terminalNodes.push(endId)
           continue
         }
 
         const cloned = this.cloneNestedSubflow(dag, subflowId, globalBranchIndex, clonedSubflows)
 
-        entryNodes.push(cloned.startId)
-        terminalNodes.push(cloned.endId)
         clonedSubflows.push({
           clonedId: cloned.clonedId,
           originalId: subflowId,
@@ -142,6 +125,20 @@ export class ParallelExpander {
       }
     }
 
+    this.wireInternalEdges(
+      dag,
+      blocksInParallel,
+      new Set(blocksInParallel),
+      branchCount,
+      branchIndexOffset
+    )
+    const { entryNodes, terminalNodes } = this.identifyBoundaryNodes(
+      dag,
+      blocksInParallel,
+      branchCount,
+      branchIndexOffset
+    )
+
     this.wireSentinelEdges(dag, parallelId, entryNodes, terminalNodes, branchCount)
 
     logger.info('Parallel expanded', {
@@ -201,68 +198,95 @@ export class ParallelExpander {
     dag: DAG,
     blocksInParallel: string[],
     blocksSet: Set<string>,
-    branchCount: number
+    branchCount: number,
+    branchIndexOffset: number
   ): void {
-    for (const blockId of blocksInParallel) {
-      const templateId = buildBranchNodeId(blockId, 0)
-      const templateNode = dag.nodes.get(templateId)
-      if (!templateNode) continue
-
-      for (const [, edge] of templateNode.outgoingEdges) {
-        const baseTargetId = extractBaseBlockId(edge.target)
-        if (!blocksSet.has(baseTargetId)) continue
-
-        // Include branch 0 so per-batch re-expansion restores the template's
-        // incoming-edge bookkeeping that earlier batches consumed during
-        // edge processing. Without this, identifyBoundaryNodes mis-classifies
-        // chained children as entry nodes after the first batch.
-        for (let i = 0; i < branchCount; i++) {
-          const sourceNodeId = buildBranchNodeId(blockId, i)
-          const targetNodeId = buildBranchNodeId(baseTargetId, i)
-          const sourceNode = dag.nodes.get(sourceNodeId)
-          const targetNode = dag.nodes.get(targetNodeId)
-
-          if (!sourceNode || !targetNode) continue
-
-          const edgeId = edge.sourceHandle
-            ? `${sourceNodeId}→${targetNodeId}-${edge.sourceHandle}`
-            : `${sourceNodeId}→${targetNodeId}`
-
-          sourceNode.outgoingEdges.set(edgeId, {
-            target: targetNodeId,
-            sourceHandle: edge.sourceHandle,
-            targetHandle: edge.targetHandle,
-          })
-          targetNode.incomingEdges.add(sourceNodeId)
+    const topology = this.collectInternalEdgeTopology(dag, blocksInParallel, blocksSet)
+    const cleanedSourceNodes = new Set<string>()
+
+    for (const edge of topology) {
+      for (let i = 0; i < branchCount; i++) {
+        const globalBranchIndex = branchIndexOffset + i
+        const sourceNodeId = this.resolveBranchChildBoundaryId(
+          dag,
+          edge.sourceBlockId,
+          i,
+          globalBranchIndex,
+          'end'
+        )
+        const targetNodeId = this.resolveBranchChildBoundaryId(
+          dag,
+          edge.targetBlockId,
+          i,
+          globalBranchIndex,
+          'start'
+        )
+        const sourceNode = dag.nodes.get(sourceNodeId)
+        const targetNode = dag.nodes.get(targetNodeId)
+
+        if (!sourceNode || !targetNode) continue
+
+        if (!cleanedSourceNodes.has(sourceNodeId)) {
+          this.clearStaleInternalEdges(dag, sourceNodeId, sourceNode, blocksSet)
+          cleanedSourceNodes.add(sourceNodeId)
         }
+
+        const edgeId = edge.sourceHandle
+          ? `${sourceNodeId}→${targetNodeId}-${edge.sourceHandle}`
+          : `${sourceNodeId}→${targetNodeId}`
+
+        sourceNode.outgoingEdges.set(edgeId, {
+          target: targetNodeId,
+          sourceHandle: edge.sourceHandle,
+          targetHandle: edge.targetHandle,
+        })
+        targetNode.incomingEdges.add(sourceNodeId)
       }
     }
   }
 
+  private clearStaleInternalEdges(
+    dag: DAG,
+    sourceNodeId: string,
+    sourceNode: DAGNode,
+    blocksSet: Set<string>
+  ): void {
+    for (const [edgeId, edge] of Array.from(sourceNode.outgoingEdges.entries())) {
+      if (!blocksSet.has(stripOuterBranchSuffix(normalizeNodeId(edge.target)))) continue
+
+      sourceNode.outgoingEdges.delete(edgeId)
+      dag.nodes.get(edge.target)?.incomingEdges.delete(sourceNodeId)
+    }
+  }
+
   private identifyBoundaryNodes(
     dag: DAG,
     blocksInParallel: string[],
-    blocksSet: Set<string>,
-    branchCount: number
+    branchCount: number,
+    branchIndexOffset: number
   ): { entryNodes: string[]; terminalNodes: string[] } {
     const entryNodes: string[] = []
     const terminalNodes: string[] = []
+    const topology = this.collectInternalEdgeTopology(
+      dag,
+      blocksInParallel,
+      new Set(blocksInParallel)
+    )
+    const blocksWithInternalIncoming = new Set(topology.map((edge) => edge.targetBlockId))
+    const blocksWithInternalOutgoing = new Set(topology.map((edge) => edge.sourceBlockId))
 
     for (const blockId of blocksInParallel) {
-      const templateId = buildBranchNodeId(blockId, 0)
-      const templateNode = dag.nodes.get(templateId)
-      if (!templateNode) continue
-
-      const hasInternalIncoming = this.hasInternalIncomingEdge(templateNode, blocksSet)
-      const hasInternalOutgoing = this.hasInternalOutgoingEdge(templateNode, blocksSet)
-
       for (let i = 0; i < branchCount; i++) {
-        const branchNodeId = buildBranchNodeId(blockId, i)
-        if (!hasInternalIncoming) {
-          entryNodes.push(branchNodeId)
+        const globalBranchIndex = branchIndexOffset + i
+        if (!blocksWithInternalIncoming.has(blockId)) {
+          entryNodes.push(
+            this.resolveBranchChildBoundaryId(dag, blockId, i, globalBranchIndex, 'start')
+          )
         }
-        if (!hasInternalOutgoing) {
-          terminalNodes.push(branchNodeId)
+        if (!blocksWithInternalOutgoing.has(blockId)) {
+          terminalNodes.push(
+            this.resolveBranchChildBoundaryId(dag, blockId, i, globalBranchIndex, 'end')
+          )
         }
       }
     }
@@ -270,24 +294,82 @@ export class ParallelExpander {
     return { entryNodes, terminalNodes }
   }
 
-  private hasInternalIncomingEdge(node: DAGNode, blocksSet: Set<string>): boolean {
-    for (const incomingId of node.incomingEdges) {
-      const baseId = extractBaseBlockId(incomingId)
-      if (blocksSet.has(baseId)) {
-        return true
+  private collectInternalEdgeTopology(
+    dag: DAG,
+    blocksInParallel: string[],
+    blocksSet: Set<string>
+  ): Array<{
+    sourceBlockId: string
+    targetBlockId: string
+    sourceHandle?: string
+    targetHandle?: string
+  }> {
+    const topology: Array<{
+      sourceBlockId: string
+      targetBlockId: string
+      sourceHandle?: string
+      targetHandle?: string
+    }> = []
+
+    for (const blockId of blocksInParallel) {
+      const sourceNodeId = this.resolveOriginalChildBoundaryId(dag, blockId, 'end')
+      const sourceNode = dag.nodes.get(sourceNodeId)
+      if (!sourceNode) continue
+
+      for (const [, edge] of sourceNode.outgoingEdges) {
+        if (edge.sourceHandle && CONTROL_BACK_EDGE_HANDLES.has(edge.sourceHandle)) continue
+
+        const targetBoundaryId = extractBaseBlockId(normalizeNodeId(edge.target))
+        const targetBlockId = blocksSet.has(targetBoundaryId)
+          ? targetBoundaryId
+          : stripOuterBranchSuffix(targetBoundaryId)
+        if (!blocksSet.has(targetBlockId)) continue
+
+        topology.push({
+          sourceBlockId: blockId,
+          targetBlockId,
+          sourceHandle: edge.sourceHandle,
+          targetHandle: edge.targetHandle,
+        })
       }
     }
-    return false
+
+    return topology
   }
 
-  private hasInternalOutgoingEdge(node: DAGNode, blocksSet: Set<string>): boolean {
-    for (const [, edge] of node.outgoingEdges) {
-      const baseId = extractBaseBlockId(edge.target)
-      if (blocksSet.has(baseId)) {
-        return true
-      }
+  private resolveOriginalChildBoundaryId(dag: DAG, blockId: string, side: 'start' | 'end'): string {
+    if (dag.parallelConfigs.has(blockId)) {
+      return side === 'start'
+        ? buildParallelSentinelStartId(blockId)
+        : buildParallelSentinelEndId(blockId)
+    }
+    if (dag.loopConfigs.has(blockId)) {
+      return side === 'start' ? buildSentinelStartId(blockId) : buildSentinelEndId(blockId)
     }
-    return false
+    return buildBranchNodeId(blockId, 0)
+  }
+
+  private resolveBranchChildBoundaryId(
+    dag: DAG,
+    blockId: string,
+    localBranchIndex: number,
+    globalBranchIndex: number,
+    side: 'start' | 'end'
+  ): string {
+    if (!dag.parallelConfigs.has(blockId) && !dag.loopConfigs.has(blockId)) {
+      return buildBranchNodeId(blockId, localBranchIndex)
+    }
+
+    const effectiveSubflowId =
+      globalBranchIndex === 0 ? blockId : buildClonedSubflowId(blockId, globalBranchIndex)
+    if (dag.parallelConfigs.has(blockId)) {
+      return side === 'start'
+        ? buildParallelSentinelStartId(effectiveSubflowId)
+        : buildParallelSentinelEndId(effectiveSubflowId)
+    }
+    return side === 'start'
+      ? buildSentinelStartId(effectiveSubflowId)
+      : buildSentinelEndId(effectiveSubflowId)
   }
 
   /**
@@ -440,53 +522,34 @@ export class ParallelExpander {
       if (!origNode) continue
 
       const clonedNodeId = idMap.get(origId)!
-      this.cloneDAGNode(dag, origNode, clonedNodeId, clonedId, isParallel, idMap)
+      this.cloneDAGNode(dag, origNode, clonedNodeId, clonedId, isParallel)
     }
 
+    this.remapClonedEdges(dag, idMap)
+
     return { startId: clonedStartId, endId: clonedEndId, idMap }
   }
 
   /**
-   * Clones a single DAG node with remapped edges and updated metadata.
+   * Clones a single DAG node with updated metadata. Edge wiring is owned by remapClonedEdges
+   * after the full clone id map is available.
    */
   private cloneDAGNode(
     dag: DAG,
     origNode: DAGNode,
     clonedNodeId: string,
     parentClonedId: string,
-    parentIsParallel: boolean,
-    idMap: Map<string, string>
+    parentIsParallel: boolean
   ): void {
-    const clonedOutgoing = new Map<
-      string,
-      { target: string; sourceHandle?: string; targetHandle?: string }
-    >()
-    for (const [, edge] of origNode.outgoingEdges) {
-      const clonedTarget = idMap.get(edge.target) ?? edge.target
-      const edgeId = edge.sourceHandle
-        ? `${clonedNodeId}→${clonedTarget}-${edge.sourceHandle}`
-        : `${clonedNodeId}→${clonedTarget}`
-      clonedOutgoing.set(edgeId, {
-        target: clonedTarget,
-        sourceHandle: edge.sourceHandle,
-        targetHandle: edge.targetHandle,
-      })
-    }
-
-    const clonedIncoming = new Set<string>()
-    for (const incomingId of origNode.incomingEdges) {
-      clonedIncoming.add(idMap.get(incomingId) ?? incomingId)
-    }
-
     const metadataOverride = parentIsParallel
-      ? { parallelId: parentClonedId }
-      : { loopId: parentClonedId }
+      ? { subflowId: parentClonedId, subflowType: 'parallel' as const }
+      : { subflowId: parentClonedId, subflowType: 'loop' as const }
 
     dag.nodes.set(clonedNodeId, {
       id: clonedNodeId,
       block: { ...origNode.block, id: clonedNodeId },
-      incomingEdges: clonedIncoming,
-      outgoingEdges: clonedOutgoing,
+      incomingEdges: new Set(),
+      outgoingEdges: new Map(),
       metadata: {
         ...origNode.metadata,
         ...metadataOverride,
@@ -497,6 +560,43 @@ export class ParallelExpander {
     })
   }
 
+  private remapClonedEdges(dag: DAG, idMap: Map<string, string>): void {
+    for (const [origId, clonedNodeId] of idMap) {
+      const origNode = dag.nodes.get(origId)
+      const clonedNode = dag.nodes.get(clonedNodeId)
+      if (!origNode || !clonedNode) continue
+
+      const remappedOutgoing = new Map<
+        string,
+        { target: string; sourceHandle?: string; targetHandle?: string }
+      >()
+      for (const [, edge] of origNode.outgoingEdges) {
+        const clonedTarget = idMap.get(edge.target)
+        if (!clonedTarget) continue
+
+        const edgeId = edge.sourceHandle
+          ? `${clonedNodeId}→${clonedTarget}-${edge.sourceHandle}`
+          : `${clonedNodeId}→${clonedTarget}`
+        remappedOutgoing.set(edgeId, {
+          target: clonedTarget,
+          sourceHandle: edge.sourceHandle,
+          targetHandle: edge.targetHandle,
+        })
+      }
+
+      const remappedIncoming = new Set<string>()
+      for (const incomingId of origNode.incomingEdges) {
+        const clonedIncomingId = idMap.get(incomingId)
+        if (clonedIncomingId) {
+          remappedIncoming.add(clonedIncomingId)
+        }
+      }
+
+      clonedNode.outgoingEdges = remappedOutgoing
+      clonedNode.incomingEdges = remappedIncoming
+    }
+  }
+
   private wireSentinelEdges(
     dag: DAG,
     parallelId: string,
@@ -515,6 +615,7 @@ export class ParallelExpander {
     }
 
     sentinelStart.outgoingEdges.clear()
+    sentinelEnd.incomingEdges.clear()
     for (const entryNodeId of entryNodes) {
       const entryNode = dag.nodes.get(entryNodeId)
       if (!entryNode) continue
@@ -528,8 +629,14 @@ export class ParallelExpander {
       const terminalNode = dag.nodes.get(terminalNodeId)
       if (!terminalNode) continue
 
-      const handle = isLoopSentinelNodeId(terminalNodeId) ? EDGE.LOOP_EXIT : EDGE.PARALLEL_EXIT
-      const edgeId = `${terminalNodeId}→${sentinelEndId}-${handle}`
+      const handle = isLoopSentinelNodeId(terminalNodeId)
+        ? EDGE.LOOP_EXIT
+        : isParallelSentinelNodeId(terminalNodeId)
+          ? EDGE.PARALLEL_EXIT
+          : undefined
+      const edgeId = handle
+        ? `${terminalNodeId}→${sentinelEndId}-${handle}`
+        : `${terminalNodeId}→${sentinelEndId}`
       terminalNode.outgoingEdges.set(edgeId, {
         target: sentinelEndId,
         sourceHandle: handle,
diff --git a/apps/sim/executor/utils/run-from-block.test.ts b/apps/sim/executor/utils/run-from-block.test.ts
index c9103c662cb..d3b2fd5401f 100644
--- a/apps/sim/executor/utils/run-from-block.test.ts
+++ b/apps/sim/executor/utils/run-from-block.test.ts
@@ -287,7 +287,13 @@ describe('validateRunFromBlock', () => {
   })
 
   it('rejects blocks inside loops', () => {
-    const dag = createDAG([createNode('A', [], { isLoopNode: true, loopId: 'loop-1' })])
+    const dag = createDAG([
+      createNode('A', [], {
+        isLoopNode: true,
+        subflowId: 'loop-1',
+        subflowType: 'loop',
+      }),
+    ])
     const executedBlocks = new Set(['A'])
 
     const result = validateRunFromBlock('A', dag, executedBlocks)
@@ -299,7 +305,11 @@ describe('validateRunFromBlock', () => {
 
   it('rejects blocks inside parallels', () => {
     const dag = createDAG([
-      createNode('A', [], { isParallelBranch: true, parallelId: 'parallel-1' }),
+      createNode('A', [], {
+        isParallelBranch: true,
+        subflowId: 'parallel-1',
+        subflowType: 'parallel',
+      }),
     ])
     const executedBlocks = new Set(['A'])
 
@@ -387,13 +397,19 @@ describe('validateRunFromBlock', () => {
       createNode(sentinelStartId, [{ target: 'B' }], {
         isSentinel: true,
         sentinelType: 'start',
-        loopId,
+        subflowId: loopId,
+        subflowType: 'loop',
+      }),
+      createNode('B', [{ target: sentinelEndId }], {
+        isLoopNode: true,
+        subflowId: loopId,
+        subflowType: 'loop',
       }),
-      createNode('B', [{ target: sentinelEndId }], { isLoopNode: true, loopId }),
       createNode(sentinelEndId, [{ target: 'C' }], {
         isSentinel: true,
         sentinelType: 'end',
-        loopId,
+        subflowId: loopId,
+        subflowType: 'loop',
       }),
       createNode('C'),
     ])
@@ -405,6 +421,69 @@ describe('validateRunFromBlock', () => {
     expect(result.valid).toBe(true)
   })
 
+  it('rejects loop containers nested inside another loop', () => {
+    const outerLoopId = 'outer-loop'
+    const innerLoopId = 'inner-loop'
+    const innerStartId = `loop-${innerLoopId}-sentinel-start`
+    const dag = createDAG([
+      createNode(innerStartId, [], {
+        isSentinel: true,
+        sentinelType: 'start',
+        subflowId: innerLoopId,
+        subflowType: 'loop',
+      }),
+    ])
+    dag.loopConfigs.set(outerLoopId, {
+      id: outerLoopId,
+      nodes: [innerLoopId],
+      iterations: 2,
+      loopType: 'for',
+    } as any)
+    dag.loopConfigs.set(innerLoopId, {
+      id: innerLoopId,
+      nodes: ['B'],
+      iterations: 2,
+      loopType: 'for',
+    } as any)
+
+    const result = validateRunFromBlock(innerLoopId, dag, new Set([innerStartId]))
+
+    expect(result.valid).toBe(false)
+    expect(result.error).toContain('inside loop')
+    expect(result.error).toContain(outerLoopId)
+  })
+
+  it('rejects containers nested inside a parallel', () => {
+    const outerParallelId = 'outer-parallel'
+    const innerLoopId = 'inner-loop'
+    const innerStartId = `loop-${innerLoopId}-sentinel-start`
+    const dag = createDAG([
+      createNode(innerStartId, [], {
+        isSentinel: true,
+        sentinelType: 'start',
+        subflowId: innerLoopId,
+        subflowType: 'loop',
+      }),
+    ])
+    dag.parallelConfigs.set(outerParallelId, {
+      id: outerParallelId,
+      nodes: [innerLoopId],
+      count: 2,
+    } as any)
+    dag.loopConfigs.set(innerLoopId, {
+      id: innerLoopId,
+      nodes: ['B'],
+      iterations: 2,
+      loopType: 'for',
+    } as any)
+
+    const result = validateRunFromBlock(innerLoopId, dag, new Set([innerStartId]))
+
+    expect(result.valid).toBe(false)
+    expect(result.error).toContain('inside parallel')
+    expect(result.error).toContain(outerParallelId)
+  })
+
   it('accepts parallel container when executed', () => {
     // Parallel container with sentinel nodes
     const parallelId = 'parallel-container-1'
@@ -415,13 +494,19 @@ describe('validateRunFromBlock', () => {
       createNode(sentinelStartId, [{ target: 'B₍0₎' }], {
         isSentinel: true,
         sentinelType: 'start',
-        parallelId,
+        subflowId: parallelId,
+        subflowType: 'parallel',
+      }),
+      createNode('B₍0₎', [{ target: sentinelEndId }], {
+        isParallelBranch: true,
+        subflowId: parallelId,
+        subflowType: 'parallel',
       }),
-      createNode('B₍0₎', [{ target: sentinelEndId }], { isParallelBranch: true, parallelId }),
       createNode(sentinelEndId, [{ target: 'C' }], {
         isSentinel: true,
         sentinelType: 'end',
-        parallelId,
+        subflowId: parallelId,
+        subflowType: 'parallel',
       }),
       createNode('C'),
     ])
@@ -433,13 +518,40 @@ describe('validateRunFromBlock', () => {
     expect(result.valid).toBe(true)
   })
 
+  it('rejects container when sentinel-start upstream dependency was not executed', () => {
+    const loopId = 'loop-container-1'
+    const sentinelStartId = `loop-${loopId}-sentinel-start`
+    const dag = createDAG([
+      createNode('A', [{ target: sentinelStartId }]),
+      createNode('X', [{ target: 'B' }]),
+      createNode('B', [{ target: sentinelStartId }]),
+      createNode(sentinelStartId, [], {
+        isSentinel: true,
+        sentinelType: 'start',
+        subflowId: loopId,
+        subflowType: 'loop',
+      }),
+    ])
+    dag.loopConfigs.set(loopId, { id: loopId, nodes: [], iterations: 3, loopType: 'for' } as any)
+
+    const result = validateRunFromBlock(loopId, dag, new Set(['A']))
+
+    expect(result.valid).toBe(false)
+    expect(result.error).toContain('Upstream dependency not executed: B')
+  })
+
   it('allows loop container with no upstream dependencies', () => {
     // Loop containers are validated via their sentinel nodes, not incoming edges on the container itself
     // If the loop has no upstream dependencies, it should be valid
     const loopId = 'loop-container-1'
     const sentinelStartId = `loop-${loopId}-sentinel-start`
     const dag = createDAG([
-      createNode(sentinelStartId, [], { isSentinel: true, sentinelType: 'start', loopId }),
+      createNode(sentinelStartId, [], {
+        isSentinel: true,
+        sentinelType: 'start',
+        subflowId: loopId,
+        subflowType: 'loop',
+      }),
     ])
     dag.loopConfigs.set(loopId, { id: loopId, nodes: [], iterations: 3, loopType: 'for' } as any)
     const executedBlocks = new Set<string>() // Nothing executed but loop has no deps
@@ -463,13 +575,19 @@ describe('computeDirtySet with containers', () => {
       createNode(sentinelStartId, [{ target: 'B' }], {
         isSentinel: true,
         sentinelType: 'start',
-        loopId,
+        subflowId: loopId,
+        subflowType: 'loop',
+      }),
+      createNode('B', [{ target: sentinelEndId }], {
+        isLoopNode: true,
+        subflowId: loopId,
+        subflowType: 'loop',
       }),
-      createNode('B', [{ target: sentinelEndId }], { isLoopNode: true, loopId }),
       createNode(sentinelEndId, [{ target: 'C' }], {
         isSentinel: true,
         sentinelType: 'end',
-        loopId,
+        subflowId: loopId,
+        subflowType: 'loop',
       }),
       createNode('C'),
     ])
@@ -497,13 +615,19 @@ describe('computeDirtySet with containers', () => {
       createNode(sentinelStartId, [{ target: 'B₍0₎' }], {
         isSentinel: true,
         sentinelType: 'start',
-        parallelId,
+        subflowId: parallelId,
+        subflowType: 'parallel',
+      }),
+      createNode('B₍0₎', [{ target: sentinelEndId }], {
+        isParallelBranch: true,
+        subflowId: parallelId,
+        subflowType: 'parallel',
       }),
-      createNode('B₍0₎', [{ target: sentinelEndId }], { isParallelBranch: true, parallelId }),
       createNode(sentinelEndId, [{ target: 'C' }], {
         isSentinel: true,
         sentinelType: 'end',
-        parallelId,
+        subflowId: parallelId,
+        subflowType: 'parallel',
       }),
       createNode('C'),
     ])
@@ -999,28 +1123,33 @@ describe('run from subflow (loop) scenarios', () => {
       createNode(outerStartId, [{ target: innerStartId }], {
         isSentinel: true,
         sentinelType: 'start',
-        loopId: outerLoopId,
+        subflowId: outerLoopId,
+        subflowType: 'loop',
       }),
       createNode(innerStartId, [{ target: 'B' }], {
         isSentinel: true,
         sentinelType: 'start',
-        loopId: innerLoopId,
+        subflowId: innerLoopId,
+        subflowType: 'loop',
         isLoopNode: true,
       }),
       createNode('B', [{ target: innerEndId }], {
         isLoopNode: true,
-        loopId: innerLoopId,
+        subflowId: innerLoopId,
+        subflowType: 'loop',
       }),
       createNode(innerEndId, [{ target: outerEndId }], {
         isSentinel: true,
         sentinelType: 'end',
-        loopId: innerLoopId,
+        subflowId: innerLoopId,
+        subflowType: 'loop',
         isLoopNode: true,
       }),
       createNode(outerEndId, [{ target: 'C' }], {
         isSentinel: true,
         sentinelType: 'end',
-        loopId: outerLoopId,
+        subflowId: outerLoopId,
+        subflowType: 'loop',
       }),
       createNode('C'),
     ])
diff --git a/apps/sim/executor/utils/run-from-block.ts b/apps/sim/executor/utils/run-from-block.ts
index 4dd1cf62dcf..9d6a25b2065 100644
--- a/apps/sim/executor/utils/run-from-block.ts
+++ b/apps/sim/executor/utils/run-from-block.ts
@@ -162,12 +162,29 @@ export function validateRunFromBlock(
   const isLoopContainer = dag.loopConfigs.has(blockId)
   const isParallelContainer = dag.parallelConfigs.has(blockId)
   const isContainer = isLoopContainer || isParallelContainer
+  let validationNode = node
 
   if (!node && !isContainer) {
     return { valid: false, error: `Block not found in workflow: ${blockId}` }
   }
 
   if (isContainer) {
+    const parentLoopId = findParentLoop(blockId, dag)
+    if (parentLoopId) {
+      return {
+        valid: false,
+        error: `Cannot run from block inside loop: ${parentLoopId}`,
+      }
+    }
+
+    const parentParallelId = findParentParallel(blockId, dag)
+    if (parentParallelId) {
+      return {
+        valid: false,
+        error: `Cannot run from block inside parallel: ${parentParallelId}`,
+      }
+    }
+
     const sentinelStartId = resolveContainerToSentinelStart(blockId, dag)
     if (!sentinelStartId || !dag.nodes.has(sentinelStartId)) {
       return {
@@ -175,29 +192,32 @@ export function validateRunFromBlock(
         error: `Container sentinel not found for: ${blockId}`,
       }
     }
+    validationNode = dag.nodes.get(sentinelStartId)
   }
 
   if (node) {
     if (node.metadata.isLoopNode) {
       return {
         valid: false,
-        error: `Cannot run from block inside loop: ${node.metadata.loopId}`,
+        error: `Cannot run from block inside loop: ${node.metadata.subflowId}`,
       }
     }
 
     if (node.metadata.isParallelBranch) {
       return {
         valid: false,
-        error: `Cannot run from block inside parallel: ${node.metadata.parallelId}`,
+        error: `Cannot run from block inside parallel: ${node.metadata.subflowId}`,
       }
     }
 
     if (node.metadata.isSentinel) {
       return { valid: false, error: 'Cannot run from sentinel node' }
     }
+  }
 
+  if (validationNode) {
     // Check immediate upstream dependencies were executed
-    for (const sourceId of node.incomingEdges) {
+    for (const sourceId of validationNode.incomingEdges) {
       const sourceNode = dag.nodes.get(sourceId)
       // Skip sentinel nodes - they're internal and not in executedBlocks
       if (sourceNode?.metadata.isSentinel) continue
@@ -217,3 +237,21 @@ export function validateRunFromBlock(
 
   return { valid: true }
 }
+
+function findParentLoop(blockId: string, dag: DAG): string | undefined {
+  for (const [loopId, config] of dag.loopConfigs) {
+    if (loopId !== blockId && config.nodes?.includes(blockId)) {
+      return loopId
+    }
+  }
+  return undefined
+}
+
+function findParentParallel(blockId: string, dag: DAG): string | undefined {
+  for (const [parallelId, config] of dag.parallelConfigs) {
+    if (parallelId !== blockId && config.nodes?.includes(blockId)) {
+      return parallelId
+    }
+  }
+  return undefined
+}
diff --git a/apps/sim/executor/utils/subflow-utils.server.ts b/apps/sim/executor/utils/subflow-utils.server.ts
index a748daffcda..5592d050908 100644
--- a/apps/sim/executor/utils/subflow-utils.server.ts
+++ b/apps/sim/executor/utils/subflow-utils.server.ts
@@ -76,7 +76,8 @@ async function normalizeCollectionValue(ctx: ExecutionContext, value: unknown):
 export async function resolveArrayInputAsync(
   ctx: ExecutionContext,
   items: any,
-  resolver: VariableResolver | null
+  resolver: VariableResolver | null,
+  currentNodeId = ''
 ): Promise<any[]> {
   if (typeof items !== 'string') {
     if (items === null) {
@@ -87,7 +88,7 @@ export async function resolveArrayInputAsync(
         return []
       }
       try {
-        const resolved = (await resolver.resolveInputs(ctx, 'subflow_items', { items })).items
+        const resolved = (await resolver.resolveInputs(ctx, currentNodeId, { items })).items
         return normalizeCollectionValue(ctx, resolved)
       } catch (error) {
         if (error instanceof Error && error.message.startsWith('Resolved items')) {
@@ -101,7 +102,7 @@ export async function resolveArrayInputAsync(
 
   if (items.startsWith(REFERENCE.START) && items.endsWith(REFERENCE.END) && resolver) {
     try {
-      const resolved = await resolver.resolveSingleReference(ctx, '', items, undefined, {
+      const resolved = await resolver.resolveSingleReference(ctx, currentNodeId, items, undefined, {
         allowLargeValueRefs: true,
       })
       return normalizeCollectionValue(ctx, resolved)
diff --git a/apps/sim/executor/utils/subflow-utils.ts b/apps/sim/executor/utils/subflow-utils.ts
index d87245bccb6..8a5846b7a5c 100644
--- a/apps/sim/executor/utils/subflow-utils.ts
+++ b/apps/sim/executor/utils/subflow-utils.ts
@@ -4,6 +4,7 @@ import { DEFAULTS, LOOP, PARALLEL } from '@/executor/constants'
 import type { ContextExtensions } from '@/executor/execution/types'
 import { type BlockLog, type ExecutionContext, getNextExecutionOrder } from '@/executor/types'
 import { buildContainerIterationContext } from '@/executor/utils/iteration-context'
+import type { SerializedWorkflow } from '@/serializer/types'
 
 const logger = createLogger('SubflowUtils')
 
@@ -107,6 +108,12 @@ export function extractOuterBranchIndex(clonedId: string): number | undefined {
   return match ? Number.parseInt(match[1], 10) : undefined
 }
 
+export function extractInnermostOuterBranchIndex(clonedId: string): number | undefined {
+  const matches = Array.from(clonedId.matchAll(/__obranch-(\d+)/g))
+  const lastMatch = matches.at(-1)
+  return lastMatch ? Number.parseInt(lastMatch[1], 10) : undefined
+}
+
 /**
  * Strips all clone suffixes (`__obranch-N`) and branch subscripts (`₍N₎`)
  * from a node ID, returning the original workflow-level block ID.
@@ -117,11 +124,18 @@ export function stripCloneSuffixes(nodeId: string): string {
   )
 }
 
+/**
+ * Builds a stable ID for an output scoped to a global outer parallel branch.
+ */
+export function buildOuterBranchScopedId(originalId: string, branchIndex: number): string {
+  return `${originalId}__obranch-${branchIndex}`
+}
+
 /**
  * Builds a cloned subflow ID from an original ID and outer branch index.
  */
 export function buildClonedSubflowId(originalId: string, branchIndex: number): string {
-  return `${originalId}__obranch-${branchIndex}`
+  return buildOuterBranchScopedId(originalId, branchIndex)
 }
 
 /**
@@ -146,8 +160,23 @@ export function stripOuterBranchSuffix(id: string): string {
 export function findEffectiveContainerId(
   originalId: string,
   currentNodeId: string,
-  executionMap: Map<string, unknown>
+  executionMap: Map<string, unknown>,
+  mappedBranchIndex?: number
 ): string {
+  if (mappedBranchIndex !== undefined && mappedBranchIndex > 0) {
+    const cloneSuffix = `__obranch-${mappedBranchIndex}`
+    const candidateId = buildClonedSubflowId(originalId, mappedBranchIndex)
+    if (executionMap.has(candidateId)) {
+      return candidateId
+    }
+
+    for (const scopeId of executionMap.keys()) {
+      if (scopeId.endsWith(cloneSuffix) && stripOuterBranchSuffix(scopeId) === originalId) {
+        return scopeId
+      }
+    }
+  }
+
   // Prefer the cloned variant when currentNodeId carries an __obranch-N suffix.
   // During concurrent parallel-in-loop execution both the original (branch 0)
   // and cloned variants coexist in the map; the clone is the correct scope.
@@ -197,6 +226,76 @@ export function normalizeNodeId(nodeId: string): string {
   return nodeId
 }
 
+type SubflowContainerType = 'loop' | 'parallel'
+
+function getSubflowNodes(
+  workflow: Pick<SerializedWorkflow, 'loops' | 'parallels'>,
+  type: SubflowContainerType,
+  id: string
+): string[] | undefined {
+  return type === 'loop' ? workflow.loops?.[id]?.nodes : workflow.parallels?.[id]?.nodes
+}
+
+export function subflowContainsBlock(
+  workflow: Pick<SerializedWorkflow, 'loops' | 'parallels'>,
+  containerType: SubflowContainerType,
+  containerId: string,
+  baseBlockId: string,
+  visited = new Set<string>()
+): boolean {
+  const visitKey = `${containerType}:${containerId}`
+  if (visited.has(visitKey)) return false
+  visited.add(visitKey)
+
+  const nodes = getSubflowNodes(workflow, containerType, containerId)
+  if (!nodes) return false
+
+  for (const nodeId of nodes) {
+    if (nodeId === baseBlockId) return true
+    if (workflow.loops?.[nodeId]) {
+      if (subflowContainsBlock(workflow, 'loop', nodeId, baseBlockId, visited)) return true
+    } else if (workflow.parallels?.[nodeId]) {
+      if (subflowContainsBlock(workflow, 'parallel', nodeId, baseBlockId, visited)) return true
+    }
+  }
+  return false
+}
+
+export function isSubflowNestedInside(
+  workflow: Pick<SerializedWorkflow, 'loops' | 'parallels'>,
+  childType: SubflowContainerType,
+  childId: string,
+  ancestorType: SubflowContainerType,
+  ancestorId: string,
+  visited = new Set<string>()
+): boolean {
+  const visitKey = `${ancestorType}:${ancestorId}`
+  if (visited.has(visitKey)) return false
+  visited.add(visitKey)
+
+  const nodes = getSubflowNodes(workflow, ancestorType, ancestorId)
+  if (!nodes) return false
+
+  for (const nodeId of nodes) {
+    if (
+      nodeId === childId &&
+      (childType === 'loop' ? workflow.loops?.[childId] : workflow.parallels?.[childId])
+    ) {
+      return true
+    }
+    if (workflow.loops?.[nodeId]) {
+      if (isSubflowNestedInside(workflow, childType, childId, 'loop', nodeId, visited)) {
+        return true
+      }
+    } else if (workflow.parallels?.[nodeId]) {
+      if (isSubflowNestedInside(workflow, childType, childId, 'parallel', nodeId, visited)) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
 /**
  * Creates and logs an error for a subflow (loop or parallel).
  */
@@ -262,77 +361,10 @@ export async function addSubflowErrorLog(
   }
 }
 
-/**
- * Emits block log + SSE events for a loop/parallel that was skipped due to an
- * empty collection or false initial condition. This ensures the container block
- * appears in terminal logs, execution snapshots, and edge highlighting.
- */
-export async function emitEmptySubflowEvents(
-  ctx: ExecutionContext,
-  blockId: string,
-  blockType: 'loop' | 'parallel',
-  contextExtensions: ContextExtensions | null
-): Promise<void> {
-  const now = new Date().toISOString()
-  const executionOrder = getNextExecutionOrder(ctx)
-  const output = { results: [] }
-  const block = ctx.workflow?.blocks.find((b) => b.id === blockId)
-  const blockName = block?.metadata?.name ?? blockType
-  const iterationContext = buildContainerIterationContext(ctx, blockId)
-
-  ctx.blockLogs.push({
-    blockId,
-    blockName,
-    blockType,
-    startedAt: now,
-    endedAt: now,
-    durationMs: DEFAULTS.EXECUTION_TIME,
-    success: true,
-    output,
-    executionOrder,
-  })
-
-  if (contextExtensions?.onBlockStart) {
-    try {
-      await contextExtensions.onBlockStart(blockId, blockName, blockType, executionOrder)
-    } catch (error) {
-      logger.warn('Empty subflow start callback failed', {
-        blockId,
-        blockType,
-        error: toError(error).message,
-      })
-    }
-  }
-
-  if (contextExtensions?.onBlockComplete) {
-    try {
-      await contextExtensions.onBlockComplete(
-        blockId,
-        blockName,
-        blockType,
-        {
-          output,
-          executionTime: DEFAULTS.EXECUTION_TIME,
-          startedAt: now,
-          executionOrder,
-          endedAt: now,
-        },
-        iterationContext
-      )
-    } catch (error) {
-      logger.warn('Empty subflow completion callback failed', {
-        blockId,
-        blockType,
-        error: toError(error).message,
-      })
-    }
-  }
-}
-
 /**
  * Emits the BlockLog + onBlockComplete callback for a loop/parallel container that
- * finished successfully with at least one iteration. Without this, successful container
- * runs produce no top-level BlockLog, which forces the trace-span builder to fall back
+ * finished successfully. Without this, successful container runs produce no top-level BlockLog,
+ * which forces the trace-span builder to fall back
  * to generic counter-based names ("Loop 1", "Parallel 1") instead of the user-configured
  * block name.
  */
diff --git a/apps/sim/executor/variables/resolvers/block.test.ts b/apps/sim/executor/variables/resolvers/block.test.ts
index a739dc28734..a225bb9edfe 100644
--- a/apps/sim/executor/variables/resolvers/block.test.ts
+++ b/apps/sim/executor/variables/resolvers/block.test.ts
@@ -141,7 +141,8 @@ function createTestWorkflow(
     name?: string
     type?: string
     outputs?: Record<string, any>
-  }> = []
+  }> = [],
+  subflows: { loops?: Record<string, any>; parallels?: Record<string, any> } = {}
 ) {
   return {
     version: '1.0',
@@ -155,8 +156,8 @@ function createTestWorkflow(
       enabled: true,
     })),
     connections: [],
-    loops: {},
-    parallels: {},
+    loops: subflows.loops ?? {},
+    parallels: subflows.parallels ?? {},
   }
 }
 
@@ -166,7 +167,8 @@ function createTestWorkflow(
 function createTestContext(
   currentNodeId: string,
   blockOutputs: Record<string, any> = {},
-  contextBlockStates?: Map<string, { output: any }>
+  contextBlockStates?: Map<string, { output: any }>,
+  parallelBlockMapping?: Map<string, any>
 ): ResolutionContext {
   const state = new ExecutionState()
   for (const [blockId, output] of Object.entries(blockOutputs)) {
@@ -179,6 +181,7 @@ function createTestContext(
       workflowId: 'workflow-1',
       executionId: 'execution-1',
       blockStates: contextBlockStates ?? new Map(),
+      parallelBlockMapping,
     },
     executionState: state,
     currentNodeId,
@@ -251,6 +254,114 @@ describe('BlockResolver', () => {
       expect(resolver.resolve('<source.user.profile.email>', ctx)).toBe('alice@test.com')
     })
 
+    it('does not fall back to unscoped block state inside cloned subflow branches', () => {
+      const workflow = createTestWorkflow([{ id: 'source' }], {
+        parallels: { 'parallel-1': { id: 'parallel-1', nodes: ['source'] } },
+      })
+      const resolver = new BlockResolver(workflow)
+      const ctx = createTestContext(
+        'consumer__clone-inner__obranch-1₍0₎',
+        {},
+        new Map([['source', { output: { result: 'branch-0' } }]])
+      )
+
+      expect(resolver.resolve('<source.result>', ctx)).toBe(RESOLVED_EMPTY)
+    })
+
+    it('allows cloned subflows to resolve top-level upstream block state', () => {
+      const workflow = createTestWorkflow([{ id: 'source' }])
+      const resolver = new BlockResolver(workflow)
+      const ctx = createTestContext(
+        'consumer__clone-inner__obranch-1₍0₎',
+        {},
+        new Map([['source', { output: { result: 'global' } }]])
+      )
+
+      expect(resolver.resolve('<source.result>', ctx)).toBe('global')
+    })
+
+    it('uses parallel block mappings to resolve cloned subflow outputs in later batches', () => {
+      const workflow = createTestWorkflow(
+        [
+          { id: 'nested-loop', name: 'Nested Loop' },
+          { id: 'consumer', name: 'Consumer' },
+        ],
+        {
+          loops: { 'nested-loop': { id: 'nested-loop', nodes: ['loop-task'] } },
+          parallels: { 'parallel-1': { id: 'parallel-1', nodes: ['nested-loop', 'consumer'] } },
+        }
+      )
+      const resolver = new BlockResolver(workflow)
+      const ctx = createTestContext(
+        'consumer₍0₎',
+        {
+          'nested-loop': { results: ['branch-0'] },
+          'nested-loop__obranch-2': { results: ['branch-2'] },
+        },
+        undefined,
+        new Map([
+          [
+            'consumer₍0₎',
+            { originalBlockId: 'consumer', parallelId: 'parallel-1', iterationIndex: 2 },
+          ],
+        ])
+      )
+
+      expect(resolver.resolve('<nestedloop.results>', ctx)).toEqual(['branch-2'])
+    })
+
+    it('resolves regular block outputs from the same cloned branch scope', () => {
+      const workflow = createTestWorkflow(
+        [
+          { id: 'source', name: 'Source' },
+          { id: 'consumer', name: 'Consumer' },
+        ],
+        {
+          parallels: { 'parallel-1': { id: 'parallel-1', nodes: ['source', 'consumer'] } },
+        }
+      )
+      const resolver = new BlockResolver(workflow)
+      const ctx = createTestContext('consumer__cloneabc__obranch-2₍0₎', {
+        'source__obranch-2': { result: 'wrong-container-alias' },
+        'source__cloneabc__obranch-2₍0₎': { result: 'same-branch' },
+      })
+
+      expect(resolver.resolve('<source.result>', ctx)).toBe('same-branch')
+    })
+
+    it('uses outer branch suffix over inner parallel mappings for cloned subflow outputs', () => {
+      const workflow = createTestWorkflow(
+        [
+          { id: 'sibling-loop', name: 'Sibling Loop' },
+          { id: 'inner-task', name: 'Inner Task' },
+        ],
+        {
+          loops: { 'sibling-loop': { id: 'sibling-loop', nodes: ['loop-task'] } },
+          parallels: {
+            'outer-parallel': { id: 'outer-parallel', nodes: ['sibling-loop', 'inner-parallel'] },
+            'inner-parallel': { id: 'inner-parallel', nodes: ['inner-task'] },
+          },
+        }
+      )
+      const resolver = new BlockResolver(workflow)
+      const ctx = createTestContext(
+        'inner-task__clone-inner__obranch-2₍0₎',
+        {
+          'sibling-loop__obranch-1': { results: ['inner-branch-1'] },
+          'sibling-loop__obranch-2': { results: ['outer-branch-2'] },
+        },
+        undefined,
+        new Map([
+          [
+            'inner-task__clone-inner__obranch-2₍0₎',
+            { originalBlockId: 'inner-task', parallelId: 'inner-parallel', iterationIndex: 1 },
+          ],
+        ])
+      )
+
+      expect(resolver.resolve('<siblingloop.results>', ctx)).toEqual(['outer-branch-2'])
+    })
+
     it('should resolve nested scalar paths inside compacted block references', async () => {
       const workflow = createTestWorkflow([{ id: 'source' }])
       const resolver = new BlockResolver(workflow)
diff --git a/apps/sim/executor/variables/resolvers/block.ts b/apps/sim/executor/variables/resolvers/block.ts
index 7a03093e6a1..32bce35e0bd 100644
--- a/apps/sim/executor/variables/resolvers/block.ts
+++ b/apps/sim/executor/variables/resolvers/block.ts
@@ -13,6 +13,7 @@ import {
   resolveBlockReferenceAsync,
 } from '@/executor/utils/block-reference'
 import { formatLiteralForCode } from '@/executor/utils/code-formatting'
+import { buildClonedSubflowId, extractOuterBranchIndex } from '@/executor/utils/subflow-utils'
 import {
   type AsyncPathNavigator,
   navigatePath,
@@ -25,6 +26,8 @@ import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
 export class BlockResolver implements Resolver {
   private nameToBlockId: Map<string, string>
   private blockById: Map<string, SerializedBlock>
+  private blockIdsInSubflows: Set<string>
+  private subflowContainerIds: Set<string>
 
   constructor(
     private workflow: SerializedWorkflow,
@@ -32,12 +35,27 @@ export class BlockResolver implements Resolver {
   ) {
     this.nameToBlockId = new Map()
     this.blockById = new Map()
+    this.blockIdsInSubflows = new Set()
+    this.subflowContainerIds = new Set([
+      ...Object.keys(workflow.loops ?? {}),
+      ...Object.keys(workflow.parallels ?? {}),
+    ])
     for (const block of workflow.blocks) {
       this.blockById.set(block.id, block)
       if (block.metadata?.name) {
         this.nameToBlockId.set(normalizeName(block.metadata.name), block.id)
       }
     }
+    for (const loop of Object.values(workflow.loops ?? {})) {
+      for (const blockId of loop.nodes ?? []) {
+        this.blockIdsInSubflows.add(blockId)
+      }
+    }
+    for (const parallel of Object.values(workflow.parallels ?? {})) {
+      for (const blockId of parallel.nodes ?? []) {
+        this.blockIdsInSubflows.add(blockId)
+      }
+    }
   }
 
   canResolve(reference: string): boolean {
@@ -282,10 +300,36 @@ export class BlockResolver implements Resolver {
   }
 
   private getBlockOutput(blockId: string, context: ResolutionContext): any {
+    const outerBranchIndex = extractOuterBranchIndex(context.currentNodeId)
+    const mappedBranchIndex =
+      outerBranchIndex ??
+      context.executionContext.parallelBlockMapping?.get(context.currentNodeId)?.iterationIndex
+    const shouldResolveClonedSubflowOutput =
+      mappedBranchIndex !== undefined &&
+      mappedBranchIndex > 0 &&
+      this.subflowContainerIds.has(blockId)
+
+    if (shouldResolveClonedSubflowOutput) {
+      const clonedStateOutput = context.executionState.getBlockOutput(
+        buildClonedSubflowId(blockId, mappedBranchIndex)
+      )
+      if (clonedStateOutput !== undefined) {
+        return clonedStateOutput
+      }
+    }
+
     const stateOutput = context.executionState.getBlockOutput(blockId, context.currentNodeId)
     if (stateOutput !== undefined) {
       return stateOutput
     }
+
+    if (
+      shouldResolveClonedSubflowOutput ||
+      (outerBranchIndex !== undefined && this.blockIdsInSubflows.has(blockId))
+    ) {
+      return undefined
+    }
+
     const contextState = context.executionContext.blockStates?.get(blockId)
     if (contextState?.output) {
       return contextState.output
diff --git a/apps/sim/executor/variables/resolvers/loop.test.ts b/apps/sim/executor/variables/resolvers/loop.test.ts
index 48576ffc67a..d0314b60957 100644
--- a/apps/sim/executor/variables/resolvers/loop.test.ts
+++ b/apps/sim/executor/variables/resolvers/loop.test.ts
@@ -17,7 +17,11 @@ interface BlockDef {
   name: string
 }
 
-function createTestWorkflow(loops: Record<string, LoopDef> = {}, blockDefs: BlockDef[] = []) {
+function createTestWorkflow(
+  loops: Record<string, LoopDef> = {},
+  blockDefs: BlockDef[] = [],
+  parallels: Record<string, { id?: string; nodes: string[] }> = {}
+) {
   const normalizedLoops: Record<string, { id: string; nodes: string[]; iterations: number }> = {}
   for (const [key, loop] of Object.entries(loops)) {
     normalizedLoops[key] = {
@@ -41,7 +45,7 @@ function createTestWorkflow(loops: Record<string, LoopDef> = {}, blockDefs: Bloc
     blocks,
     connections: [],
     loops: normalizedLoops,
-    parallels: {},
+    parallels,
   }
 }
 
@@ -58,7 +62,8 @@ function createTestContext(
   currentNodeId: string,
   loopScope?: LoopScope,
   loopExecutions?: Map<string, LoopScope>,
-  blockOutputs?: Record<string, any>
+  blockOutputs?: Record<string, any>,
+  parallelBlockMapping?: Map<string, any>
 ): ResolutionContext {
   return {
     executionContext: {
@@ -66,6 +71,7 @@ function createTestContext(
       workflowId: 'workflow-1',
       executionId: 'execution-1',
       loopExecutions: loopExecutions ?? new Map(),
+      parallelBlockMapping,
     },
     executionState: {
       getBlockOutput: (id: string) => blockOutputs?.[id],
@@ -249,6 +255,34 @@ describe('LoopResolver', () => {
       expect(resolver.resolve('<loop.index>', ctx)).toBe(0)
     })
 
+    it('resolves generic loop context from inside a parallel nested in a loop', () => {
+      const workflow = createTestWorkflow({ 'loop-1': { nodes: ['parallel-1'] } }, [], {
+        'parallel-1': { id: 'parallel-1', nodes: ['block-1'] },
+      })
+      const resolver = new LoopResolver(workflow)
+      const loopScope = createLoopScope({ iteration: 3 })
+      const ctx = createTestContext('block-1₍0₎', undefined, new Map([['loop-1', loopScope]]))
+
+      expect(resolver.resolve('<loop.index>', ctx)).toBe(3)
+    })
+
+    it('resolves inner cloned loop context independently from outer clone indexes', () => {
+      const workflow = createTestWorkflow({ 'loop-1': { nodes: ['task'] } })
+      const resolver = new LoopResolver(workflow)
+      const loopExecutions = new Map<string, LoopScope>([
+        ['loop-1__obranch-1', createLoopScope({ iteration: 4, item: 'inner-branch-1' })],
+        ['loop-1__obranch-2', createLoopScope({ iteration: 9, item: 'outer-branch-2' })],
+      ])
+      const ctx = createTestContext(
+        'task__cloneabc__obranch-2__clonedef__obranch-1',
+        undefined,
+        loopExecutions
+      )
+
+      expect(resolver.resolve('<loop.index>', ctx)).toBe(4)
+      expect(resolver.resolve('<loop.currentItem>', ctx)).toBe('inner-branch-1')
+    })
+
     it.concurrent('should handle null item value', () => {
       const resolver = new LoopResolver(createTestWorkflow())
       const loopScope = createLoopScope({ item: null })
@@ -395,6 +429,62 @@ describe('LoopResolver', () => {
       expect(resolver.resolve('<loop1.results>', ctx)).toEqual(results)
     })
 
+    it('uses parallel block mappings to resolve cloned loop outputs in later batches', () => {
+      const workflow = createTestWorkflow({ 'loop-1': { nodes: ['block-1'] } }, [
+        { id: 'loop-1', name: 'Loop 1' },
+      ])
+      const resolver = new LoopResolver(workflow)
+      const loopExecutions = new Map<string, LoopScope>([
+        ['loop-1', createLoopScope()],
+        ['loop-1__obranch-2', createLoopScope()],
+      ])
+      const ctx = createTestContext(
+        'consumer₍0₎',
+        undefined,
+        loopExecutions,
+        {
+          'loop-1': { results: ['branch-0'] },
+          'loop-1__obranch-2': { results: ['branch-2'] },
+        },
+        new Map([
+          [
+            'consumer₍0₎',
+            { originalBlockId: 'consumer', parallelId: 'parallel-1', iterationIndex: 2 },
+          ],
+        ])
+      )
+
+      expect(resolver.resolve('<loop1.results>', ctx)).toEqual(['branch-2'])
+    })
+
+    it('uses outer branch suffix over inner parallel mappings for cloned loop outputs', () => {
+      const workflow = createTestWorkflow({ 'loop-1': { nodes: ['block-1'] } }, [
+        { id: 'loop-1', name: 'Loop 1' },
+      ])
+      const resolver = new LoopResolver(workflow)
+      const loopExecutions = new Map<string, LoopScope>([
+        ['loop-1__obranch-1', createLoopScope()],
+        ['loop-1__obranch-2', createLoopScope()],
+      ])
+      const ctx = createTestContext(
+        'consumer__cloneabc__obranch-2₍0₎',
+        undefined,
+        loopExecutions,
+        {
+          'loop-1__obranch-1': { results: ['outer-branch-1'] },
+          'loop-1__obranch-2': { results: ['outer-branch-2'] },
+        },
+        new Map([
+          [
+            'consumer__cloneabc__obranch-2₍0₎',
+            { originalBlockId: 'consumer', parallelId: 'inner-parallel', iterationIndex: 1 },
+          ],
+        ])
+      )
+
+      expect(resolver.resolve('<loop1.results>', ctx)).toEqual(['outer-branch-2'])
+    })
+
     it.concurrent('should resolve result with nested path', () => {
       const workflow = createTestWorkflow({ 'loop-1': { nodes: ['block-1'] } }, [
         { id: 'loop-1', name: 'Loop 1' },
diff --git a/apps/sim/executor/variables/resolvers/loop.ts b/apps/sim/executor/variables/resolvers/loop.ts
index ef483c995ce..a6841f2608d 100644
--- a/apps/sim/executor/variables/resolvers/loop.ts
+++ b/apps/sim/executor/variables/resolvers/loop.ts
@@ -3,9 +3,13 @@ import { assertNoLargeValueRefs } from '@/lib/execution/payloads/large-value-ref
 import { isReference, normalizeName, parseReferencePath, REFERENCE } from '@/executor/constants'
 import { InvalidFieldError } from '@/executor/utils/block-reference'
 import {
+  extractInnermostOuterBranchIndex,
+  extractOuterBranchIndex,
   findEffectiveContainerId,
+  isSubflowNestedInside,
   stripCloneSuffixes,
   stripOuterBranchSuffix,
+  subflowContainsBlock,
 } from '@/executor/utils/subflow-utils'
 import {
   type AsyncPathNavigator,
@@ -98,10 +102,16 @@ export class LoopResolver implements Resolver {
 
     // Resolve the effective (possibly cloned) loop ID for scope/output lookups
     if (targetLoopId && context.executionContext.loopExecutions) {
+      const mappedBranchIndex =
+        (isGenericRef
+          ? extractInnermostOuterBranchIndex(context.currentNodeId)
+          : extractOuterBranchIndex(context.currentNodeId)) ??
+        context.executionContext.parallelBlockMapping?.get(context.currentNodeId)?.iterationIndex
       targetLoopId = findEffectiveContainerId(
         targetLoopId,
         context.currentNodeId,
-        context.executionContext.loopExecutions
+        context.executionContext.loopExecutions,
+        mappedBranchIndex
       )
     }
 
@@ -243,7 +253,7 @@ export class LoopResolver implements Resolver {
     const baseId = stripCloneSuffixes(blockId)
     const loops = this.workflow.loops || {}
     const candidateLoopIds = Object.keys(loops).filter((loopId) =>
-      loops[loopId].nodes.includes(baseId)
+      subflowContainsBlock(this.workflow, 'loop', loopId, baseId)
     )
     if (candidateLoopIds.length === 0) return undefined
     if (candidateLoopIds.length === 1) return candidateLoopIds[0]
@@ -252,7 +262,9 @@ export class LoopResolver implements Resolver {
     // In a valid DAG, exactly one candidate will satisfy this (circular containment is impossible).
     return candidateLoopIds.find((candidateId) =>
       candidateLoopIds.every(
-        (otherId) => otherId === candidateId || !loops[candidateId].nodes.includes(otherId)
+        (otherId) =>
+          otherId === candidateId ||
+          !isSubflowNestedInside(this.workflow, 'loop', otherId, 'loop', candidateId)
       )
     )
   }
@@ -260,46 +272,7 @@ export class LoopResolver implements Resolver {
   private isBlockInLoopOrDescendant(blockId: string, targetLoopId: string): boolean {
     const baseId = stripCloneSuffixes(blockId)
     const originalLoopId = stripOuterBranchSuffix(targetLoopId)
-    const targetLoop = this.workflow.loops?.[originalLoopId]
-    if (!targetLoop) {
-      return false
-    }
-    if (targetLoop.nodes.includes(baseId)) {
-      return true
-    }
-    const directLoopId = this.findInnermostLoopForBlock(blockId)
-    if (!directLoopId) {
-      return false
-    }
-    if (directLoopId === originalLoopId) {
-      return true
-    }
-    return this.isLoopNestedInside(directLoopId, originalLoopId)
-  }
-
-  private isLoopNestedInside(
-    childLoopId: string,
-    ancestorLoopId: string,
-    visited = new Set<string>()
-  ): boolean {
-    if (visited.has(ancestorLoopId)) return false
-    visited.add(ancestorLoopId)
-
-    const ancestorLoop = this.workflow.loops?.[ancestorLoopId]
-    if (!ancestorLoop) {
-      return false
-    }
-    if (ancestorLoop.nodes.includes(childLoopId)) {
-      return true
-    }
-    for (const nodeId of ancestorLoop.nodes) {
-      if (this.workflow.loops[nodeId]) {
-        if (this.isLoopNestedInside(childLoopId, nodeId, visited)) {
-          return true
-        }
-      }
-    }
-    return false
+    return subflowContainsBlock(this.workflow, 'loop', originalLoopId, baseId)
   }
 
   private isForEachLoop(loopId: string): boolean {
diff --git a/apps/sim/executor/variables/resolvers/parallel.test.ts b/apps/sim/executor/variables/resolvers/parallel.test.ts
index 3d4764acd4a..ebcad1a21bf 100644
--- a/apps/sim/executor/variables/resolvers/parallel.test.ts
+++ b/apps/sim/executor/variables/resolvers/parallel.test.ts
@@ -22,7 +22,8 @@ function createTestWorkflow(
       parallelType?: 'count' | 'collection'
     }
   > = {},
-  blockDefs: BlockDef[] = []
+  blockDefs: BlockDef[] = [],
+  loops: Record<string, { id?: string; nodes: string[] }> = {}
 ) {
   const normalizedParallels: Record<
     string,
@@ -54,7 +55,7 @@ function createTestWorkflow(
     version: '1.0',
     blocks,
     connections: [],
-    loops: {},
+    loops,
     parallels: normalizedParallels,
   }
 }
@@ -78,7 +79,8 @@ function createTestContext(
   currentNodeId: string,
   parallelExecutions?: Map<string, any>,
   blockOutputs?: Record<string, any>,
-  parallelBlockMapping?: Map<string, any>
+  parallelBlockMapping?: Map<string, any>,
+  subflowParentMap?: Map<string, any>
 ): ResolutionContext {
   return {
     executionContext: {
@@ -87,6 +89,7 @@ function createTestContext(
       executionId: 'execution-1',
       parallelExecutions: parallelExecutions ?? new Map(),
       parallelBlockMapping,
+      subflowParentMap,
     },
     executionState: {
       getBlockOutput: (id: string) => blockOutputs?.[id],
@@ -452,6 +455,71 @@ describe('ParallelResolver', () => {
       expect(resolver.resolve('<parallel1.results>', ctx)).toEqual(results)
     })
 
+    it('uses parallel block mappings to resolve cloned parallel outputs in later batches', () => {
+      const workflow = createTestWorkflow(
+        { 'nested-parallel': { nodes: ['block-1'], distribution: ['a', 'b'] } },
+        [{ id: 'nested-parallel', name: 'Nested Parallel' }]
+      )
+      const resolver = new ParallelResolver(workflow)
+      const parallelExecutions = new Map<string, any>([
+        ['nested-parallel', { parallelId: 'nested-parallel', branchOutputs: new Map() }],
+        [
+          'nested-parallel__obranch-2',
+          { parallelId: 'nested-parallel__obranch-2', branchOutputs: new Map() },
+        ],
+      ])
+      const ctx = createTestContext(
+        'consumer₍0₎',
+        parallelExecutions,
+        {
+          'nested-parallel': { results: ['branch-0'] },
+          'nested-parallel__obranch-2': { results: ['branch-2'] },
+        },
+        new Map([
+          [
+            'consumer₍0₎',
+            { originalBlockId: 'consumer', parallelId: 'parallel-1', iterationIndex: 2 },
+          ],
+        ])
+      )
+
+      expect(resolver.resolve('<nestedparallel.results>', ctx)).toEqual(['branch-2'])
+    })
+
+    it('uses outer branch suffix over inner parallel mappings for cloned parallel outputs', () => {
+      const workflow = createTestWorkflow(
+        { 'nested-parallel': { nodes: ['block-1'], distribution: ['a', 'b'] } },
+        [{ id: 'nested-parallel', name: 'Nested Parallel' }]
+      )
+      const resolver = new ParallelResolver(workflow)
+      const parallelExecutions = new Map<string, any>([
+        [
+          'nested-parallel__obranch-1',
+          { parallelId: 'nested-parallel__obranch-1', branchOutputs: new Map() },
+        ],
+        [
+          'nested-parallel__obranch-2',
+          { parallelId: 'nested-parallel__obranch-2', branchOutputs: new Map() },
+        ],
+      ])
+      const ctx = createTestContext(
+        'consumer__cloneabc__obranch-2₍0₎',
+        parallelExecutions,
+        {
+          'nested-parallel__obranch-1': { results: ['outer-branch-1'] },
+          'nested-parallel__obranch-2': { results: ['outer-branch-2'] },
+        },
+        new Map([
+          [
+            'consumer__cloneabc__obranch-2₍0₎',
+            { originalBlockId: 'consumer', parallelId: 'inner-parallel', iterationIndex: 1 },
+          ],
+        ])
+      )
+
+      expect(resolver.resolve('<nestedparallel.results>', ctx)).toEqual(['outer-branch-2'])
+    })
+
     it.concurrent('should resolve result with nested path', () => {
       const workflow = createTestWorkflow(
         { 'parallel-1': { nodes: ['block-1'], distribution: ['a', 'b'] } },
@@ -597,5 +665,77 @@ describe('ParallelResolver', () => {
       expect(resolver.resolve('<parallel.results>', ctx)).toEqual(results)
       expect(resolver.resolve('<parallel.result>', ctx)).toEqual(results)
     })
+
+    it('resolves generic parallel context from inside a loop nested in a parallel', () => {
+      const workflow = createTestWorkflow(
+        {
+          'parallel-1': {
+            nodes: ['loop-1'],
+            distribution: ['a', 'b', 'c'],
+            parallelType: 'collection',
+          },
+        },
+        [],
+        { 'loop-1': { id: 'loop-1', nodes: ['block-1'] } }
+      )
+      const resolver = new ParallelResolver(workflow)
+      const ctx = createTestContext(
+        'block-1__cloneaaa__obranch-2',
+        new Map([['parallel-1', createParallelScope(['a', 'b', 'c'])]])
+      )
+
+      expect(resolver.resolve('<parallel.index>', ctx)).toBe(2)
+      expect(resolver.resolve('<parallel.currentItem>', ctx)).toBe('c')
+    })
+
+    it('resolves inner parallel branch context independently from the outer clone index', () => {
+      const workflow = createTestWorkflow({
+        'outer-parallel': {
+          nodes: ['inner-parallel'],
+          distribution: ['outer0', 'outer1', 'outer2'],
+        },
+        'inner-parallel': {
+          nodes: ['block-1'],
+          distribution: ['inner0', 'inner1'],
+        },
+      })
+      const resolver = new ParallelResolver(workflow)
+      const parallelExecutions = new Map([
+        ['inner-parallel__obranch-2', createParallelScope(['inner0', 'inner1'])],
+      ])
+      const ctx = createTestContext('block-1__cloneabc__obranch-2₍1₎', parallelExecutions)
+
+      expect(resolver.resolve('<parallel.index>', ctx)).toBe(1)
+      expect(resolver.resolve('<parallel.currentItem>', ctx)).toBe('inner1')
+    })
+
+    it('resolves parent parallel context for branch-zero nested subflow descendants', () => {
+      const workflow = createTestWorkflow(
+        {
+          'outer-parallel': {
+            nodes: ['inner-loop'],
+            distribution: ['outer0', 'outer1'],
+          },
+        },
+        [],
+        { 'inner-loop': { id: 'inner-loop', nodes: ['loop-task'] } }
+      )
+      const resolver = new ParallelResolver(workflow)
+      const parallelExecutions = new Map([
+        ['outer-parallel', createParallelScope(['outer0', 'outer1'])],
+      ])
+      const ctx = createTestContext(
+        'loop-task',
+        parallelExecutions,
+        undefined,
+        undefined,
+        new Map([
+          ['inner-loop', { parentId: 'outer-parallel', parentType: 'parallel', branchIndex: 0 }],
+        ])
+      )
+
+      expect(resolver.resolve('<parallel.index>', ctx)).toBe(0)
+      expect(resolver.resolve('<parallel.currentItem>', ctx)).toBe('outer0')
+    })
   })
 })
diff --git a/apps/sim/executor/variables/resolvers/parallel.ts b/apps/sim/executor/variables/resolvers/parallel.ts
index e6f033f80ab..06fff3e6411 100644
--- a/apps/sim/executor/variables/resolvers/parallel.ts
+++ b/apps/sim/executor/variables/resolvers/parallel.ts
@@ -4,10 +4,13 @@ import { isReference, normalizeName, parseReferencePath, REFERENCE } from '@/exe
 import { InvalidFieldError } from '@/executor/utils/block-reference'
 import {
   extractBranchIndex,
+  extractInnermostOuterBranchIndex,
   extractOuterBranchIndex,
   findEffectiveContainerId,
+  isSubflowNestedInside,
   stripCloneSuffixes,
   stripOuterBranchSuffix,
+  subflowContainsBlock,
 } from '@/executor/utils/subflow-utils'
 import {
   type AsyncPathNavigator,
@@ -98,10 +101,16 @@ export class ParallelResolver implements Resolver {
 
     // Resolve the effective (possibly cloned) parallel ID for scope lookups
     if (context.executionContext.parallelExecutions) {
+      const mappedBranchIndex =
+        (isGenericRef
+          ? extractInnermostOuterBranchIndex(context.currentNodeId)
+          : extractOuterBranchIndex(context.currentNodeId)) ??
+        context.executionContext.parallelBlockMapping?.get(context.currentNodeId)?.iterationIndex
       targetParallelId = findEffectiveContainerId(
         targetParallelId,
         context.currentNodeId,
-        context.executionContext.parallelExecutions
+        context.executionContext.parallelExecutions,
+        mappedBranchIndex
       )
     }
 
@@ -188,16 +197,59 @@ export class ParallelResolver implements Resolver {
 
   private resolveBranchIndex(targetParallelId: string, context: ResolutionContext): number | null {
     const mapping = context.executionContext.parallelBlockMapping?.get(context.currentNodeId)
-    if (mapping?.parallelId === targetParallelId) {
+    const originalTargetParallelId = stripOuterBranchSuffix(targetParallelId)
+    if (
+      mapping?.parallelId === targetParallelId ||
+      mapping?.parallelId === originalTargetParallelId
+    ) {
       return mapping.iterationIndex
     }
 
+    const branchIndex = extractBranchIndex(context.currentNodeId)
+    if (targetParallelId !== originalTargetParallelId && branchIndex !== null) {
+      return branchIndex
+    }
+
     const outerBranchIndex = extractOuterBranchIndex(context.currentNodeId)
     if (outerBranchIndex !== undefined) {
       return outerBranchIndex
     }
 
-    return extractBranchIndex(context.currentNodeId)
+    const parentBranchIndex = this.resolveParentParallelBranchIndex(
+      originalTargetParallelId,
+      context
+    )
+    if (parentBranchIndex !== undefined) {
+      return parentBranchIndex
+    }
+
+    return branchIndex
+  }
+
+  private resolveParentParallelBranchIndex(
+    targetParallelId: string,
+    context: ResolutionContext
+  ): number | undefined {
+    const parentMap = context.executionContext.subflowParentMap
+    if (!parentMap) return undefined
+
+    const baseId = stripCloneSuffixes(context.currentNodeId)
+    for (const [subflowId, entry] of parentMap) {
+      if (entry.parentType !== 'parallel' || entry.parentId !== targetParallelId) continue
+      if (entry.branchIndex === undefined) continue
+
+      const originalSubflowId = stripOuterBranchSuffix(subflowId)
+      if (this.workflow.loops?.[originalSubflowId]) {
+        if (subflowContainsBlock(this.workflow, 'loop', originalSubflowId, baseId)) {
+          return entry.branchIndex
+        }
+      } else if (this.workflow.parallels?.[originalSubflowId]) {
+        if (subflowContainsBlock(this.workflow, 'parallel', originalSubflowId, baseId)) {
+          return entry.branchIndex
+        }
+      }
+    }
+    return undefined
   }
 
   private findInnermostParallelForBlock(blockId: string): string | undefined {
@@ -206,7 +258,7 @@ export class ParallelResolver implements Resolver {
     if (!parallels) return undefined
 
     const candidateIds = Object.keys(parallels).filter((parallelId) =>
-      parallels[parallelId]?.nodes.includes(baseId)
+      subflowContainsBlock(this.workflow, 'parallel', parallelId, baseId)
     )
     if (candidateIds.length === 0) return undefined
     if (candidateIds.length === 1) return candidateIds[0]
@@ -215,49 +267,16 @@ export class ParallelResolver implements Resolver {
     // In a valid DAG, exactly one candidate will satisfy this (circular containment is impossible).
     return candidateIds.find((candidateId) =>
       candidateIds.every(
-        (otherId) => otherId === candidateId || !parallels[candidateId]?.nodes.includes(otherId)
+        (otherId) =>
+          otherId === candidateId ||
+          !isSubflowNestedInside(this.workflow, 'parallel', otherId, 'parallel', candidateId)
       )
     )
   }
 
   private isBlockInParallelOrDescendant(blockId: string, targetParallelId: string): boolean {
     const baseId = stripCloneSuffixes(blockId)
-    const parallels = this.workflow.parallels
-    if (!parallels) return false
-
-    const targetConfig = parallels[targetParallelId]
-    if (!targetConfig) return false
-
-    if (targetConfig.nodes.includes(baseId)) return true
-
-    const directParallelId = this.findInnermostParallelForBlock(blockId)
-    if (!directParallelId) return false
-    if (directParallelId === targetParallelId) return true
-
-    return this.isParallelNestedInside(directParallelId, targetParallelId)
-  }
-
-  private isParallelNestedInside(
-    childParallelId: string,
-    ancestorParallelId: string,
-    visited = new Set<string>()
-  ): boolean {
-    if (visited.has(ancestorParallelId)) return false
-    visited.add(ancestorParallelId)
-
-    const ancestorConfig = this.workflow.parallels?.[ancestorParallelId]
-    if (!ancestorConfig) return false
-
-    if (ancestorConfig.nodes.includes(childParallelId)) return true
-
-    for (const nodeId of ancestorConfig.nodes) {
-      if (this.workflow.parallels?.[nodeId]) {
-        if (this.isParallelNestedInside(childParallelId, nodeId, visited)) {
-          return true
-        }
-      }
-    }
-    return false
+    return subflowContainsBlock(this.workflow, 'parallel', targetParallelId, baseId)
   }
 
   private resolveCurrentItem(
diff --git a/apps/sim/hooks/queries/providers.ts b/apps/sim/hooks/queries/providers.ts
index c7eaabf5035..902d3b27bc2 100644
--- a/apps/sim/hooks/queries/providers.ts
+++ b/apps/sim/hooks/queries/providers.ts
@@ -5,6 +5,7 @@ import { requestJson } from '@/lib/api/client/request'
 import {
   getBaseProviderModelsContract,
   getFireworksProviderModelsContract,
+  getLitellmProviderModelsContract,
   getOllamaProviderModelsContract,
   getOpenRouterProviderModelsContract,
   getVllmProviderModelsContract,
@@ -54,6 +55,8 @@ async function requestProviderModels(
       return requestJson(getOllamaProviderModelsContract, { signal })
     case 'vllm':
       return requestJson(getVllmProviderModelsContract, { signal })
+    case 'litellm':
+      return requestJson(getLitellmProviderModelsContract, { signal })
     case 'openrouter':
       return requestJson(getOpenRouterProviderModelsContract, { signal })
     case 'fireworks':
diff --git a/apps/sim/lib/api-key/byok.ts b/apps/sim/lib/api-key/byok.ts
index a2aa198e859..01e9d0fcbc0 100644
--- a/apps/sim/lib/api-key/byok.ts
+++ b/apps/sim/lib/api-key/byok.ts
@@ -74,6 +74,12 @@ export async function getApiKeyWithBYOK(
     return { apiKey: userProvidedKey || env.VLLM_API_KEY || 'empty', isBYOK: false }
   }
 
+  const isLitellmModel =
+    provider === 'litellm' || useProvidersStore.getState().providers.litellm.models.includes(model)
+  if (isLitellmModel) {
+    return { apiKey: userProvidedKey || env.LITELLM_API_KEY || 'empty', isBYOK: false }
+  }
+
   const isFireworksModel =
     provider === 'fireworks' ||
     useProvidersStore.getState().providers.fireworks.models.includes(model)
diff --git a/apps/sim/lib/api/contracts/byok-keys.ts b/apps/sim/lib/api/contracts/byok-keys.ts
index 7a761c44bd3..d52838eb427 100644
--- a/apps/sim/lib/api/contracts/byok-keys.ts
+++ b/apps/sim/lib/api/contracts/byok-keys.ts
@@ -18,6 +18,8 @@ export const byokProviderIdSchema = z.enum([
   'parallel_ai',
   'brandfetch',
   'cohere',
+  'hunter',
+  'peopledatalabs',
 ])
 
 export const byokKeySchema = z.object({
diff --git a/apps/sim/lib/api/contracts/providers.ts b/apps/sim/lib/api/contracts/providers.ts
index c53d3fedf21..776b1d94c42 100644
--- a/apps/sim/lib/api/contracts/providers.ts
+++ b/apps/sim/lib/api/contracts/providers.ts
@@ -207,6 +207,15 @@ export const getOpenRouterProviderModelsContract = defineRouteContract({
   },
 })
 
+export const getLitellmProviderModelsContract = defineRouteContract({
+  method: 'GET',
+  path: '/api/providers/litellm/models',
+  response: {
+    mode: 'json',
+    schema: providerModelsResponseSchema,
+  },
+})
+
 export const getFireworksProviderModelsContract = defineRouteContract({
   method: 'GET',
   path: '/api/providers/fireworks/models',
diff --git a/apps/sim/lib/api/contracts/workflows.test.ts b/apps/sim/lib/api/contracts/workflows.test.ts
new file mode 100644
index 00000000000..d70ec31fd5d
--- /dev/null
+++ b/apps/sim/lib/api/contracts/workflows.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest'
+import { executeWorkflowBodySchema } from '@/lib/api/contracts/workflows'
+
+describe('workflow contracts', () => {
+  it('normalizes null React Flow edge handles in execution overrides', () => {
+    const parsed = executeWorkflowBodySchema.parse({
+      workflowStateOverride: {
+        blocks: {
+          source: {
+            id: 'source',
+            type: 'start_trigger',
+            name: 'Start',
+            position: { x: 0, y: 0 },
+            subBlocks: {},
+            outputs: {},
+            enabled: true,
+          },
+          target: {
+            id: 'target',
+            type: 'function',
+            name: 'Function',
+            position: { x: 100, y: 0 },
+            subBlocks: {},
+            outputs: {},
+            enabled: true,
+          },
+        },
+        edges: [
+          {
+            id: 'edge-1',
+            source: 'source',
+            target: 'target',
+            sourceHandle: null,
+            targetHandle: null,
+            type: 'workflowEdge',
+          },
+        ],
+        loops: {},
+        parallels: {},
+      },
+    })
+
+    expect(parsed.workflowStateOverride?.edges[0].sourceHandle).toBeUndefined()
+    expect(parsed.workflowStateOverride?.edges[0].targetHandle).toBeUndefined()
+  })
+})
diff --git a/apps/sim/lib/api/contracts/workflows.ts b/apps/sim/lib/api/contracts/workflows.ts
index f623bcdaf55..0d99ea83ad2 100644
--- a/apps/sim/lib/api/contracts/workflows.ts
+++ b/apps/sim/lib/api/contracts/workflows.ts
@@ -40,6 +40,10 @@ const workflowSubBlockStateSchema = z.object({
 })
 
 const workflowBlockOutputSchema = z.unknown()
+const workflowEdgeHandleSchema = z
+  .string()
+  .nullish()
+  .transform((value) => value ?? undefined)
 
 const workflowBlockStateSchema = z.object({
   id: z.string(),
@@ -61,8 +65,8 @@ const workflowEdgeSchema = z.object({
   id: z.string(),
   source: z.string(),
   target: z.string(),
-  sourceHandle: z.string().optional(),
-  targetHandle: z.string().optional(),
+  sourceHandle: workflowEdgeHandleSchema,
+  targetHandle: workflowEdgeHandleSchema,
   type: z.string().optional(),
   animated: z.boolean().optional(),
   style: z.record(z.string(), z.unknown()).optional(),
diff --git a/apps/sim/lib/copilot/chat/post.ts b/apps/sim/lib/copilot/chat/post.ts
index a7ba4573879..f13f4a85046 100644
--- a/apps/sim/lib/copilot/chat/post.ts
+++ b/apps/sim/lib/copilot/chat/post.ts
@@ -44,7 +44,10 @@ import { taskPubSub } from '@/lib/copilot/tasks'
 import { prepareExecutionContext } from '@/lib/copilot/tools/handlers/context'
 import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
 import { getWorkflowById, resolveWorkflowIdForUser } from '@/lib/workflows/utils'
-import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
+import {
+  getUserEntityPermissions,
+  isWorkspaceAccessDeniedError,
+} from '@/lib/workspaces/permissions/utils'
 import type { ChatContext } from '@/stores/panel'
 
 export const maxDuration = 3600
@@ -1039,6 +1042,10 @@ export async function handleUnifiedChatPost(req: NextRequest) {
       return validationErrorResponse(error, 'Invalid request data')
     }
 
+    if (isWorkspaceAccessDeniedError(error)) {
+      return NextResponse.json({ error: 'Workspace access denied' }, { status: 403 })
+    }
+
     logger.error(`[${requestId}] Error handling unified chat request`, {
       error: getErrorMessage(error, 'Unknown error'),
       stack: error instanceof Error ? error.stack : undefined,
diff --git a/apps/sim/lib/copilot/request/http.ts b/apps/sim/lib/copilot/request/http.ts
index 19c33fc7545..56614265ff7 100644
--- a/apps/sim/lib/copilot/request/http.ts
+++ b/apps/sim/lib/copilot/request/http.ts
@@ -35,6 +35,10 @@ export function createBadRequestResponse(message: string): NextResponse {
   return NextResponse.json({ error: message }, { status: 400 })
 }
 
+export function createForbiddenResponse(message: string): NextResponse {
+  return NextResponse.json({ error: message }, { status: 403 })
+}
+
 export function createNotFoundResponse(message: string): NextResponse {
   return NextResponse.json({ error: message }, { status: 404 })
 }
diff --git a/apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts b/apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts
index 2e4d2a3aee7..0c2d11d0827 100644
--- a/apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts
+++ b/apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts
@@ -768,6 +768,7 @@ function callOptionsWithFallback(
       base: { models: staticModels.map((m) => m.id) },
       ollama: { models: [] },
       vllm: { models: [] },
+      litellm: { models: [] },
       openrouter: { models: [] },
       fireworks: { models: [] },
     },
diff --git a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts
index 2c182cc839c..e98e39a3967 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts
@@ -369,7 +369,7 @@ export function validateValueForSubBlockType(
               blockType,
               field: fieldName,
               value,
-              error: `Unknown model id "${trimmed}" for block "${blockType}". Read components/blocks/${blockType}.json (the model.options array) for valid ids; prefer entries with recommended: true and avoid deprecated: true. For user-configured models (Ollama, vLLM, OpenRouter, Fireworks), prefix the id with the provider slash, e.g. "ollama/llama3.1:8b".${suggestionText}`,
+              error: `Unknown model id "${trimmed}" for block "${blockType}". Read components/blocks/${blockType}.json (the model.options array) for valid ids; prefer entries with recommended: true and avoid deprecated: true. For user-configured models (Ollama, vLLM, LiteLLM, OpenRouter, Fireworks), prefix the id with the provider slash, e.g. "ollama/llama3.1:8b".${suggestionText}`,
             },
           }
         }
diff --git a/apps/sim/lib/core/config/env.ts b/apps/sim/lib/core/config/env.ts
index 41dc464ff7c..ecad5d3bb02 100644
--- a/apps/sim/lib/core/config/env.ts
+++ b/apps/sim/lib/core/config/env.ts
@@ -127,6 +127,8 @@ export const env = createEnv({
     OLLAMA_URL:                            z.string().url().optional(),            // Ollama local LLM server URL
     VLLM_BASE_URL:                         z.string().url().optional(),            // vLLM self-hosted base URL (OpenAI-compatible)
     VLLM_API_KEY:                          z.string().optional(),                  // Optional bearer token for vLLM
+    LITELLM_BASE_URL:                      z.string().url().optional(),            // LiteLLM proxy base URL (OpenAI-compatible)
+    LITELLM_API_KEY:                       z.string().optional(),                  // Optional bearer token for LiteLLM
     FIREWORKS_API_KEY:                     z.string().optional(),                  // Optional Fireworks AI API key for model listing
     COHERE_API_KEY:                        z.string().min(1).optional(),           // Cohere API key for reranker (rerank-v4.0-pro, rerank-v4.0-fast, rerank-v3.5)
     COHERE_API_KEY_1:                      z.string().min(1).optional(),           // Primary Cohere API key for rotation
diff --git a/apps/sim/lib/core/utils/http-error.ts b/apps/sim/lib/core/utils/http-error.ts
new file mode 100644
index 00000000000..5c77ebe54ba
--- /dev/null
+++ b/apps/sim/lib/core/utils/http-error.ts
@@ -0,0 +1,19 @@
+/**
+ * Base class for domain errors that map to a specific HTTP status when they
+ * bubble up unhandled through `withRouteHandler`. Modeled after NestJS
+ * `HttpException` / Spring `ResponseStatusException`: subclasses declare a
+ * concrete `statusCode`, and the centralized route wrapper uses an
+ * `instanceof HttpError` check (not duck-typing on a `statusCode` property)
+ * to decide whether to forward the error's `message` to the client.
+ *
+ * Using a class check prevents third-party errors that happen to carry a
+ * `statusCode`-shaped field from being treated as typed HTTP errors and
+ * leaking internal details.
+ *
+ * Subclasses MUST ensure that `message` is safe to expose to clients — no
+ * stack traces, secrets, file paths, ORM internals, or upstream provider
+ * details.
+ */
+export abstract class HttpError extends Error {
+  abstract readonly statusCode: number
+}
diff --git a/apps/sim/lib/core/utils/with-route-handler.ts b/apps/sim/lib/core/utils/with-route-handler.ts
index 5b3212f23e5..b61cd0d3b30 100644
--- a/apps/sim/lib/core/utils/with-route-handler.ts
+++ b/apps/sim/lib/core/utils/with-route-handler.ts
@@ -2,6 +2,7 @@ import { createLogger, runWithRequestContext } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import type { NextRequest } from 'next/server'
 import { NextResponse } from 'next/server'
+import { HttpError } from '@/lib/core/utils/http-error'
 import { generateRequestId } from '@/lib/core/utils/request'
 
 const logger = createLogger('RouteHandler')
@@ -11,6 +12,29 @@ type RouteHandler<T = unknown> = (
   context: T
 ) => Promise<NextResponse | Response> | NextResponse | Response
 
+/**
+ * Reads a numeric `statusCode` (4xx or 5xx) off an `HttpError` so typed domain
+ * errors (e.g. `WorkspaceAccessDeniedError`, `InvalidFieldError`) map to the
+ * correct HTTP status when they bubble up unhandled instead of defaulting to
+ * 500.
+ *
+ * Uses an `instanceof HttpError` check (not duck-typing on `statusCode`) so
+ * third-party errors that happen to carry a `statusCode`-shaped field cannot
+ * trigger this path and leak their internal `message` to the client.
+ *
+ * When a typed status is returned, the error's `message` is sent to the client
+ * verbatim — matching the NestJS `HttpException` / Spring `ResponseStatusException`
+ * convention. Subclasses of `HttpError` are responsible for keeping `message`
+ * safe to expose to clients (no stack traces, secrets, file paths, ORM
+ * internals).
+ */
+function readTypedErrorStatus(error: unknown): number | undefined {
+  if (!(error instanceof HttpError)) return undefined
+  const status = error.statusCode
+  if (status < 400 || status >= 600) return undefined
+  return status
+}
+
 /**
  * Wraps a Next.js API route handler with centralized error reporting.
  *
@@ -35,8 +59,21 @@ export function withRouteHandler<T>(handler: RouteHandler<T>): RouteHandler<T> {
       } catch (error) {
         const duration = Date.now() - startTime
         const message = getErrorMessage(error, 'Unknown error')
-        logger.error('Unhandled route error', { duration, error: message })
-        response = NextResponse.json({ error: 'Internal server error', requestId }, { status: 500 })
+        const typedStatus = readTypedErrorStatus(error)
+        if (typedStatus !== undefined) {
+          if (typedStatus >= 500) {
+            logger.error('Unhandled route error', { duration, status: typedStatus, error: message })
+          } else {
+            logger.warn('Typed route error', { duration, status: typedStatus, error: message })
+          }
+          response = NextResponse.json({ error: message, requestId }, { status: typedStatus })
+        } else {
+          logger.error('Unhandled route error', { duration, error: message })
+          response = NextResponse.json(
+            { error: 'Internal server error', requestId },
+            { status: 500 }
+          )
+        }
         response?.headers?.set('x-request-id', requestId)
         return response
       }
diff --git a/apps/sim/lib/logs/execution/logging-session.test.ts b/apps/sim/lib/logs/execution/logging-session.test.ts
index 95805c74eac..bdd338e1ff5 100644
--- a/apps/sim/lib/logs/execution/logging-session.test.ts
+++ b/apps/sim/lib/logs/execution/logging-session.test.ts
@@ -35,8 +35,14 @@ const dbMocks = vi.hoisted(() => {
   }
 })
 
-const { completeWorkflowExecutionMock } = vi.hoisted(() => ({
+const {
+  completeWorkflowExecutionMock,
+  startWorkflowExecutionMock,
+  loadWorkflowStateForExecutionMock,
+} = vi.hoisted(() => ({
   completeWorkflowExecutionMock: vi.fn(),
+  startWorkflowExecutionMock: vi.fn(),
+  loadWorkflowStateForExecutionMock: vi.fn(),
 }))
 
 vi.mock('@sim/db', () => ({
@@ -55,7 +61,7 @@ vi.mock('drizzle-orm', () => ({
 
 vi.mock('@/lib/logs/execution/logger', () => ({
   executionLogger: {
-    startWorkflowExecution: vi.fn(),
+    startWorkflowExecution: startWorkflowExecutionMock,
     completeWorkflowExecution: completeWorkflowExecutionMock,
   },
 }))
@@ -75,11 +81,76 @@ vi.mock('@/lib/logs/execution/logging-factory', () => ({
   createEnvironmentObject: vi.fn(),
   createTriggerObject: vi.fn(),
   loadDeployedWorkflowStateForLogging: vi.fn(),
-  loadWorkflowStateForExecution: vi.fn(),
+  loadWorkflowStateForExecution: loadWorkflowStateForExecutionMock,
 }))
 
 import { LoggingSession } from './logging-session'
 
+describe('LoggingSession start snapshots', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    startWorkflowExecutionMock.mockResolvedValue({})
+    loadWorkflowStateForExecutionMock.mockResolvedValue({
+      blocks: {
+        stale: {
+          id: 'stale',
+          type: 'function',
+          name: 'Stale',
+          position: { x: 0, y: 0 },
+          subBlocks: {},
+          outputs: {},
+          enabled: true,
+        },
+      },
+      edges: [],
+      loops: {},
+      parallels: {},
+    })
+  })
+
+  it('uses the executed workflow state override for execution snapshots', async () => {
+    const session = new LoggingSession('workflow-1', 'execution-1', 'manual', 'req-1')
+    const executedWorkflowState = {
+      blocks: {
+        loop: {
+          id: 'loop',
+          type: 'loop',
+          name: 'Loop',
+          position: { x: 0, y: 0 },
+          subBlocks: {},
+          outputs: {},
+          enabled: true,
+        },
+        parallel: {
+          id: 'parallel',
+          type: 'parallel',
+          name: 'Parallel',
+          position: { x: 100, y: 80 },
+          subBlocks: {},
+          outputs: {},
+          enabled: true,
+          data: { parentId: 'loop', extent: 'parent' as const },
+        },
+      },
+      edges: [],
+      loops: { loop: { id: 'loop', nodes: ['parallel'], iterations: 1, loopType: 'for' as const } },
+      parallels: { parallel: { id: 'parallel', nodes: [], count: 1 } },
+    }
+
+    await session.start({
+      workspaceId: 'workspace-1',
+      workflowState: executedWorkflowState,
+    })
+
+    expect(loadWorkflowStateForExecutionMock).not.toHaveBeenCalled()
+    expect(startWorkflowExecutionMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workflowState: executedWorkflowState,
+      })
+    )
+  })
+})
+
 describe('LoggingSession completion retries', () => {
   beforeEach(() => {
     vi.clearAllMocks()
diff --git a/apps/sim/lib/logs/execution/logging-session.ts b/apps/sim/lib/logs/execution/logging-session.ts
index 573d6f26f6d..56eb463e201 100644
--- a/apps/sim/lib/logs/execution/logging-session.ts
+++ b/apps/sim/lib/logs/execution/logging-session.ts
@@ -82,6 +82,7 @@ export interface SessionStartParams {
   triggerData?: TriggerData
   skipLogCreation?: boolean // For resume executions - reuse existing log entry
   deploymentVersionId?: string // ID of the deployment version used (null for manual/editor executions)
+  workflowState?: WorkflowState
 }
 
 export interface SessionCompleteParams {
@@ -413,8 +414,15 @@ export class LoggingSession {
   }
 
   async start(params: SessionStartParams): Promise<void> {
-    const { userId, workspaceId, variables, triggerData, skipLogCreation, deploymentVersionId } =
-      params
+    const {
+      userId,
+      workspaceId,
+      variables,
+      triggerData,
+      skipLogCreation,
+      deploymentVersionId,
+      workflowState,
+    } = params
 
     try {
       this.trigger = createTriggerObject(this.triggerType, triggerData)
@@ -426,11 +434,11 @@ export class LoggingSession {
         workspaceId,
         variables
       )
-      // Use deployed state if deploymentVersionId is provided (non-manual execution)
-      // Otherwise fall back to loading from normalized tables (manual/draft execution)
-      this.workflowState = deploymentVersionId
-        ? await loadDeployedWorkflowStateForLogging(this.workflowId)
-        : await loadWorkflowStateForExecution(this.workflowId)
+      this.workflowState =
+        workflowState ??
+        (deploymentVersionId
+          ? await loadDeployedWorkflowStateForLogging(this.workflowId)
+          : await loadWorkflowStateForExecution(this.workflowId))
 
       if (!skipLogCreation) {
         await executionLogger.startWorkflowExecution({
@@ -895,7 +903,8 @@ export class LoggingSession {
 
       // Fallback: create a minimal logging session without full workflow state
       try {
-        const { userId, workspaceId, variables, triggerData, deploymentVersionId } = params
+        const { userId, workspaceId, variables, triggerData, deploymentVersionId, workflowState } =
+          params
         this.trigger = createTriggerObject(this.triggerType, triggerData)
         this.correlation = triggerData?.correlation
         this.environment = createEnvironmentObject(
@@ -905,14 +914,13 @@ export class LoggingSession {
           workspaceId,
           variables
         )
-        // Minimal workflow state when normalized/deployed data is unavailable
-        const minimalWorkflowState: WorkflowState = {
+        const fallbackWorkflowState: WorkflowState = workflowState ?? {
           blocks: {},
           edges: [],
           loops: {},
           parallels: {},
         }
-        this.workflowState = minimalWorkflowState
+        this.workflowState = fallbackWorkflowState
 
         await executionLogger.startWorkflowExecution({
           workflowId: this.workflowId,
diff --git a/apps/sim/lib/oauth/oauth.ts b/apps/sim/lib/oauth/oauth.ts
index 82c3ee7bb1e..21d12053ebd 100644
--- a/apps/sim/lib/oauth/oauth.ts
+++ b/apps/sim/lib/oauth/oauth.ts
@@ -1367,7 +1367,7 @@ function getProviderAuthConfig(provider: string): ProviderAuthConfig {
         clientId,
         clientSecret,
         useBasicAuth: true,
-        supportsRefreshTokenRotation: false,
+        supportsRefreshTokenRotation: true,
       }
     }
     case 'wordpress': {
diff --git a/apps/sim/lib/workflows/executor/execution-core.test.ts b/apps/sim/lib/workflows/executor/execution-core.test.ts
index 4f958a6527c..08be63da3fd 100644
--- a/apps/sim/lib/workflows/executor/execution-core.test.ts
+++ b/apps/sim/lib/workflows/executor/execution-core.test.ts
@@ -215,6 +215,49 @@ describe('executeWorkflowCore terminal finalization sequencing', () => {
     )
   })
 
+  it('starts logging with the workflow state that will be executed', async () => {
+    const executedWorkflowState = {
+      blocks: {
+        loop: { id: 'loop', type: 'loop', name: 'Loop', subBlocks: {} },
+        parallel: {
+          id: 'parallel',
+          type: 'parallel',
+          name: 'Parallel',
+          subBlocks: {},
+          data: { parentId: 'loop', extent: 'parent' },
+        },
+      },
+      edges: [],
+      loops: { loop: { id: 'loop', nodes: ['parallel'], iterations: 1, loopType: 'for' } },
+      parallels: { parallel: { id: 'parallel', nodes: [], count: 1 } },
+    }
+    executorExecuteMock.mockResolvedValue({
+      success: true,
+      status: 'completed',
+      output: { done: true },
+      logs: [],
+      metadata: { duration: 123, startTime: 'start', endTime: 'end' },
+    })
+
+    await executeWorkflowCore({
+      snapshot: {
+        ...createSnapshot(),
+        metadata: {
+          ...createSnapshot().metadata,
+          workflowStateOverride: executedWorkflowState,
+        },
+      } as any,
+      callbacks: {},
+      loggingSession: loggingSession as any,
+    })
+
+    expect(safeStartMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workflowState: executedWorkflowState,
+      })
+    )
+  })
+
   it('uses external trigger selection for webhook executions without an explicit triggerBlockId', async () => {
     executorExecuteMock.mockResolvedValue({
       success: true,
diff --git a/apps/sim/lib/workflows/executor/execution-core.ts b/apps/sim/lib/workflows/executor/execution-core.ts
index fe7b40b32fc..bffc4d4c868 100644
--- a/apps/sim/lib/workflows/executor/execution-core.ts
+++ b/apps/sim/lib/workflows/executor/execution-core.ts
@@ -376,6 +376,7 @@ export async function executeWorkflowCore(
       triggerData: metadata.correlation ? { correlation: metadata.correlation } : undefined,
       skipLogCreation,
       deploymentVersionId,
+      workflowState: { blocks, edges, loops, parallels },
     })
 
     // Use edges directly - trigger-to-trigger edges are prevented at creation time
diff --git a/apps/sim/lib/workflows/executor/human-in-the-loop-manager.test.ts b/apps/sim/lib/workflows/executor/human-in-the-loop-manager.test.ts
new file mode 100644
index 00000000000..178eefbe746
--- /dev/null
+++ b/apps/sim/lib/workflows/executor/human-in-the-loop-manager.test.ts
@@ -0,0 +1,145 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { updateResumeOutputInAggregationBuffers } from '@/lib/workflows/executor/human-in-the-loop-manager'
+import type { SerializableExecutionState } from '@/executor/execution/types'
+
+function createExecutionState(): SerializableExecutionState {
+  return {
+    blockStates: {},
+    executedBlocks: [],
+    blockLogs: [],
+    decisions: { router: {}, condition: {} },
+    completedLoops: [],
+    activeExecutionPath: [],
+  }
+}
+
+describe('updateResumeOutputInAggregationBuffers', () => {
+  it('replaces a paused parallel branch placeholder with the resumed HITL output', () => {
+    const pausedOutput = {
+      response: { status: 'paused' },
+      _pauseMetadata: {
+        contextId: 'pause-context-1',
+        blockId: 'hitl₍1₎',
+      },
+    }
+    const siblingOutput = { value: 'already-complete' }
+    const mergedOutput = {
+      response: { data: { submission: { approved: true } } },
+      submission: { approved: true },
+      _resumed: true,
+    }
+    const state = createExecutionState()
+    state.parallelExecutions = {
+      'parallel-1': {
+        branchOutputs: {
+          0: [siblingOutput],
+          1: [pausedOutput],
+        },
+      },
+    }
+
+    updateResumeOutputInAggregationBuffers(
+      state,
+      'hitl₍1₎',
+      'hitl',
+      'pause-context-1',
+      mergedOutput
+    )
+
+    expect(state.parallelExecutions['parallel-1'].branchOutputs).toEqual({
+      0: [siblingOutput],
+      1: [mergedOutput],
+    })
+  })
+
+  it('does not replace unrelated paused parallel branch outputs', () => {
+    const unrelatedPausedOutput = {
+      response: { status: 'paused' },
+      _pauseMetadata: {
+        contextId: 'different-context',
+        blockId: 'hitl₍1₎',
+      },
+    }
+    const mergedOutput = {
+      response: { data: { submission: { approved: true } } },
+      submission: { approved: true },
+      _resumed: true,
+    }
+    const state = createExecutionState()
+    state.parallelExecutions = {
+      'parallel-1': {
+        branchOutputs: {
+          1: [unrelatedPausedOutput],
+        },
+      },
+    }
+
+    updateResumeOutputInAggregationBuffers(
+      state,
+      'hitl₍1₎',
+      'hitl',
+      'pause-context-1',
+      mergedOutput
+    )
+
+    expect(state.parallelExecutions['parallel-1'].branchOutputs).toEqual({
+      1: [unrelatedPausedOutput],
+    })
+  })
+
+  it('replaces paused loop iteration outputs using the resumed state block key', () => {
+    const pausedOutput = {
+      response: { status: 'paused' },
+      _pauseMetadata: {
+        contextId: 'pause-context-1',
+        blockId: 'hitl',
+      },
+    }
+    const unrelatedPausedOutput = {
+      response: { status: 'paused' },
+      _pauseMetadata: {
+        contextId: 'different-context',
+        blockId: 'hitl',
+      },
+    }
+    const siblingOutput = { value: 'already-complete' }
+    const mergedOutput = {
+      response: { data: { submission: { approved: true } } },
+      submission: { approved: true },
+      _resumed: true,
+    }
+    const state = createExecutionState()
+    state.loopExecutions = {
+      'loop-1': {
+        currentIterationOutputs: {
+          hitl: pausedOutput,
+          sibling: siblingOutput,
+        },
+      },
+      'loop-2': {
+        currentIterationOutputs: {
+          hitl: unrelatedPausedOutput,
+        },
+      },
+    }
+
+    updateResumeOutputInAggregationBuffers(
+      state,
+      'hitl₍1₎',
+      'hitl',
+      'pause-context-1',
+      mergedOutput
+    )
+
+    expect(state.loopExecutions['loop-1'].currentIterationOutputs).toEqual({
+      'hitl₍1₎': mergedOutput,
+      sibling: siblingOutput,
+    })
+    expect(state.loopExecutions['loop-2'].currentIterationOutputs).toEqual({
+      hitl: unrelatedPausedOutput,
+    })
+  })
+})
diff --git a/apps/sim/lib/workflows/executor/human-in-the-loop-manager.ts b/apps/sim/lib/workflows/executor/human-in-the-loop-manager.ts
index d5ab6bb5807..f1765b52389 100644
--- a/apps/sim/lib/workflows/executor/human-in-the-loop-manager.ts
+++ b/apps/sim/lib/workflows/executor/human-in-the-loop-manager.ts
@@ -52,6 +52,58 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === 'object' && !Array.isArray(value)
 }
 
+function isPausedOutputForContext(output: unknown, contextId: string): boolean {
+  if (!isRecord(output)) return false
+  const metadata = output._pauseMetadata
+  return isRecord(metadata) && metadata.contextId === contextId
+}
+
+export function updateResumeOutputInAggregationBuffers(
+  state: SerializableExecutionState,
+  stateBlockKey: string,
+  pauseBlockId: string,
+  contextId: string,
+  mergedOutput: Record<string, unknown>
+): void {
+  for (const scope of Object.values(state.loopExecutions ?? {})) {
+    if (!isRecord(scope) || !isRecord(scope.currentIterationOutputs)) continue
+
+    const outputs = scope.currentIterationOutputs
+    const pausedEntry =
+      outputs[stateBlockKey] !== undefined
+        ? stateBlockKey
+        : outputs[pauseBlockId] !== undefined
+          ? pauseBlockId
+          : undefined
+
+    if (pausedEntry !== undefined && isPausedOutputForContext(outputs[pausedEntry], contextId)) {
+      if (pausedEntry !== stateBlockKey) {
+        delete outputs[pausedEntry]
+      }
+      outputs[stateBlockKey] = mergedOutput
+    }
+  }
+
+  for (const scope of Object.values(state.parallelExecutions ?? {})) {
+    if (!isRecord(scope) || !isRecord(scope.branchOutputs)) continue
+
+    for (const [branchIndex, branchOutputs] of Object.entries(scope.branchOutputs)) {
+      if (!Array.isArray(branchOutputs)) continue
+
+      const outputIndex = branchOutputs.findIndex((output) =>
+        isPausedOutputForContext(output, contextId)
+      )
+      if (outputIndex !== -1) {
+        scope.branchOutputs[branchIndex] = [
+          ...branchOutputs.slice(0, outputIndex),
+          mergedOutput,
+          ...branchOutputs.slice(outputIndex + 1),
+        ]
+      }
+    }
+  }
+}
+
 function parseSnapshotForReferenceTracking(snapshotSeed: SerializedSnapshot): unknown {
   try {
     return { ...snapshotSeed, snapshot: JSON.parse(snapshotSeed.snapshot) }
@@ -782,7 +834,7 @@ export class PauseResumeManager {
         resume: existingResponse.resume ?? existingOutput.resume,
       }
 
-      const mergedOutput: Record<string, any> = {
+      const mergedOutput: Record<string, unknown> = {
         ...existingOutput,
         response: mergedResponse,
         submission: submissionPayload,
@@ -827,6 +879,13 @@ export class PauseResumeManager {
       }
 
       stateCopy.blockStates[stateBlockKey] = pauseBlockState
+      updateResumeOutputInAggregationBuffers(
+        stateCopy,
+        stateBlockKey,
+        pauseBlockId,
+        contextId,
+        mergedOutput
+      )
 
       // Update the block log entry with the merged output so logs show the submission data
       if (Array.isArray(stateCopy.blockLogs)) {
diff --git a/apps/sim/lib/workspaces/permissions/utils.ts b/apps/sim/lib/workspaces/permissions/utils.ts
index bef0da42e42..dad8ef20d20 100644
--- a/apps/sim/lib/workspaces/permissions/utils.ts
+++ b/apps/sim/lib/workspaces/permissions/utils.ts
@@ -8,6 +8,7 @@ import {
   workspace,
 } from '@sim/db/schema'
 import { and, eq, isNull } from 'drizzle-orm'
+import { HttpError } from '@/lib/core/utils/http-error'
 
 export type PermissionType = (typeof permissionTypeEnum.enumValues)[number]
 export interface WorkspaceBasic {
@@ -147,13 +148,34 @@ export async function checkWorkspaceAccess(
   return { exists: true, hasAccess: true, canWrite, workspace: ws }
 }
 
+/**
+ * Thrown when a user attempts to access a workspace they don't have access to,
+ * or that doesn't exist / has been archived. Carries `statusCode = 403` so the
+ * centralized route wrapper maps it to HTTP 403 instead of defaulting to 500.
+ * The `message` is intentionally client-safe and is exposed to API responses.
+ */
+export class WorkspaceAccessDeniedError extends HttpError {
+  readonly statusCode = 403
+  readonly workspaceId: string
+
+  constructor(workspaceId: string) {
+    super(`Workspace access denied: ${workspaceId}`)
+    this.name = 'WorkspaceAccessDeniedError'
+    this.workspaceId = workspaceId
+  }
+}
+
+export function isWorkspaceAccessDeniedError(error: unknown): error is WorkspaceAccessDeniedError {
+  return error instanceof WorkspaceAccessDeniedError
+}
+
 export async function assertActiveWorkspaceAccess(
   workspaceId: string,
   userId: string
 ): Promise<WorkspaceAccess> {
   const access = await checkWorkspaceAccess(workspaceId, userId)
   if (!access.exists || !access.hasAccess) {
-    throw new Error(`Active workspace access denied: ${workspaceId}`)
+    throw new WorkspaceAccessDeniedError(workspaceId)
   }
   return access
 }
diff --git a/apps/sim/providers/attachments.ts b/apps/sim/providers/attachments.ts
index 380b4d8c890..d1b5d48c828 100644
--- a/apps/sim/providers/attachments.ts
+++ b/apps/sim/providers/attachments.ts
@@ -24,6 +24,7 @@ export type AttachmentProvider =
   | 'fireworks'
   | 'ollama'
   | 'vllm'
+  | 'litellm'
   | 'xai'
   | 'deepseek'
   | 'cerebras'
@@ -93,6 +94,7 @@ const PROVIDER_SUPPORTED_LABELS: Record<AttachmentProvider, string> = {
   fireworks: 'images through image_url message parts on vision models',
   ollama: 'images through image_url message parts on vision models',
   vllm: 'images through image_url message parts on multimodal models',
+  litellm: 'images through image_url message parts on multimodal models',
   xai: 'images through image_url message parts on Grok vision models',
   deepseek: 'no file attachments in the current API adapter',
   cerebras: 'no file attachments in the current API adapter',
@@ -109,6 +111,7 @@ export function getAttachmentProvider(providerId: ProviderId | string): Attachme
   if (providerId === 'fireworks') return 'fireworks'
   if (providerId === 'ollama') return 'ollama'
   if (providerId === 'vllm') return 'vllm'
+  if (providerId === 'litellm') return 'litellm'
   if (providerId === 'xai') return 'xai'
   if (providerId === 'deepseek') return 'deepseek'
   if (providerId === 'cerebras') return 'cerebras'
@@ -247,6 +250,7 @@ function isMimeTypeSupportedByProvider(
     case 'fireworks':
     case 'ollama':
     case 'vllm':
+    case 'litellm':
     case 'xai':
       return isImageMimeType(mimeType)
     case 'deepseek':
diff --git a/apps/sim/providers/litellm/index.ts b/apps/sim/providers/litellm/index.ts
new file mode 100644
index 00000000000..33e363f0509
--- /dev/null
+++ b/apps/sim/providers/litellm/index.ts
@@ -0,0 +1,688 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage, toError } from '@sim/utils/errors'
+import OpenAI from 'openai'
+import type { ChatCompletionCreateParamsStreaming } from 'openai/resources/chat/completions'
+import { env } from '@/lib/core/config/env'
+import type { StreamingExecution } from '@/executor/types'
+import { MAX_TOOL_ITERATIONS } from '@/providers'
+import { formatMessagesForProvider } from '@/providers/attachments'
+import { createReadableStreamFromLiteLLMStream } from '@/providers/litellm/utils'
+import { getProviderDefaultModel, getProviderModels } from '@/providers/models'
+import { enrichLastModelSegmentFromChatCompletions } from '@/providers/trace-enrichment'
+import type {
+  Message,
+  ProviderConfig,
+  ProviderRequest,
+  ProviderResponse,
+  TimeSegment,
+} from '@/providers/types'
+import { ProviderError } from '@/providers/types'
+import {
+  calculateCost,
+  prepareToolExecution,
+  prepareToolsWithUsageControl,
+  sumToolCosts,
+  trackForcedToolUsage,
+} from '@/providers/utils'
+import { useProvidersStore } from '@/stores/providers'
+import { executeTool } from '@/tools'
+
+const logger = createLogger('LiteLLMProvider')
+const LITELLM_VERSION = '1.0.0'
+
+export const litellmProvider: ProviderConfig = {
+  id: 'litellm',
+  name: 'LiteLLM',
+  description: 'LiteLLM proxy with OpenAI-compatible API',
+  version: LITELLM_VERSION,
+  models: getProviderModels('litellm'),
+  defaultModel: getProviderDefaultModel('litellm'),
+
+  async initialize() {
+    if (typeof window !== 'undefined') {
+      logger.info('Skipping LiteLLM initialization on client side to avoid CORS issues')
+      return
+    }
+
+    const baseUrl = (env.LITELLM_BASE_URL || '').replace(/\/$/, '')
+    if (!baseUrl) {
+      logger.info('LITELLM_BASE_URL not configured, skipping initialization')
+      return
+    }
+
+    try {
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+      }
+
+      if (env.LITELLM_API_KEY) {
+        headers.Authorization = `Bearer ${env.LITELLM_API_KEY}`
+      }
+
+      const response = await fetch(`${baseUrl}/v1/models`, { headers })
+      if (!response.ok) {
+        await response.text().catch(() => {})
+        useProvidersStore.getState().setProviderModels('litellm', [])
+        logger.warn('LiteLLM service is not available. The provider will be disabled.')
+        return
+      }
+
+      const { vllmUpstreamResponseSchema } = await import('@/lib/api/contracts/providers')
+      const data = vllmUpstreamResponseSchema.parse(await response.json())
+      const models = data.data.map((model) => `litellm/${model.id}`)
+
+      this.models = models
+      useProvidersStore.getState().setProviderModels('litellm', models)
+
+      logger.info(`Discovered ${models.length} LiteLLM model(s):`, { models })
+    } catch (error) {
+      logger.warn('LiteLLM model instantiation failed. The provider will be disabled.', {
+        error: getErrorMessage(error, 'Unknown error'),
+      })
+    }
+  },
+
+  executeRequest: async (
+    request: ProviderRequest
+  ): Promise<ProviderResponse | StreamingExecution> => {
+    logger.info('Preparing LiteLLM request', {
+      model: request.model,
+      hasSystemPrompt: !!request.systemPrompt,
+      hasMessages: !!request.messages?.length,
+      hasTools: !!request.tools?.length,
+      toolCount: request.tools?.length || 0,
+      hasResponseFormat: !!request.responseFormat,
+      stream: !!request.stream,
+    })
+
+    const baseUrl = (env.LITELLM_BASE_URL || '').replace(/\/$/, '')
+    if (!baseUrl) {
+      throw new Error('LITELLM_BASE_URL is required for LiteLLM provider')
+    }
+
+    const apiKey = request.apiKey || env.LITELLM_API_KEY || 'empty'
+    const litellm = new OpenAI({
+      apiKey,
+      baseURL: `${baseUrl}/v1`,
+    })
+
+    const allMessages: Message[] = []
+
+    if (request.systemPrompt) {
+      allMessages.push({
+        role: 'system',
+        content: request.systemPrompt,
+      })
+    }
+
+    if (request.context) {
+      allMessages.push({
+        role: 'user',
+        content: request.context,
+      })
+    }
+
+    if (request.messages) {
+      allMessages.push(...request.messages)
+    }
+    const formattedMessages = formatMessagesForProvider(allMessages, 'litellm') as Message[]
+
+    const tools = request.tools?.length
+      ? request.tools.map((tool) => ({
+          type: 'function',
+          function: {
+            name: tool.id,
+            description: tool.description,
+            parameters: tool.parameters,
+          },
+        }))
+      : undefined
+
+    const payload: any = {
+      model: request.model.replace(/^litellm\//, ''),
+      messages: formattedMessages,
+    }
+
+    if (request.temperature !== undefined) payload.temperature = request.temperature
+    if (request.maxTokens != null) payload.max_completion_tokens = request.maxTokens
+
+    if (request.responseFormat) {
+      payload.response_format = {
+        type: 'json_schema',
+        json_schema: {
+          name: request.responseFormat.name || 'response_schema',
+          schema: request.responseFormat.schema || request.responseFormat,
+          strict: request.responseFormat.strict !== false,
+        },
+      }
+
+      logger.info('Added JSON schema response format to LiteLLM request')
+    }
+
+    let preparedTools: ReturnType<typeof prepareToolsWithUsageControl> | null = null
+    let hasActiveTools = false
+
+    if (tools?.length) {
+      preparedTools = prepareToolsWithUsageControl(tools, request.tools, logger, 'litellm')
+      const { tools: filteredTools, toolChoice } = preparedTools
+
+      if (filteredTools?.length && toolChoice) {
+        payload.tools = filteredTools
+        payload.tool_choice = toolChoice
+        hasActiveTools = true
+
+        logger.info('LiteLLM request configuration:', {
+          toolCount: filteredTools.length,
+          toolChoice:
+            typeof toolChoice === 'string'
+              ? toolChoice
+              : toolChoice.type === 'function'
+                ? `force:${toolChoice.function.name}`
+                : 'unknown',
+          model: payload.model,
+        })
+      }
+    }
+
+    const providerStartTime = Date.now()
+    const providerStartTimeISO = new Date(providerStartTime).toISOString()
+
+    try {
+      if (request.stream && (!tools || tools.length === 0 || !hasActiveTools)) {
+        logger.info('Using streaming response for LiteLLM request')
+
+        const streamingParams: ChatCompletionCreateParamsStreaming = {
+          ...payload,
+          stream: true,
+          stream_options: { include_usage: true },
+        }
+        const streamResponse = await litellm.chat.completions.create(
+          streamingParams,
+          request.abortSignal ? { signal: request.abortSignal } : undefined
+        )
+
+        const streamingResult = {
+          stream: createReadableStreamFromLiteLLMStream(streamResponse, (content, usage) => {
+            let cleanContent = content
+            if (cleanContent && request.responseFormat) {
+              cleanContent = cleanContent.replace(/```json\n?|\n?```/g, '').trim()
+            }
+
+            streamingResult.execution.output.content = cleanContent
+            streamingResult.execution.output.tokens = {
+              input: usage.prompt_tokens,
+              output: usage.completion_tokens,
+              total: usage.total_tokens,
+            }
+
+            const costResult = calculateCost(
+              request.model,
+              usage.prompt_tokens,
+              usage.completion_tokens
+            )
+            streamingResult.execution.output.cost = {
+              input: costResult.input,
+              output: costResult.output,
+              total: costResult.total,
+            }
+
+            const streamEndTime = Date.now()
+            const streamEndTimeISO = new Date(streamEndTime).toISOString()
+
+            if (streamingResult.execution.output.providerTiming) {
+              streamingResult.execution.output.providerTiming.endTime = streamEndTimeISO
+              streamingResult.execution.output.providerTiming.duration =
+                streamEndTime - providerStartTime
+
+              if (streamingResult.execution.output.providerTiming.timeSegments?.[0]) {
+                streamingResult.execution.output.providerTiming.timeSegments[0].endTime =
+                  streamEndTime
+                streamingResult.execution.output.providerTiming.timeSegments[0].duration =
+                  streamEndTime - providerStartTime
+              }
+            }
+          }),
+          execution: {
+            success: true,
+            output: {
+              content: '',
+              model: request.model,
+              tokens: { input: 0, output: 0, total: 0 },
+              toolCalls: undefined,
+              providerTiming: {
+                startTime: providerStartTimeISO,
+                endTime: new Date().toISOString(),
+                duration: Date.now() - providerStartTime,
+                timeSegments: [
+                  {
+                    type: 'model',
+                    name: request.model,
+                    startTime: providerStartTime,
+                    endTime: Date.now(),
+                    duration: Date.now() - providerStartTime,
+                  },
+                ],
+              },
+              cost: { input: 0, output: 0, total: 0 },
+            },
+            logs: [],
+            metadata: {
+              startTime: providerStartTimeISO,
+              endTime: new Date().toISOString(),
+              duration: Date.now() - providerStartTime,
+            },
+          },
+        } as StreamingExecution
+
+        return streamingResult as StreamingExecution
+      }
+
+      const initialCallTime = Date.now()
+
+      const originalToolChoice = payload.tool_choice
+
+      const forcedTools = preparedTools?.forcedTools || []
+      let usedForcedTools: string[] = []
+
+      const checkForForcedToolUsage = (
+        response: any,
+        toolChoice: string | { type: string; function?: { name: string }; name?: string; any?: any }
+      ) => {
+        if (typeof toolChoice === 'object' && response.choices[0]?.message?.tool_calls) {
+          const toolCallsResponse = response.choices[0].message.tool_calls
+          const result = trackForcedToolUsage(
+            toolCallsResponse,
+            toolChoice,
+            logger,
+            'litellm',
+            forcedTools,
+            usedForcedTools
+          )
+          hasUsedForcedTool = result.hasUsedForcedTool
+          usedForcedTools = result.usedForcedTools
+        }
+      }
+
+      let currentResponse = await litellm.chat.completions.create(
+        payload,
+        request.abortSignal ? { signal: request.abortSignal } : undefined
+      )
+      const firstResponseTime = Date.now() - initialCallTime
+
+      let content = currentResponse.choices[0]?.message?.content || ''
+
+      if (content && request.responseFormat) {
+        content = content.replace(/```json\n?|\n?```/g, '').trim()
+      }
+
+      const tokens = {
+        input: currentResponse.usage?.prompt_tokens || 0,
+        output: currentResponse.usage?.completion_tokens || 0,
+        total: currentResponse.usage?.total_tokens || 0,
+      }
+      const toolCalls = []
+      const toolResults: Record<string, unknown>[] = []
+      const currentMessages = [...formattedMessages]
+      let iterationCount = 0
+
+      let modelTime = firstResponseTime
+      let toolsTime = 0
+
+      let hasUsedForcedTool = false
+
+      const timeSegments: TimeSegment[] = [
+        {
+          type: 'model',
+          name: request.model,
+          startTime: initialCallTime,
+          endTime: initialCallTime + firstResponseTime,
+          duration: firstResponseTime,
+        },
+      ]
+
+      checkForForcedToolUsage(currentResponse, originalToolChoice)
+
+      while (iterationCount < MAX_TOOL_ITERATIONS) {
+        if (currentResponse.choices[0]?.message?.content) {
+          content = currentResponse.choices[0].message.content
+          if (request.responseFormat) {
+            content = content.replace(/```json\n?|\n?```/g, '').trim()
+          }
+        }
+
+        const toolCallsInResponse = currentResponse.choices[0]?.message?.tool_calls
+
+        enrichLastModelSegmentFromChatCompletions(
+          timeSegments,
+          currentResponse,
+          toolCallsInResponse,
+          { model: request.model, provider: 'litellm' }
+        )
+
+        if (!toolCallsInResponse || toolCallsInResponse.length === 0) {
+          break
+        }
+
+        logger.info(
+          `Processing ${toolCallsInResponse.length} tool calls (iteration ${iterationCount + 1}/${MAX_TOOL_ITERATIONS})`
+        )
+
+        const toolsStartTime = Date.now()
+
+        const toolExecutionPromises = toolCallsInResponse.map(async (toolCall) => {
+          const toolCallStartTime = Date.now()
+          const toolName = toolCall.function.name
+
+          try {
+            const toolArgs = JSON.parse(toolCall.function.arguments)
+            const tool = request.tools?.find((t) => t.id === toolName)
+
+            if (!tool) return null
+
+            const { toolParams, executionParams } = prepareToolExecution(tool, toolArgs, request)
+            const result = await executeTool(toolName, executionParams, {
+              signal: request.abortSignal,
+            })
+            const toolCallEndTime = Date.now()
+
+            return {
+              toolCall,
+              toolName,
+              toolParams,
+              result,
+              startTime: toolCallStartTime,
+              endTime: toolCallEndTime,
+              duration: toolCallEndTime - toolCallStartTime,
+            }
+          } catch (error) {
+            const toolCallEndTime = Date.now()
+            logger.error('Error processing tool call:', { error, toolName })
+
+            return {
+              toolCall,
+              toolName,
+              toolParams: {},
+              result: {
+                success: false,
+                output: undefined,
+                error: getErrorMessage(error, 'Tool execution failed'),
+              },
+              startTime: toolCallStartTime,
+              endTime: toolCallEndTime,
+              duration: toolCallEndTime - toolCallStartTime,
+            }
+          }
+        })
+
+        const executionResults = await Promise.allSettled(toolExecutionPromises)
+
+        currentMessages.push({
+          role: 'assistant',
+          content: null,
+          tool_calls: toolCallsInResponse.map((tc) => ({
+            id: tc.id,
+            type: 'function',
+            function: {
+              name: tc.function.name,
+              arguments: tc.function.arguments,
+            },
+          })),
+        })
+
+        for (const settledResult of executionResults) {
+          if (settledResult.status === 'rejected' || !settledResult.value) continue
+
+          const { toolCall, toolName, toolParams, result, startTime, endTime, duration } =
+            settledResult.value
+
+          timeSegments.push({
+            type: 'tool',
+            name: toolName,
+            startTime: startTime,
+            endTime: endTime,
+            duration: duration,
+            toolCallId: toolCall.id,
+          })
+
+          let resultContent: any
+          if (result.success && result.output) {
+            toolResults.push(result.output)
+            resultContent = result.output
+          } else {
+            resultContent = {
+              error: true,
+              message: result.error || 'Tool execution failed',
+              tool: toolName,
+            }
+          }
+
+          toolCalls.push({
+            name: toolName,
+            arguments: toolParams,
+            startTime: new Date(startTime).toISOString(),
+            endTime: new Date(endTime).toISOString(),
+            duration: duration,
+            result: resultContent,
+            success: result.success,
+          })
+
+          currentMessages.push({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            content: JSON.stringify(resultContent),
+          })
+        }
+
+        const thisToolsTime = Date.now() - toolsStartTime
+        toolsTime += thisToolsTime
+
+        const nextPayload = {
+          ...payload,
+          messages: currentMessages,
+        }
+
+        if (typeof originalToolChoice === 'object' && hasUsedForcedTool && forcedTools.length > 0) {
+          const remainingTools = forcedTools.filter((tool) => !usedForcedTools.includes(tool))
+
+          if (remainingTools.length > 0) {
+            nextPayload.tool_choice = {
+              type: 'function',
+              function: { name: remainingTools[0] },
+            }
+            logger.info(`Forcing next tool: ${remainingTools[0]}`)
+          } else {
+            nextPayload.tool_choice = 'auto'
+            logger.info('All forced tools have been used, switching to auto tool_choice')
+          }
+        }
+
+        const nextModelStartTime = Date.now()
+
+        currentResponse = await litellm.chat.completions.create(
+          nextPayload,
+          request.abortSignal ? { signal: request.abortSignal } : undefined
+        )
+
+        checkForForcedToolUsage(currentResponse, nextPayload.tool_choice)
+
+        const nextModelEndTime = Date.now()
+        const thisModelTime = nextModelEndTime - nextModelStartTime
+
+        timeSegments.push({
+          type: 'model',
+          name: request.model,
+          startTime: nextModelStartTime,
+          endTime: nextModelEndTime,
+          duration: thisModelTime,
+        })
+
+        modelTime += thisModelTime
+
+        if (currentResponse.choices[0]?.message?.content) {
+          content = currentResponse.choices[0].message.content
+          if (request.responseFormat) {
+            content = content.replace(/```json\n?|\n?```/g, '').trim()
+          }
+        }
+
+        if (currentResponse.usage) {
+          tokens.input += currentResponse.usage.prompt_tokens || 0
+          tokens.output += currentResponse.usage.completion_tokens || 0
+          tokens.total += currentResponse.usage.total_tokens || 0
+        }
+
+        iterationCount++
+      }
+
+      if (iterationCount === MAX_TOOL_ITERATIONS) {
+        enrichLastModelSegmentFromChatCompletions(
+          timeSegments,
+          currentResponse,
+          currentResponse.choices[0]?.message?.tool_calls,
+          { model: request.model, provider: 'litellm' }
+        )
+      }
+
+      if (request.stream) {
+        logger.info('Using streaming for final response after tool processing')
+
+        const accumulatedCost = calculateCost(request.model, tokens.input, tokens.output)
+
+        const streamingParams: ChatCompletionCreateParamsStreaming = {
+          ...payload,
+          messages: currentMessages,
+          tool_choice: 'auto',
+          stream: true,
+          stream_options: { include_usage: true },
+        }
+        const streamResponse = await litellm.chat.completions.create(
+          streamingParams,
+          request.abortSignal ? { signal: request.abortSignal } : undefined
+        )
+
+        const streamingResult = {
+          stream: createReadableStreamFromLiteLLMStream(streamResponse, (content, usage) => {
+            let cleanContent = content
+            if (cleanContent && request.responseFormat) {
+              cleanContent = cleanContent.replace(/```json\n?|\n?```/g, '').trim()
+            }
+
+            streamingResult.execution.output.content = cleanContent
+            streamingResult.execution.output.tokens = {
+              input: tokens.input + usage.prompt_tokens,
+              output: tokens.output + usage.completion_tokens,
+              total: tokens.total + usage.total_tokens,
+            }
+
+            const streamCost = calculateCost(
+              request.model,
+              usage.prompt_tokens,
+              usage.completion_tokens
+            )
+            const tc = sumToolCosts(toolResults)
+            streamingResult.execution.output.cost = {
+              input: accumulatedCost.input + streamCost.input,
+              output: accumulatedCost.output + streamCost.output,
+              toolCost: tc || undefined,
+              total: accumulatedCost.total + streamCost.total + tc,
+            }
+          }),
+          execution: {
+            success: true,
+            output: {
+              content: '',
+              model: request.model,
+              tokens: {
+                input: tokens.input,
+                output: tokens.output,
+                total: tokens.total,
+              },
+              toolCalls:
+                toolCalls.length > 0
+                  ? {
+                      list: toolCalls,
+                      count: toolCalls.length,
+                    }
+                  : undefined,
+              providerTiming: {
+                startTime: providerStartTimeISO,
+                endTime: new Date().toISOString(),
+                duration: Date.now() - providerStartTime,
+                modelTime: modelTime,
+                toolsTime: toolsTime,
+                firstResponseTime: firstResponseTime,
+                iterations: iterationCount + 1,
+                timeSegments: timeSegments,
+              },
+              cost: {
+                input: accumulatedCost.input,
+                output: accumulatedCost.output,
+                total: accumulatedCost.total,
+              },
+            },
+            logs: [],
+            metadata: {
+              startTime: providerStartTimeISO,
+              endTime: new Date().toISOString(),
+              duration: Date.now() - providerStartTime,
+            },
+          },
+        } as StreamingExecution
+
+        return streamingResult as StreamingExecution
+      }
+
+      const providerEndTime = Date.now()
+      const providerEndTimeISO = new Date(providerEndTime).toISOString()
+      const totalDuration = providerEndTime - providerStartTime
+
+      return {
+        content,
+        model: request.model,
+        tokens,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        toolResults: toolResults.length > 0 ? toolResults : undefined,
+        timing: {
+          startTime: providerStartTimeISO,
+          endTime: providerEndTimeISO,
+          duration: totalDuration,
+          modelTime: modelTime,
+          toolsTime: toolsTime,
+          firstResponseTime: firstResponseTime,
+          iterations: iterationCount + 1,
+          timeSegments: timeSegments,
+        },
+      }
+    } catch (error) {
+      const providerEndTime = Date.now()
+      const providerEndTimeISO = new Date(providerEndTime).toISOString()
+      const totalDuration = providerEndTime - providerStartTime
+
+      let errorMessage = toError(error).message
+      let errorType: string | undefined
+      let errorCode: number | undefined
+
+      if (error && typeof error === 'object' && 'error' in error) {
+        const litellmError = error.error as any
+        if (litellmError && typeof litellmError === 'object') {
+          errorMessage = litellmError.message || errorMessage
+          errorType = litellmError.type
+          errorCode = litellmError.code
+        }
+      }
+
+      logger.error('Error in LiteLLM request:', {
+        error: errorMessage,
+        errorType,
+        errorCode,
+        duration: totalDuration,
+      })
+
+      throw new ProviderError(errorMessage, {
+        startTime: providerStartTimeISO,
+        endTime: providerEndTimeISO,
+        duration: totalDuration,
+      })
+    }
+  },
+}
diff --git a/apps/sim/providers/litellm/utils.ts b/apps/sim/providers/litellm/utils.ts
new file mode 100644
index 00000000000..f779f95c703
--- /dev/null
+++ b/apps/sim/providers/litellm/utils.ts
@@ -0,0 +1,14 @@
+import type { ChatCompletionChunk } from 'openai/resources/chat/completions'
+import type { CompletionUsage } from 'openai/resources/completions'
+import { createOpenAICompatibleStream } from '@/providers/utils'
+
+/**
+ * Creates a ReadableStream from a LiteLLM streaming response.
+ * Uses the shared OpenAI-compatible streaming utility.
+ */
+export function createReadableStreamFromLiteLLMStream(
+  litellmStream: AsyncIterable<ChatCompletionChunk>,
+  onComplete?: (content: string, usage: CompletionUsage) => void
+): ReadableStream<Uint8Array> {
+  return createOpenAICompatibleStream(litellmStream, 'LiteLLM', onComplete)
+}
diff --git a/apps/sim/providers/models.ts b/apps/sim/providers/models.ts
index 82497c87d04..375506cde25 100644
--- a/apps/sim/providers/models.ts
+++ b/apps/sim/providers/models.ts
@@ -17,6 +17,7 @@ import {
   FireworksIcon,
   GeminiIcon,
   GroqIcon,
+  LitellmIcon,
   MistralIcon,
   OllamaIcon,
   OpenAIIcon,
@@ -125,6 +126,20 @@ export const PROVIDER_DEFINITIONS: Record<string, ProviderDefinition> = {
     },
     models: [],
   },
+  litellm: {
+    id: 'litellm',
+    name: 'LiteLLM',
+    icon: LitellmIcon,
+    color: '#040229',
+    description: 'LiteLLM proxy with an OpenAI-compatible API',
+    defaultModel: '',
+    modelPatterns: [/^litellm\//],
+    capabilities: {
+      temperature: { min: 0, max: 2 },
+      toolUsageControl: true,
+    },
+    models: [],
+  },
   openai: {
     id: 'openai',
     name: 'OpenAI',
@@ -2803,7 +2818,13 @@ export function getProviderModels(providerId: string): string[] {
   return PROVIDER_DEFINITIONS[providerId]?.models.map((m) => m.id) || []
 }
 
-export const DYNAMIC_MODEL_PROVIDERS = ['ollama', 'vllm', 'openrouter', 'fireworks'] as const
+export const DYNAMIC_MODEL_PROVIDERS = [
+  'ollama',
+  'vllm',
+  'litellm',
+  'openrouter',
+  'fireworks',
+] as const
 
 function getAllStaticModelIds(): string[] {
   const ids: string[] = []
@@ -2857,7 +2878,7 @@ export function suggestModelIdsForUnknownModel(_modelId: string, limit = 5): str
 
 export function getBaseModelProviders(): Record<string, ProviderId> {
   return Object.entries(PROVIDER_DEFINITIONS)
-    .filter(([providerId]) => !['ollama', 'vllm', 'openrouter'].includes(providerId))
+    .filter(([providerId]) => !['ollama', 'vllm', 'litellm', 'openrouter'].includes(providerId))
     .reduce(
       (map, [providerId, provider]) => {
         provider.models.forEach((model) => {
@@ -3034,6 +3055,18 @@ export function updateVLLMModels(models: string[]): void {
   }))
 }
 
+export function updateLiteLLMModels(models: string[]): void {
+  PROVIDER_DEFINITIONS.litellm.models = models.map((modelId) => ({
+    id: modelId,
+    pricing: {
+      input: 0,
+      output: 0,
+      updatedAt: new Date().toISOString().split('T')[0],
+    },
+    capabilities: {},
+  }))
+}
+
 export function updateFireworksModels(models: string[]): void {
   PROVIDER_DEFINITIONS.fireworks.models = models.map((modelId) => ({
     id: modelId,
diff --git a/apps/sim/providers/registry.ts b/apps/sim/providers/registry.ts
index 8b1256c2de7..5aa48d3db3a 100644
--- a/apps/sim/providers/registry.ts
+++ b/apps/sim/providers/registry.ts
@@ -9,6 +9,7 @@ import { deepseekProvider } from '@/providers/deepseek'
 import { fireworksProvider } from '@/providers/fireworks'
 import { googleProvider } from '@/providers/google'
 import { groqProvider } from '@/providers/groq'
+import { litellmProvider } from '@/providers/litellm'
 import { mistralProvider } from '@/providers/mistral'
 import { ollamaProvider } from '@/providers/ollama'
 import { openaiProvider } from '@/providers/openai'
@@ -31,6 +32,7 @@ const providerRegistry: Record<ProviderId, ProviderConfig> = {
   cerebras: cerebrasProvider,
   groq: groqProvider,
   vllm: vllmProvider,
+  litellm: litellmProvider,
   mistral: mistralProvider,
   'azure-openai': azureOpenAIProvider,
   openrouter: openRouterProvider,
diff --git a/apps/sim/providers/types.ts b/apps/sim/providers/types.ts
index 007b9b3ead5..dc2f25927d6 100644
--- a/apps/sim/providers/types.ts
+++ b/apps/sim/providers/types.ts
@@ -16,6 +16,7 @@ export type ProviderId =
   | 'openrouter'
   | 'fireworks'
   | 'vllm'
+  | 'litellm'
   | 'bedrock'
 
 export interface ModelPricing {
diff --git a/apps/sim/providers/utils.test.ts b/apps/sim/providers/utils.test.ts
index 0b46003ca4a..03e50c78f24 100644
--- a/apps/sim/providers/utils.test.ts
+++ b/apps/sim/providers/utils.test.ts
@@ -168,6 +168,19 @@ describe('getApiKey', () => {
       expect(key2).toBe('user-key')
     }
   )
+
+  it.concurrent(
+    'should return empty or user-provided key for litellm provider without requiring API key',
+    () => {
+      isHostedSpy.mockReturnValue(false)
+
+      const key = getApiKey('litellm', 'litellm/anthropic/claude-sonnet-4-6')
+      expect(key).toBe('empty')
+
+      const key2 = getApiKey('litellm', 'litellm/openai/gpt-4', 'user-key')
+      expect(key2).toBe('user-key')
+    }
+  )
 })
 
 describe('Model Capabilities', () => {
diff --git a/apps/sim/providers/utils.ts b/apps/sim/providers/utils.ts
index a646214b148..205fb307873 100644
--- a/apps/sim/providers/utils.ts
+++ b/apps/sim/providers/utils.ts
@@ -132,6 +132,7 @@ function buildProviderMetadata(providerId: ProviderId): ProviderMetadata {
 export const providers: Record<ProviderId, ProviderMetadata> = {
   ollama: buildProviderMetadata('ollama'),
   vllm: buildProviderMetadata('vllm'),
+  litellm: buildProviderMetadata('litellm'),
   openai: {
     ...buildProviderMetadata('openai'),
     computerUseModels: ['computer-use-preview'],
@@ -167,6 +168,12 @@ export function updateVLLMProviderModels(models: string[]): void {
   providers.vllm.models = getProviderModelsFromDefinitions('vllm')
 }
 
+export function updateLiteLLMProviderModels(models: string[]): void {
+  const { updateLiteLLMModels } = require('@/providers/models')
+  updateLiteLLMModels(models)
+  providers.litellm.models = getProviderModelsFromDefinitions('litellm')
+}
+
 export async function updateOpenRouterProviderModels(models: string[]): Promise<void> {
   const { updateOpenRouterModels } = await import('@/providers/models')
   updateOpenRouterModels(models)
@@ -185,6 +192,7 @@ export function getBaseModelProviders(): Record<string, ProviderId> {
       ([providerId]) =>
         providerId !== 'ollama' &&
         providerId !== 'vllm' &&
+        providerId !== 'litellm' &&
         providerId !== 'openrouter' &&
         providerId !== 'fireworks'
     )
@@ -744,6 +752,12 @@ export function getApiKey(provider: string, model: string, userProvidedKey?: str
     return userProvidedKey || 'empty'
   }
 
+  const isLitellmModel =
+    provider === 'litellm' || useProvidersStore.getState().providers.litellm.models.includes(model)
+  if (isLitellmModel) {
+    return userProvidedKey || 'empty'
+  }
+
   // Bedrock uses its own credentials (bedrockAccessKeyId/bedrockSecretKey), not apiKey
   const isBedrockModel = provider === 'bedrock' || model.startsWith('bedrock/')
   if (isBedrockModel) {
diff --git a/apps/sim/stores/providers/store.ts b/apps/sim/stores/providers/store.ts
index 4567812e0f8..00896c0ba7c 100644
--- a/apps/sim/stores/providers/store.ts
+++ b/apps/sim/stores/providers/store.ts
@@ -9,6 +9,7 @@ export const useProvidersStore = create<ProvidersStore>((set, get) => ({
     base: { models: [], isLoading: false },
     ollama: { models: [], isLoading: false },
     vllm: { models: [], isLoading: false },
+    litellm: { models: [], isLoading: false },
     openrouter: { models: [], isLoading: false },
     fireworks: { models: [], isLoading: false },
   },
diff --git a/apps/sim/stores/providers/types.ts b/apps/sim/stores/providers/types.ts
index e76870c04cf..7022529f202 100644
--- a/apps/sim/stores/providers/types.ts
+++ b/apps/sim/stores/providers/types.ts
@@ -1,4 +1,4 @@
-export type ProviderName = 'ollama' | 'vllm' | 'openrouter' | 'fireworks' | 'base'
+export type ProviderName = 'ollama' | 'vllm' | 'litellm' | 'openrouter' | 'fireworks' | 'base'
 
 export interface OpenRouterModelInfo {
   id: string
diff --git a/apps/sim/tools/hunter/companies_find.ts b/apps/sim/tools/hunter/companies_find.ts
index 4b158a91f3a..b92a59b3b1f 100644
--- a/apps/sim/tools/hunter/companies_find.ts
+++ b/apps/sim/tools/hunter/companies_find.ts
@@ -1,4 +1,5 @@
 import type { HunterEnrichmentParams, HunterEnrichmentResponse } from '@/tools/hunter/types'
+import { HUNTER_API_KEY_PREFIX } from '@/tools/hunter/types'
 import type { ToolConfig } from '@/tools/types'
 
 export const companiesFindTool: ToolConfig<HunterEnrichmentParams, HunterEnrichmentResponse> = {
@@ -7,6 +8,18 @@ export const companiesFindTool: ToolConfig<HunterEnrichmentParams, HunterEnrichm
   description: 'Enriches company data using domain name.',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: HUNTER_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'hunter',
+    // Companies Find (enrichment) is free on Hunter — no credits consumed.
+    pricing: { type: 'per_request', cost: 0 },
+    rateLimit: {
+      mode: 'per_request',
+      requestsPerMinute: 60,
+    },
+  },
+
   params: {
     domain: {
       type: 'string',
diff --git a/apps/sim/tools/hunter/discover.ts b/apps/sim/tools/hunter/discover.ts
index bdcd26c97da..876d5c49b9f 100644
--- a/apps/sim/tools/hunter/discover.ts
+++ b/apps/sim/tools/hunter/discover.ts
@@ -1,5 +1,5 @@
 import type { HunterDiscoverParams, HunterDiscoverResponse } from '@/tools/hunter/types'
-import { DISCOVER_RESULTS_OUTPUT } from '@/tools/hunter/types'
+import { DISCOVER_RESULTS_OUTPUT, HUNTER_API_KEY_PREFIX } from '@/tools/hunter/types'
 import type { ToolConfig } from '@/tools/types'
 
 export const discoverTool: ToolConfig<HunterDiscoverParams, HunterDiscoverResponse> = {
@@ -8,6 +8,18 @@ export const discoverTool: ToolConfig<HunterDiscoverParams, HunterDiscoverRespon
   description: 'Returns companies matching a set of criteria using Hunter.io AI-powered search.',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: HUNTER_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'hunter',
+    // Discover is free on Hunter — no credits consumed.
+    pricing: { type: 'per_request', cost: 0 },
+    rateLimit: {
+      mode: 'per_request',
+      requestsPerMinute: 30,
+    },
+  },
+
   params: {
     query: {
       type: 'string',
diff --git a/apps/sim/tools/hunter/domain_search.ts b/apps/sim/tools/hunter/domain_search.ts
index 33d99cbd508..3c83495355a 100644
--- a/apps/sim/tools/hunter/domain_search.ts
+++ b/apps/sim/tools/hunter/domain_search.ts
@@ -3,7 +3,11 @@ import type {
   HunterDomainSearchResponse,
   HunterEmail,
 } from '@/tools/hunter/types'
-import { EMAILS_OUTPUT } from '@/tools/hunter/types'
+import {
+  EMAILS_OUTPUT,
+  HUNTER_API_KEY_PREFIX,
+  HUNTER_SEARCH_CREDIT_USD,
+} from '@/tools/hunter/types'
 import type { ToolConfig } from '@/tools/types'
 
 export const domainSearchTool: ToolConfig<HunterDomainSearchParams, HunterDomainSearchResponse> = {
@@ -12,6 +16,28 @@ export const domainSearchTool: ToolConfig<HunterDomainSearchParams, HunterDomain
   description: 'Returns all the email addresses found using one given domain name, with sources.',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: HUNTER_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'hunter',
+    pricing: {
+      type: 'custom',
+      getCost: (_params, output) => {
+        const emails = output.emails
+        if (!Array.isArray(emails)) {
+          throw new Error('Hunter domain search response missing emails, cannot determine cost')
+        }
+        // Hunter counts one search credit only when a call returns at least one result.
+        const cost = emails.length > 0 ? HUNTER_SEARCH_CREDIT_USD : 0
+        return { cost, metadata: { credits: cost > 0 ? 1 : 0, emails: emails.length } }
+      },
+    },
+    rateLimit: {
+      mode: 'per_request',
+      requestsPerMinute: 60,
+    },
+  },
+
   params: {
     domain: {
       type: 'string',
diff --git a/apps/sim/tools/hunter/email_count.ts b/apps/sim/tools/hunter/email_count.ts
index 021d290d4e8..25022267074 100644
--- a/apps/sim/tools/hunter/email_count.ts
+++ b/apps/sim/tools/hunter/email_count.ts
@@ -1,5 +1,5 @@
 import type { HunterEmailCountParams, HunterEmailCountResponse } from '@/tools/hunter/types'
-import { DEPARTMENT_OUTPUT, SENIORITY_OUTPUT } from '@/tools/hunter/types'
+import { DEPARTMENT_OUTPUT, HUNTER_API_KEY_PREFIX, SENIORITY_OUTPUT } from '@/tools/hunter/types'
 import type { ToolConfig } from '@/tools/types'
 
 export const emailCountTool: ToolConfig<HunterEmailCountParams, HunterEmailCountResponse> = {
@@ -8,6 +8,18 @@ export const emailCountTool: ToolConfig<HunterEmailCountParams, HunterEmailCount
   description: 'Returns the total number of email addresses found for a domain or company.',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: HUNTER_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'hunter',
+    // Email Count is free on Hunter — no credits consumed.
+    pricing: { type: 'per_request', cost: 0 },
+    rateLimit: {
+      mode: 'per_request',
+      requestsPerMinute: 60,
+    },
+  },
+
   params: {
     domain: {
       type: 'string',
diff --git a/apps/sim/tools/hunter/email_finder.ts b/apps/sim/tools/hunter/email_finder.ts
index 22c427fec58..4263afe104c 100644
--- a/apps/sim/tools/hunter/email_finder.ts
+++ b/apps/sim/tools/hunter/email_finder.ts
@@ -1,5 +1,10 @@
 import type { HunterEmailFinderParams, HunterEmailFinderResponse } from '@/tools/hunter/types'
-import { SOURCES_OUTPUT, VERIFICATION_OUTPUT } from '@/tools/hunter/types'
+import {
+  HUNTER_API_KEY_PREFIX,
+  HUNTER_SEARCH_CREDIT_USD,
+  SOURCES_OUTPUT,
+  VERIFICATION_OUTPUT,
+} from '@/tools/hunter/types'
 import type { ToolConfig } from '@/tools/types'
 
 export const emailFinderTool: ToolConfig<HunterEmailFinderParams, HunterEmailFinderResponse> = {
@@ -9,6 +14,25 @@ export const emailFinderTool: ToolConfig<HunterEmailFinderParams, HunterEmailFin
     'Finds the most likely email address for a person given their name and company domain.',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: HUNTER_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'hunter',
+    pricing: {
+      type: 'custom',
+      getCost: (_params, output) => {
+        // Hunter counts one search credit only when an email is found.
+        const found = typeof output.email === 'string' && output.email.length > 0
+        const cost = found ? HUNTER_SEARCH_CREDIT_USD : 0
+        return { cost, metadata: { credits: found ? 1 : 0 } }
+      },
+    },
+    rateLimit: {
+      mode: 'per_request',
+      requestsPerMinute: 60,
+    },
+  },
+
   params: {
     domain: {
       type: 'string',
diff --git a/apps/sim/tools/hunter/email_verifier.ts b/apps/sim/tools/hunter/email_verifier.ts
index 14c6efe43c7..c988bab6d2b 100644
--- a/apps/sim/tools/hunter/email_verifier.ts
+++ b/apps/sim/tools/hunter/email_verifier.ts
@@ -1,5 +1,9 @@
 import type { HunterEmailVerifierParams, HunterEmailVerifierResponse } from '@/tools/hunter/types'
-import { SOURCES_OUTPUT } from '@/tools/hunter/types'
+import {
+  HUNTER_API_KEY_PREFIX,
+  HUNTER_VERIFICATION_CREDIT_USD,
+  SOURCES_OUTPUT,
+} from '@/tools/hunter/types'
 import type { ToolConfig } from '@/tools/types'
 
 export const emailVerifierTool: ToolConfig<HunterEmailVerifierParams, HunterEmailVerifierResponse> =
@@ -10,6 +14,24 @@ export const emailVerifierTool: ToolConfig<HunterEmailVerifierParams, HunterEmai
       'Verifies the deliverability of an email address and provides detailed verification status.',
     version: '1.0.0',
 
+    hosting: {
+      envKeyPrefix: HUNTER_API_KEY_PREFIX,
+      apiKeyParam: 'apiKey',
+      byokProviderId: 'hunter',
+      pricing: {
+        type: 'custom',
+        // The verifier always consumes one verification (0.5 credit), regardless of result.
+        getCost: () => ({
+          cost: HUNTER_VERIFICATION_CREDIT_USD,
+          metadata: { verifications: 1 },
+        }),
+      },
+      rateLimit: {
+        mode: 'per_request',
+        requestsPerMinute: 60,
+      },
+    },
+
     params: {
       email: {
         type: 'string',
diff --git a/apps/sim/tools/hunter/types.ts b/apps/sim/tools/hunter/types.ts
index 32c0177f8af..b77c1162f79 100644
--- a/apps/sim/tools/hunter/types.ts
+++ b/apps/sim/tools/hunter/types.ts
@@ -1,6 +1,25 @@
 // Common types for Hunter.io tools
 import type { OutputProperty, ToolResponse } from '@/tools/types'
 
+/**
+ * Env var prefix for Sim-hosted Hunter.io keys.
+ * Resolved at runtime as `HUNTER_API_KEY_COUNT` + `HUNTER_API_KEY_1..N`.
+ */
+export const HUNTER_API_KEY_PREFIX = 'HUNTER_API_KEY'
+
+/**
+ * Dollar cost per Hunter.io credit when billing hosted-key usage.
+ *
+ * Hunter does not report per-call credit consumption in its responses, so cost is
+ * derived from the response: a "search" credit is consumed only when a call returns
+ * at least one result; a verification consumes half a credit.
+ *
+ * Estimate based on the Growth plan ($149/mo for 10,000 credits ≈ $0.015/credit) —
+ * see https://hunter.io/pricing. Tune if Sim's plan rate changes.
+ */
+export const HUNTER_SEARCH_CREDIT_USD = 0.015
+export const HUNTER_VERIFICATION_CREDIT_USD = 0.0075
+
 /**
  * Shared output property definitions for Hunter.io API responses.
  * These are reusable across all Hunter tools to ensure consistency.
diff --git a/apps/sim/tools/peopledatalabs/autocomplete.ts b/apps/sim/tools/peopledatalabs/autocomplete.ts
index 588605f7a59..9353c3aa143 100644
--- a/apps/sim/tools/peopledatalabs/autocomplete.ts
+++ b/apps/sim/tools/peopledatalabs/autocomplete.ts
@@ -1,4 +1,5 @@
 import type { PdlAutocompleteParams, PdlAutocompleteResponse } from '@/tools/peopledatalabs/types'
+import { PEOPLEDATALABS_API_KEY_PREFIX } from '@/tools/peopledatalabs/types'
 import { buildQueryString } from '@/tools/peopledatalabs/utils'
 import type { OutputProperty, ToolConfig } from '@/tools/types'
 
@@ -19,6 +20,18 @@ export const autocompleteTool: ToolConfig<PdlAutocompleteParams, PdlAutocomplete
     'Get autocomplete suggestions for a PDL field (title, skill, company, industry, location, school, major, role, sub_role).',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: PEOPLEDATALABS_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'peopledatalabs',
+    // Autocomplete is free on PDL (rate-limited only) — no credits consumed.
+    pricing: { type: 'per_request', cost: 0 },
+    rateLimit: {
+      mode: 'per_request',
+      requestsPerMinute: 60,
+    },
+  },
+
   params: {
     apiKey: {
       type: 'string',
diff --git a/apps/sim/tools/peopledatalabs/bulk_company_enrich.ts b/apps/sim/tools/peopledatalabs/bulk_company_enrich.ts
index 278e8cfdb21..139a0bac7a9 100644
--- a/apps/sim/tools/peopledatalabs/bulk_company_enrich.ts
+++ b/apps/sim/tools/peopledatalabs/bulk_company_enrich.ts
@@ -3,7 +3,8 @@ import type {
   PdlBulkCompanyEnrichResponse,
   PdlBulkCompanyResultItem,
 } from '@/tools/peopledatalabs/types'
-import { projectCompany } from '@/tools/peopledatalabs/utils'
+import { PDL_CREDIT_USD, PEOPLEDATALABS_API_KEY_PREFIX } from '@/tools/peopledatalabs/types'
+import { countBulkMatched, projectCompany } from '@/tools/peopledatalabs/utils'
 import type { OutputProperty, ToolConfig } from '@/tools/types'
 
 const BULK_COMPANY_RESULT_PROPERTIES = {
@@ -32,6 +33,31 @@ export const bulkCompanyEnrichTool: ToolConfig<
     'Enrich up to 100 companies in a single call. Provide a JSON array of request objects, each with a `params` object. Reference: https://docs.peopledatalabs.com/docs/bulk-company-enrichment-api',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: PEOPLEDATALABS_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'peopledatalabs',
+    pricing: {
+      type: 'custom',
+      // PDL charges 1 credit per matched record; unmatched records in the batch are free.
+      getCost: (_params, output) => {
+        const matched = countBulkMatched(output)
+        return { cost: matched * PDL_CREDIT_USD, metadata: { credits: matched } }
+      },
+    },
+    rateLimit: {
+      mode: 'custom',
+      requestsPerMinute: 10,
+      dimensions: [
+        {
+          name: 'credits',
+          limitPerMinute: 600,
+          extractUsage: (_params, response) => countBulkMatched(response),
+        },
+      ],
+    },
+  },
+
   params: {
     apiKey: {
       type: 'string',
diff --git a/apps/sim/tools/peopledatalabs/bulk_person_enrich.ts b/apps/sim/tools/peopledatalabs/bulk_person_enrich.ts
index 8df13c55e24..a993a8e1e22 100644
--- a/apps/sim/tools/peopledatalabs/bulk_person_enrich.ts
+++ b/apps/sim/tools/peopledatalabs/bulk_person_enrich.ts
@@ -3,7 +3,8 @@ import type {
   PdlBulkPersonEnrichResponse,
   PdlBulkPersonResultItem,
 } from '@/tools/peopledatalabs/types'
-import { projectPerson } from '@/tools/peopledatalabs/utils'
+import { PDL_CREDIT_USD, PEOPLEDATALABS_API_KEY_PREFIX } from '@/tools/peopledatalabs/types'
+import { countBulkMatched, projectPerson } from '@/tools/peopledatalabs/utils'
 import type { OutputProperty, ToolConfig } from '@/tools/types'
 
 const BULK_PERSON_RESULT_PROPERTIES = {
@@ -32,6 +33,31 @@ export const bulkPersonEnrichTool: ToolConfig<
     'Enrich up to 100 person records in a single call. Provide a JSON array of request objects, each with a `params` object (and optional `metadata` echoed back). Reference: https://docs.peopledatalabs.com/docs/bulk-person-enrichment-api',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: PEOPLEDATALABS_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'peopledatalabs',
+    pricing: {
+      type: 'custom',
+      // PDL charges 1 credit per matched record; unmatched records in the batch are free.
+      getCost: (_params, output) => {
+        const matched = countBulkMatched(output)
+        return { cost: matched * PDL_CREDIT_USD, metadata: { credits: matched } }
+      },
+    },
+    rateLimit: {
+      mode: 'custom',
+      requestsPerMinute: 10,
+      dimensions: [
+        {
+          name: 'credits',
+          limitPerMinute: 600,
+          extractUsage: (_params, response) => countBulkMatched(response),
+        },
+      ],
+    },
+  },
+
   params: {
     apiKey: {
       type: 'string',
diff --git a/apps/sim/tools/peopledatalabs/company_clean.ts b/apps/sim/tools/peopledatalabs/company_clean.ts
index 65aaff4b87f..67b34ab2492 100644
--- a/apps/sim/tools/peopledatalabs/company_clean.ts
+++ b/apps/sim/tools/peopledatalabs/company_clean.ts
@@ -1,5 +1,8 @@
 import type { PdlCleanCompanyParams, PdlCleanCompanyResponse } from '@/tools/peopledatalabs/types'
-import { PDL_COMPANY_OUTPUT_PROPERTIES } from '@/tools/peopledatalabs/types'
+import {
+  PDL_COMPANY_OUTPUT_PROPERTIES,
+  PEOPLEDATALABS_API_KEY_PREFIX,
+} from '@/tools/peopledatalabs/types'
 import { projectCompany } from '@/tools/peopledatalabs/utils'
 import type { ToolConfig } from '@/tools/types'
 
@@ -10,6 +13,18 @@ export const cleanCompanyTool: ToolConfig<PdlCleanCompanyParams, PdlCleanCompany
     'Normalize a company string into a canonical company record. Provide at least one of name, website, or profile (LinkedIn URL).',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: PEOPLEDATALABS_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'peopledatalabs',
+    // Cleaner APIs are free on PDL (rate-limited only) — no credits consumed.
+    pricing: { type: 'per_request', cost: 0 },
+    rateLimit: {
+      mode: 'per_request',
+      requestsPerMinute: 60,
+    },
+  },
+
   params: {
     apiKey: {
       type: 'string',
diff --git a/apps/sim/tools/peopledatalabs/company_enrich.ts b/apps/sim/tools/peopledatalabs/company_enrich.ts
index 2e278eac5eb..959d465a6c7 100644
--- a/apps/sim/tools/peopledatalabs/company_enrich.ts
+++ b/apps/sim/tools/peopledatalabs/company_enrich.ts
@@ -1,5 +1,9 @@
 import type { PdlCompanyEnrichParams, PdlCompanyEnrichResponse } from '@/tools/peopledatalabs/types'
-import { PDL_COMPANY_OUTPUT_PROPERTIES } from '@/tools/peopledatalabs/types'
+import {
+  PDL_COMPANY_OUTPUT_PROPERTIES,
+  PDL_CREDIT_USD,
+  PEOPLEDATALABS_API_KEY_PREFIX,
+} from '@/tools/peopledatalabs/types'
 import { buildQueryString, projectCompany } from '@/tools/peopledatalabs/utils'
 import type { ToolConfig } from '@/tools/types'
 
@@ -10,6 +14,24 @@ export const companyEnrichTool: ToolConfig<PdlCompanyEnrichParams, PdlCompanyEnr
     'Enrich a single company using People Data Labs. Match by name, website, LinkedIn URL, ticker, or PDL ID.',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: PEOPLEDATALABS_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'peopledatalabs',
+    pricing: {
+      type: 'custom',
+      // PDL charges 1 credit per matched request; misses (404) are free.
+      getCost: (_params, output) => {
+        const cost = output.matched === true ? PDL_CREDIT_USD : 0
+        return { cost, metadata: { credits: output.matched === true ? 1 : 0 } }
+      },
+    },
+    rateLimit: {
+      mode: 'per_request',
+      requestsPerMinute: 60,
+    },
+  },
+
   params: {
     apiKey: {
       type: 'string',
diff --git a/apps/sim/tools/peopledatalabs/company_search.ts b/apps/sim/tools/peopledatalabs/company_search.ts
index 2c71d66aa41..9027045ab52 100644
--- a/apps/sim/tools/peopledatalabs/company_search.ts
+++ b/apps/sim/tools/peopledatalabs/company_search.ts
@@ -1,5 +1,9 @@
 import type { PdlCompanySearchParams, PdlCompanySearchResponse } from '@/tools/peopledatalabs/types'
-import { PDL_COMPANY_OUTPUT_PROPERTIES } from '@/tools/peopledatalabs/types'
+import {
+  PDL_COMPANY_OUTPUT_PROPERTIES,
+  PDL_CREDIT_USD,
+  PEOPLEDATALABS_API_KEY_PREFIX,
+} from '@/tools/peopledatalabs/types'
 import { projectCompany } from '@/tools/peopledatalabs/utils'
 import type { ToolConfig } from '@/tools/types'
 
@@ -10,6 +14,35 @@ export const companySearchTool: ToolConfig<PdlCompanySearchParams, PdlCompanySea
     'Search the People Data Labs company dataset using SQL or Elasticsearch DSL. Returns up to 100 matching companies per call.',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: PEOPLEDATALABS_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'peopledatalabs',
+    pricing: {
+      type: 'custom',
+      // PDL Search charges 1 credit per company returned (up to the requested size).
+      getCost: (_params, output) => {
+        const results = output.results
+        if (!Array.isArray(results)) {
+          throw new Error('PDL company search response missing results, cannot determine cost')
+        }
+        return { cost: results.length * PDL_CREDIT_USD, metadata: { credits: results.length } }
+      },
+    },
+    rateLimit: {
+      mode: 'custom',
+      requestsPerMinute: 30,
+      dimensions: [
+        {
+          name: 'credits',
+          limitPerMinute: 600,
+          extractUsage: (_params, response) =>
+            Array.isArray(response.results) ? response.results.length : 0,
+        },
+      ],
+    },
+  },
+
   params: {
     apiKey: {
       type: 'string',
diff --git a/apps/sim/tools/peopledatalabs/location_clean.ts b/apps/sim/tools/peopledatalabs/location_clean.ts
index e08e7a6f5aa..4222d3345f5 100644
--- a/apps/sim/tools/peopledatalabs/location_clean.ts
+++ b/apps/sim/tools/peopledatalabs/location_clean.ts
@@ -1,5 +1,8 @@
 import type { PdlCleanLocationParams, PdlCleanLocationResponse } from '@/tools/peopledatalabs/types'
-import { PDL_LOCATION_OUTPUT_PROPERTIES } from '@/tools/peopledatalabs/types'
+import {
+  PDL_LOCATION_OUTPUT_PROPERTIES,
+  PEOPLEDATALABS_API_KEY_PREFIX,
+} from '@/tools/peopledatalabs/types'
 import { projectLocation } from '@/tools/peopledatalabs/utils'
 import type { ToolConfig } from '@/tools/types'
 
@@ -10,6 +13,18 @@ export const cleanLocationTool: ToolConfig<PdlCleanLocationParams, PdlCleanLocat
     'Normalize a freeform location string into a structured locality/region/country record with coordinates.',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: PEOPLEDATALABS_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'peopledatalabs',
+    // Cleaner APIs are free on PDL (rate-limited only) — no credits consumed.
+    pricing: { type: 'per_request', cost: 0 },
+    rateLimit: {
+      mode: 'per_request',
+      requestsPerMinute: 60,
+    },
+  },
+
   params: {
     apiKey: {
       type: 'string',
diff --git a/apps/sim/tools/peopledatalabs/person_enrich.ts b/apps/sim/tools/peopledatalabs/person_enrich.ts
index 0157260534f..65576f11c89 100644
--- a/apps/sim/tools/peopledatalabs/person_enrich.ts
+++ b/apps/sim/tools/peopledatalabs/person_enrich.ts
@@ -1,5 +1,9 @@
 import type { PdlPersonEnrichParams, PdlPersonEnrichResponse } from '@/tools/peopledatalabs/types'
-import { PDL_PERSON_OUTPUT_PROPERTIES } from '@/tools/peopledatalabs/types'
+import {
+  PDL_CREDIT_USD,
+  PDL_PERSON_OUTPUT_PROPERTIES,
+  PEOPLEDATALABS_API_KEY_PREFIX,
+} from '@/tools/peopledatalabs/types'
 import { buildQueryString, projectPerson } from '@/tools/peopledatalabs/utils'
 import type { ToolConfig } from '@/tools/types'
 
@@ -10,6 +14,24 @@ export const personEnrichTool: ToolConfig<PdlPersonEnrichParams, PdlPersonEnrich
     'Enrich a single person profile using People Data Labs. Match by email, phone, LinkedIn URL, or name + company/location. Returns work history, contact details, location, and skills.',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: PEOPLEDATALABS_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'peopledatalabs',
+    pricing: {
+      type: 'custom',
+      // PDL charges 1 credit per matched request; misses (404) are free.
+      getCost: (_params, output) => {
+        const cost = output.matched === true ? PDL_CREDIT_USD : 0
+        return { cost, metadata: { credits: output.matched === true ? 1 : 0 } }
+      },
+    },
+    rateLimit: {
+      mode: 'per_request',
+      requestsPerMinute: 60,
+    },
+  },
+
   params: {
     apiKey: {
       type: 'string',
diff --git a/apps/sim/tools/peopledatalabs/person_identify.ts b/apps/sim/tools/peopledatalabs/person_identify.ts
index d68f74e3c24..7a16aa1fcb2 100644
--- a/apps/sim/tools/peopledatalabs/person_identify.ts
+++ b/apps/sim/tools/peopledatalabs/person_identify.ts
@@ -2,7 +2,11 @@ import type {
   PdlPersonIdentifyParams,
   PdlPersonIdentifyResponse,
 } from '@/tools/peopledatalabs/types'
-import { PDL_PERSON_OUTPUT_PROPERTIES } from '@/tools/peopledatalabs/types'
+import {
+  PDL_CREDIT_USD,
+  PDL_PERSON_OUTPUT_PROPERTIES,
+  PEOPLEDATALABS_API_KEY_PREFIX,
+} from '@/tools/peopledatalabs/types'
 import { buildQueryString, projectPerson } from '@/tools/peopledatalabs/utils'
 import type { OutputProperty, ToolConfig } from '@/tools/types'
 
@@ -28,6 +32,28 @@ export const personIdentifyTool: ToolConfig<PdlPersonIdentifyParams, PdlPersonId
     'Return up to 20 candidate person matches with confidence scores. Useful when you want to see all plausible matches rather than the single best one. Reference: https://docs.peopledatalabs.com/docs/identify-api-quickstart',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: PEOPLEDATALABS_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'peopledatalabs',
+    pricing: {
+      type: 'custom',
+      // PDL Identify charges 1 credit per call that returns matches, regardless of count.
+      getCost: (_params, output) => {
+        const matches = output.matches
+        if (!Array.isArray(matches)) {
+          throw new Error('PDL identify response missing matches, cannot determine cost')
+        }
+        const cost = matches.length > 0 ? PDL_CREDIT_USD : 0
+        return { cost, metadata: { credits: matches.length > 0 ? 1 : 0 } }
+      },
+    },
+    rateLimit: {
+      mode: 'per_request',
+      requestsPerMinute: 60,
+    },
+  },
+
   params: {
     apiKey: {
       type: 'string',
diff --git a/apps/sim/tools/peopledatalabs/person_search.ts b/apps/sim/tools/peopledatalabs/person_search.ts
index 4efb94edd8d..17adeb1721b 100644
--- a/apps/sim/tools/peopledatalabs/person_search.ts
+++ b/apps/sim/tools/peopledatalabs/person_search.ts
@@ -1,5 +1,9 @@
 import type { PdlPersonSearchParams, PdlPersonSearchResponse } from '@/tools/peopledatalabs/types'
-import { PDL_PERSON_OUTPUT_PROPERTIES } from '@/tools/peopledatalabs/types'
+import {
+  PDL_CREDIT_USD,
+  PDL_PERSON_OUTPUT_PROPERTIES,
+  PEOPLEDATALABS_API_KEY_PREFIX,
+} from '@/tools/peopledatalabs/types'
 import { projectPerson } from '@/tools/peopledatalabs/utils'
 import type { ToolConfig } from '@/tools/types'
 
@@ -10,6 +14,35 @@ export const personSearchTool: ToolConfig<PdlPersonSearchParams, PdlPersonSearch
     'Search the People Data Labs person dataset using SQL or Elasticsearch DSL. Returns up to 100 matching records per call.',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: PEOPLEDATALABS_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'peopledatalabs',
+    pricing: {
+      type: 'custom',
+      // PDL Search charges 1 credit per profile returned (up to the requested size).
+      getCost: (_params, output) => {
+        const results = output.results
+        if (!Array.isArray(results)) {
+          throw new Error('PDL person search response missing results, cannot determine cost')
+        }
+        return { cost: results.length * PDL_CREDIT_USD, metadata: { credits: results.length } }
+      },
+    },
+    rateLimit: {
+      mode: 'custom',
+      requestsPerMinute: 30,
+      dimensions: [
+        {
+          name: 'credits',
+          limitPerMinute: 600,
+          extractUsage: (_params, response) =>
+            Array.isArray(response.results) ? response.results.length : 0,
+        },
+      ],
+    },
+  },
+
   params: {
     apiKey: {
       type: 'string',
diff --git a/apps/sim/tools/peopledatalabs/school_clean.ts b/apps/sim/tools/peopledatalabs/school_clean.ts
index 5ae7cc3d504..e890867a5e9 100644
--- a/apps/sim/tools/peopledatalabs/school_clean.ts
+++ b/apps/sim/tools/peopledatalabs/school_clean.ts
@@ -1,5 +1,8 @@
 import type { PdlCleanSchoolParams, PdlCleanSchoolResponse } from '@/tools/peopledatalabs/types'
-import { PDL_SCHOOL_OUTPUT_PROPERTIES } from '@/tools/peopledatalabs/types'
+import {
+  PDL_SCHOOL_OUTPUT_PROPERTIES,
+  PEOPLEDATALABS_API_KEY_PREFIX,
+} from '@/tools/peopledatalabs/types'
 import { projectSchool } from '@/tools/peopledatalabs/utils'
 import type { ToolConfig } from '@/tools/types'
 
@@ -10,6 +13,18 @@ export const cleanSchoolTool: ToolConfig<PdlCleanSchoolParams, PdlCleanSchoolRes
     'Normalize a school string into a canonical school record. Provide at least one of name, website, or profile (LinkedIn URL).',
   version: '1.0.0',
 
+  hosting: {
+    envKeyPrefix: PEOPLEDATALABS_API_KEY_PREFIX,
+    apiKeyParam: 'apiKey',
+    byokProviderId: 'peopledatalabs',
+    // Cleaner APIs are free on PDL (rate-limited only) — no credits consumed.
+    pricing: { type: 'per_request', cost: 0 },
+    rateLimit: {
+      mode: 'per_request',
+      requestsPerMinute: 60,
+    },
+  },
+
   params: {
     apiKey: {
       type: 'string',
diff --git a/apps/sim/tools/peopledatalabs/types.ts b/apps/sim/tools/peopledatalabs/types.ts
index 261a2c15d12..37f800afae9 100644
--- a/apps/sim/tools/peopledatalabs/types.ts
+++ b/apps/sim/tools/peopledatalabs/types.ts
@@ -1,5 +1,24 @@
 import type { OutputProperty, ToolResponse } from '@/tools/types'
 
+/**
+ * Env var prefix for Sim-hosted People Data Labs keys.
+ * Resolved at runtime as `PEOPLEDATALABS_API_KEY_COUNT` + `PEOPLEDATALABS_API_KEY_1..N`.
+ */
+export const PEOPLEDATALABS_API_KEY_PREFIX = 'PEOPLEDATALABS_API_KEY'
+
+/**
+ * Dollar cost per People Data Labs credit when billing hosted-key usage.
+ *
+ * PDL does not report credits in its responses, so cost is derived from match counts:
+ * enrich/identify consume 1 credit per matched request, search consumes 1 credit per
+ * profile returned, and bulk consumes 1 credit per matched record. Misses (HTTP 404)
+ * are not charged. Cleaner and autocomplete endpoints are free (rate-limited only).
+ *
+ * Estimate based on the self-serve Pro plan (~$0.28/credit) — see
+ * https://www.peopledatalabs.com/pricing. Tune if Sim's plan rate changes.
+ */
+export const PDL_CREDIT_USD = 0.28
+
 /**
  * Output property definitions for People Data Labs API responses.
  * Reference: https://docs.peopledatalabs.com/docs
diff --git a/apps/sim/tools/peopledatalabs/utils.ts b/apps/sim/tools/peopledatalabs/utils.ts
index bd37a47a04a..1c77f2d619d 100644
--- a/apps/sim/tools/peopledatalabs/utils.ts
+++ b/apps/sim/tools/peopledatalabs/utils.ts
@@ -5,6 +5,20 @@ import type {
   PdlSchoolRecord,
 } from '@/tools/peopledatalabs/types'
 
+/**
+ * Count matched records in a bulk enrich output `results` array.
+ * PDL charges one credit per matched record, so this drives both hosted-key
+ * cost and the post-execution credit rate-limit dimension.
+ */
+export function countBulkMatched(output: Record<string, unknown>): number {
+  const results = output.results
+  if (!Array.isArray(results)) return 0
+  return results.reduce((count, item) => {
+    const matched = (item as { matched?: unknown }).matched
+    return matched === true ? count + 1 : count
+  }, 0)
+}
+
 /**
  * Build a query string from non-empty params.
  */
diff --git a/apps/sim/tools/types.ts b/apps/sim/tools/types.ts
index 6b39f863954..b89ca98cd7e 100644
--- a/apps/sim/tools/types.ts
+++ b/apps/sim/tools/types.ts
@@ -19,6 +19,8 @@ export type BYOKProviderId =
   | 'brandfetch'
   | 'parallel_ai'
   | 'cohere'
+  | 'hunter'
+  | 'peopledatalabs'
 
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD'
 
diff --git a/bun.lock b/bun.lock
index 1371cc19e58..a1f5f4ea6db 100644
--- a/bun.lock
+++ b/bun.lock
@@ -1,5 +1,6 @@
 {
   "lockfileVersion": 1,
+  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "simstudio",
@@ -10,7 +11,7 @@
         "husky": "9.1.7",
         "json-schema-to-typescript": "15.0.4",
         "lint-staged": "16.0.0",
-        "turbo": "2.9.12",
+        "turbo": "2.9.14",
         "yaml": "^2.8.1",
       },
     },
@@ -1663,17 +1664,17 @@
 
     "@trigger.dev/sdk": ["@trigger.dev/sdk@4.4.3", "", { "dependencies": { "@opentelemetry/api": "1.9.0", "@opentelemetry/semantic-conventions": "1.36.0", "@trigger.dev/core": "4.4.3", "chalk": "^5.2.0", "cronstrue": "^2.21.0", "debug": "^4.3.4", "evt": "^2.4.13", "slug": "^6.0.0", "ulid": "^2.3.0", "uncrypto": "^0.1.3", "uuid": "^9.0.0", "ws": "^8.11.0" }, "peerDependencies": { "ai": "^4.2.0 || ^5.0.0 || ^6.0.0", "zod": "^3.0.0 || ^4.0.0" }, "optionalPeers": ["ai"] }, "sha512-ghJkak+PTBJJ9HiHMcnahJmzjsgCzYiIHu5Qj5R7I9q5LS6i7mkx169rB/tOE9HLadd4HSu3yYA5DrH4wXhZuw=="],
 
-    "@turbo/darwin-64": ["@turbo/darwin-64@2.9.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-eu3eFRmE9NjgZ0wPdRJ44l+LGSeIky+tz5ZQd8zQkw/Yqi+BM7wq+8nbabeoiVUcICi/IZweMOKl/MCmkrd1+g=="],
+    "@turbo/darwin-64": ["@turbo/darwin-64@2.9.14", "", { "os": "darwin", "cpu": "x64" }, "sha512-t7QiPflaEyBE4oayeZtSmu4mEfjgIrcNlNNl1z1dmIVPqEdtA7+CfTf8d7KXsOGPh6aNgWjKxyvQg9uGfDQF+A=="],
 
-    "@turbo/darwin-arm64": ["@turbo/darwin-arm64@2.9.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-RUkAE404z/J8NsyrUosMcBaXT6M4bRFxTQrmkDQBLQVXaC8Jl0e9bMvYDSX0GW7Ffm2m3j9y7RXgR1foeUAM9w=="],
+    "@turbo/darwin-arm64": ["@turbo/darwin-arm64@2.9.14", "", { "os": "darwin", "cpu": "arm64" }, "sha512-d23147mC9BsCPA9mJ0h/ubcpbRgcJBXbcG3+Vq7YLhjz3IXuvQsJ1UXH8f4MD76ZjJ4m/E4aRdJV+MW88CDfbw=="],
 
-    "@turbo/linux-64": ["@turbo/linux-64@2.9.12", "", { "os": "linux", "cpu": "x64" }, "sha512-InIUtH7cw/vqXNX1Gr7QgWfmw3ct08pV5CpfdEOR48z2u2rzdmpIuk00B/Q2xCb0PMWtKgiMQynfuphmEuUyTQ=="],
+    "@turbo/linux-64": ["@turbo/linux-64@2.9.14", "", { "os": "linux", "cpu": "x64" }, "sha512-P3ZKB5tuUDdDQWuAsACGUR1qv9W7BNWxdxqVJ0kZNuNNPRaVYTPPikLcp79+GiEcW3npsR+KyP38lnQiBc5aSA=="],
 
-    "@turbo/linux-arm64": ["@turbo/linux-arm64@2.9.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-lC6nD//Xh67fmJM0LKaLsg74Wry0aYrgMklpiNgCbUaMdPIOqj0A00iri3NU7Lb7pZHx8ViisgpeDKlpSgFUCA=="],
+    "@turbo/linux-arm64": ["@turbo/linux-arm64@2.9.14", "", { "os": "linux", "cpu": "arm64" }, "sha512-ZRTlzcUMrrPv9ZuDzRF9n60Ym13bKeG9jDB8WjxyLhWNzV+AJQN+zdpIk3NJYf2zQsGUm1mNar2P0elRzLw25g=="],
 
-    "@turbo/windows-64": ["@turbo/windows-64@2.9.12", "", { "os": "win32", "cpu": "x64" }, "sha512-conYri8VUl72JOdYnLDPYwzqbPcY5ECoHmo9FWoKznemhaAIilj4maHqs9Uar0aKfNoZIULniy+6iWaLtLO34A=="],
+    "@turbo/windows-64": ["@turbo/windows-64@2.9.14", "", { "os": "win32", "cpu": "x64" }, "sha512-exanwN6sIduZwykYeiTQj8kCmOhazP5WOz3bvXMcYtjhL6Z3iRWLewKrXCBq0bqwSP3iBMb/AerRCnHI4lx46A=="],
 
-    "@turbo/windows-arm64": ["@turbo/windows-arm64@2.9.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-XoR4bsg62/L/esRVcmoMESEiNZ36+YmyjYGLpoqk8nwMgXzzVjNOgX0lRSz5w/U/ajLGv3nhMsS0Q2QOdvp2AQ=="],
+    "@turbo/windows-arm64": ["@turbo/windows-arm64@2.9.14", "", { "os": "win32", "cpu": "arm64" }, "sha512-fVdCsnmYoKICsycbWuuGp6Jvi51/3G/UluFWuAUCvR8PIW5IJkAk5BM9UF8PSm0Q2IphWHFZjYEgjHsh3B9y/g=="],
 
     "@tweenjs/tween.js": ["@tweenjs/tween.js@23.1.3", "", {}, "sha512-vJmvvwFxYuGnF2axRtPYocag6Clbb5YS7kLL+SO/TeVFzHqDIWrNKYtcsPMibjDx9O+bu+psAy9NKfWklassUA=="],
 
@@ -3839,7 +3840,7 @@
 
     "tunnel-agent": ["tunnel-agent@0.6.0", "", { "dependencies": { "safe-buffer": "^5.0.1" } }, "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w=="],
 
-    "turbo": ["turbo@2.9.12", "", { "optionalDependencies": { "@turbo/darwin-64": "2.9.12", "@turbo/darwin-arm64": "2.9.12", "@turbo/linux-64": "2.9.12", "@turbo/linux-arm64": "2.9.12", "@turbo/windows-64": "2.9.12", "@turbo/windows-arm64": "2.9.12" }, "bin": { "turbo": "bin/turbo" } }, "sha512-lCPgus1NuTiBdaITWqzSH/Ff6HVL8HHGBtOXHg1dHRfcshN79XkygSdh0M6g8b0td91ILLG5MTkLOkp5UvyPJw=="],
+    "turbo": ["turbo@2.9.14", "", { "optionalDependencies": { "@turbo/darwin-64": "2.9.14", "@turbo/darwin-arm64": "2.9.14", "@turbo/linux-64": "2.9.14", "@turbo/linux-arm64": "2.9.14", "@turbo/windows-64": "2.9.14", "@turbo/windows-arm64": "2.9.14" }, "bin": { "turbo": "bin/turbo" } }, "sha512-BQqXRr4UoWI3UPFrtznCLykYHxwxWh53iCB57x092jPMjIlW1wnm3N895g5irpiXmnxUhREBB0n6+y8BHhs4nw=="],
 
     "tweetnacl": ["tweetnacl@0.14.5", "", {}, "sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA=="],
 
diff --git a/package.json b/package.json
index d587cebb54a..1b95ca0f8dd 100644
--- a/package.json
+++ b/package.json
@@ -64,7 +64,7 @@
     "husky": "9.1.7",
     "json-schema-to-typescript": "15.0.4",
     "lint-staged": "16.0.0",
-    "turbo": "2.9.12",
+    "turbo": "2.9.14",
     "yaml": "^2.8.1"
   },
   "lint-staged": {
diff --git a/scripts/check-api-validation-contracts.ts b/scripts/check-api-validation-contracts.ts
index 0fbe9d4077a..b3c105ab531 100644
--- a/scripts/check-api-validation-contracts.ts
+++ b/scripts/check-api-validation-contracts.ts
@@ -9,8 +9,8 @@ const QUERY_HOOKS_DIR = path.join(ROOT, 'apps/sim/hooks/queries')
 const SELECTOR_HOOKS_DIR = path.join(ROOT, 'apps/sim/hooks/selectors')
 
 const BASELINE = {
-  totalRoutes: 755,
-  zodRoutes: 755,
+  totalRoutes: 756,
+  zodRoutes: 756,
   nonZodRoutes: 0,
 } as const