diff --git a/apps/sim/app/api/workspaces/route.ts b/apps/sim/app/api/workspaces/route.ts
index e6aac33f5e..cb7db1ba04 100644
--- a/apps/sim/app/api/workspaces/route.ts
+++ b/apps/sim/app/api/workspaces/route.ts
@@ -104,7 +104,7 @@ async function createWorkspace(userId: string, name: string) {
         updatedAt: now,
       })
 
-      // Create "Workflow 1" for the workspace with start block
+      // Create initial workflow for the workspace with start block
       const starterId = crypto.randomUUID()
       const initialState = {
         blocks: {
@@ -170,7 +170,7 @@ async function createWorkspace(userId: string, name: string) {
         userId,
         workspaceId,
         folderId: null,
-        name: 'Workflow 1',
+        name: 'default-agent',
         description: 'Your first workflow - start building here!',
         state: initialState,
         color: '#3972F6',
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/components/sub-block/components/schedule/schedule-config.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/components/sub-block/components/schedule/schedule-config.tsx
index 9b9c58f6d1..65870360d8 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/components/sub-block/components/schedule/schedule-config.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/components/sub-block/components/schedule/schedule-config.tsx
@@ -26,10 +26,10 @@ interface ScheduleConfigProps {
 
 export function ScheduleConfig({
   blockId,
-  subBlockId,
+  subBlockId: _subBlockId,
   isConnecting,
   isPreview = false,
-  previewValue,
+  previewValue: _previewValue,
   disabled = false,
 }: ScheduleConfigProps) {
   const [error, setError] = useState<string | null>(null)
@@ -56,13 +56,7 @@ export function ScheduleConfig({
 
   // Get the startWorkflow value to determine if scheduling is enabled
   // and expose the setter so we can update it
-  const [startWorkflow, setStartWorkflow] = useSubBlockValue(blockId, 'startWorkflow')
-  const isScheduleEnabled = startWorkflow === 'schedule'
-
-  const [storeValue, setStoreValue] = useSubBlockValue(blockId, subBlockId)
-
-  // Use preview value when in preview mode, otherwise use store value
-  const value = isPreview ? previewValue : storeValue
+  const [_startWorkflow, setStartWorkflow] = useSubBlockValue(blockId, 'startWorkflow')
 
   // Function to check if schedule exists in the database
   const checkSchedule = async () => {
@@ -110,10 +104,17 @@ export function ScheduleConfig({
 
   // Check for schedule on mount and when relevant dependencies change
   useEffect(() => {
-    // Always check for schedules regardless of the UI setting
-    // This ensures we detect schedules even when the UI is set to manual
-    checkSchedule()
-  }, [workflowId, scheduleType, isModalOpen, refreshCounter])
+    // Only check for schedules when workflowId changes or modal opens
+    // Avoid checking on every scheduleType change to prevent excessive API calls
+    if (workflowId && (isModalOpen || refreshCounter > 0)) {
+      checkSchedule()
+    }
+
+    // Cleanup function to reset loading state
+    return () => {
+      setIsLoading(false)
+    }
+  }, [workflowId, isModalOpen, refreshCounter])
 
   // Format the schedule information for display
   const getScheduleInfo = () => {
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/workflow-block.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/workflow-block.tsx
index 01460ceef2..9812ed5b5d 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/workflow-block.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/workflow-block.tsx
@@ -1,5 +1,6 @@
 import { useEffect, useRef, useState } from 'react'
 import { BookOpen, Code, Info, RectangleHorizontal, RectangleVertical } from 'lucide-react'
+import { useParams } from 'next/navigation'
 import { Handle, type NodeProps, Position, useUpdateNodeInternals } from 'reactflow'
 import { Badge } from '@/components/ui/badge'
 import { Button } from '@/components/ui/button'
@@ -83,6 +84,11 @@ export function WorkflowBlock({ id, data }: NodeProps<WorkflowBlockProps>) {
   const isActiveBlock = useExecutionStore((state) => state.activeBlockIds.has(id))
   const isActive = dataIsActive || isActiveBlock
 
+  // Get the current workflow ID from URL params instead of global state
+  // This prevents race conditions when switching workflows rapidly
+  const params = useParams()
+  const currentWorkflowId = params.workflowId as string
+
   const reactivateSchedule = async (scheduleId: string) => {
     try {
       const response = await fetch(`/api/schedules/${scheduleId}`, {
@@ -94,7 +100,10 @@ export function WorkflowBlock({ id, data }: NodeProps<WorkflowBlockProps>) {
       })
 
       if (response.ok) {
-        fetchScheduleInfo()
+        // Use the current workflow ID from params instead of global state
+        if (currentWorkflowId) {
+          fetchScheduleInfo(currentWorkflowId)
+        }
       } else {
         console.error('Failed to reactivate schedule')
       }
@@ -103,11 +112,11 @@ export function WorkflowBlock({ id, data }: NodeProps<WorkflowBlockProps>) {
     }
   }
 
-  const fetchScheduleInfo = async () => {
+  const fetchScheduleInfo = async (workflowId: string) => {
+    if (!workflowId) return
+
     try {
       setIsLoadingScheduleInfo(true)
-      const workflowId = useWorkflowRegistry.getState().activeWorkflowId
-      if (!workflowId) return
 
       const response = await fetch(`/api/schedules?workflowId=${workflowId}&mode=schedule`, {
         cache: 'no-store',
@@ -176,12 +185,18 @@ export function WorkflowBlock({ id, data }: NodeProps<WorkflowBlockProps>) {
   }
 
   useEffect(() => {
-    if (type === 'starter') {
-      fetchScheduleInfo()
+    if (type === 'starter' && currentWorkflowId) {
+      fetchScheduleInfo(currentWorkflowId)
     } else {
       setScheduleInfo(null)
+      setIsLoadingScheduleInfo(false) // Reset loading state when not a starter block
+    }
+
+    // Cleanup function to reset loading state when component unmounts or workflow changes
+    return () => {
+      setIsLoadingScheduleInfo(false)
     }
-  }, [type])
+  }, [type, currentWorkflowId])
 
   // Get webhook information for the tooltip
   useEffect(() => {
diff --git a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/create-menu/create-menu.tsx b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/create-menu/create-menu.tsx
index 188ee91ea8..1ccb647469 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/create-menu/create-menu.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/create-menu/create-menu.tsx
@@ -15,9 +15,14 @@ import { useFolderStore } from '@/stores/folders/store'
 interface CreateMenuProps {
   onCreateWorkflow: (folderId?: string) => void
   isCollapsed?: boolean
+  isCreatingWorkflow?: boolean
 }
 
-export function CreateMenu({ onCreateWorkflow, isCollapsed }: CreateMenuProps) {
+export function CreateMenu({
+  onCreateWorkflow,
+  isCollapsed,
+  isCreatingWorkflow = false,
+}: CreateMenuProps) {
   const [showFolderDialog, setShowFolderDialog] = useState(false)
   const [folderName, setFolderName] = useState('')
   const [isCreating, setIsCreating] = useState(false)
@@ -73,6 +78,7 @@ export function CreateMenu({ onCreateWorkflow, isCollapsed }: CreateMenuProps) {
             onClick={handleCreateWorkflow}
             onMouseEnter={() => setIsHoverOpen(true)}
             onMouseLeave={() => setIsHoverOpen(false)}
+            disabled={isCreatingWorkflow}
           >
             <Plus
               className={cn(
@@ -101,11 +107,17 @@ export function CreateMenu({ onCreateWorkflow, isCollapsed }: CreateMenuProps) {
           onCloseAutoFocus={(e) => e.preventDefault()}
         >
           <button
-            className='flex w-full cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none transition-colors hover:bg-accent hover:text-accent-foreground'
+            className={cn(
+              'flex w-full cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none transition-colors',
+              isCreatingWorkflow
+                ? 'cursor-not-allowed opacity-50'
+                : 'hover:bg-accent hover:text-accent-foreground'
+            )}
             onClick={handleCreateWorkflow}
+            disabled={isCreatingWorkflow}
           >
             <File className='h-4 w-4' />
-            New Workflow
+            {isCreatingWorkflow ? 'Creating...' : 'New Workflow'}
           </button>
           <button
             className='flex w-full cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none transition-colors hover:bg-accent hover:text-accent-foreground'
diff --git a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
index 4cf0d8eedf..568d8dd272 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx
@@ -41,6 +41,9 @@ export function Sidebar() {
   const { isPending: sessionLoading } = useSession()
   const userPermissions = useUserPermissionsContext()
   const isLoading = workflowsLoading || sessionLoading
+
+  // Add state to prevent multiple simultaneous workflow creations
+  const [isCreatingWorkflow, setIsCreatingWorkflow] = useState(false)
   const router = useRouter()
   const params = useParams()
   const workspaceId = params.workspaceId as string
@@ -108,7 +111,14 @@ export function Sidebar() {
 
   // Create workflow handler
   const handleCreateWorkflow = async (folderId?: string) => {
+    // Prevent multiple simultaneous workflow creations
+    if (isCreatingWorkflow) {
+      logger.info('Workflow creation already in progress, ignoring request')
+      return
+    }
+
     try {
+      setIsCreatingWorkflow(true)
       const id = await createWorkflow({
         workspaceId: workspaceId || undefined,
         folderId: folderId || undefined,
@@ -116,6 +126,8 @@ export function Sidebar() {
       router.push(`/workspace/${workspaceId}/w/${id}`)
     } catch (error) {
       logger.error('Error creating workflow:', error)
+    } finally {
+      setIsCreatingWorkflow(false)
     }
   }
 
@@ -173,7 +185,11 @@ export function Sidebar() {
               {isLoading ? <Skeleton className='h-4 w-16' /> : 'Workflows'}
             </h2>
             {!isCollapsed && !isLoading && (
-              <CreateMenu onCreateWorkflow={handleCreateWorkflow} isCollapsed={false} />
+              <CreateMenu
+                onCreateWorkflow={handleCreateWorkflow}
+                isCollapsed={false}
+                isCreatingWorkflow={isCreatingWorkflow}
+              />
             )}
           </div>
           <FolderTree
diff --git a/apps/sim/stores/workflows/registry/store.ts b/apps/sim/stores/workflows/registry/store.ts
index 5ffd0dd0ee..fee3d6da31 100644
--- a/apps/sim/stores/workflows/registry/store.ts
+++ b/apps/sim/stores/workflows/registry/store.ts
@@ -557,9 +557,6 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
        * @returns The ID of the newly created workflow
        */
       createWorkflow: async (options = {}) => {
-        const { workflows } = get()
-        const id = crypto.randomUUID()
-
         // Use provided workspace ID (must be provided since we no longer track active workspace)
         const workspaceId = options.workspaceId
 
@@ -570,292 +567,259 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
         }
 
         logger.info(`Creating new workflow in workspace: ${workspaceId || 'none'}`)
-        // Generate workflow metadata with appropriate name and color
-        const newWorkflow: WorkflowMetadata = {
-          id,
-          name: options.name || generateUniqueName(workflows),
-          lastModified: new Date(),
-          description: options.description || 'New workflow',
-          color: options.marketplaceId ? '#808080' : getNextWorkflowColor(workflows), // Gray for marketplace imports
-          marketplaceData: options.marketplaceId
-            ? { id: options.marketplaceId, status: 'temp' as const }
-            : undefined,
-          workspaceId, // Associate with workspace
-          folderId: options.folderId || null, // Associate with folder if provided
-        }
 
-        let initialState: any
+        // Create the workflow on the server first to get the server-generated ID
+        try {
+          const response = await fetch('/api/workflows', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              name: options.name || generateUniqueName(),
+              description: options.description || 'New workflow',
+              color: options.marketplaceId ? '#808080' : getNextWorkflowColor(),
+              workspaceId,
+              folderId: options.folderId || null,
+            }),
+          })
 
-        // If this is a marketplace import with existing state
-        if (options.marketplaceId && options.marketplaceState) {
-          initialState = {
-            blocks: options.marketplaceState.blocks || {},
-            edges: options.marketplaceState.edges || [],
-            loops: options.marketplaceState.loops || {},
-            parallels: options.marketplaceState.parallels || {},
-            isDeployed: false,
-            deployedAt: undefined,
-            deploymentStatuses: {}, // Initialize empty deployment statuses map
-            workspaceId, // Include workspace ID in the state object
-            history: {
-              past: [],
-              present: {
-                state: {
-                  blocks: options.marketplaceState.blocks || {},
-                  edges: options.marketplaceState.edges || [],
-                  loops: options.marketplaceState.loops || {},
-                  parallels: options.marketplaceState.parallels || {},
-                  isDeployed: false,
-                  deployedAt: undefined,
-                  workspaceId, // Include workspace ID in history
-                },
-                timestamp: Date.now(),
-                action: 'Imported from marketplace',
-                subblockValues: {},
-              },
-              future: [],
-            },
-            lastSaved: Date.now(),
+          if (!response.ok) {
+            const errorData = await response.json()
+            throw new Error(`Failed to create workflow: ${errorData.error || response.statusText}`)
           }
 
-          logger.info(`Created workflow from marketplace: ${options.marketplaceId}`)
-        } else {
-          // Create starter block for new workflow
-          const starterId = crypto.randomUUID()
-          const starterBlock = {
-            id: starterId,
-            type: 'starter' as const,
-            name: 'Start',
-            position: { x: 100, y: 100 },
-            subBlocks: {
-              startWorkflow: {
-                id: 'startWorkflow',
-                type: 'dropdown' as const,
-                value: 'manual',
-              },
-              webhookPath: {
-                id: 'webhookPath',
-                type: 'short-input' as const,
-                value: '',
-              },
-              webhookSecret: {
-                id: 'webhookSecret',
-                type: 'short-input' as const,
-                value: '',
-              },
-              scheduleType: {
-                id: 'scheduleType',
-                type: 'dropdown' as const,
-                value: 'daily',
-              },
-              minutesInterval: {
-                id: 'minutesInterval',
-                type: 'short-input' as const,
-                value: '',
-              },
-              minutesStartingAt: {
-                id: 'minutesStartingAt',
-                type: 'short-input' as const,
-                value: '',
-              },
-              hourlyMinute: {
-                id: 'hourlyMinute',
-                type: 'short-input' as const,
-                value: '',
-              },
-              dailyTime: {
-                id: 'dailyTime',
-                type: 'short-input' as const,
-                value: '',
-              },
-              weeklyDay: {
-                id: 'weeklyDay',
-                type: 'dropdown' as const,
-                value: 'MON',
-              },
-              weeklyDayTime: {
-                id: 'weeklyDayTime',
-                type: 'short-input' as const,
-                value: '',
-              },
-              monthlyDay: {
-                id: 'monthlyDay',
-                type: 'short-input' as const,
-                value: '',
-              },
-              monthlyTime: {
-                id: 'monthlyTime',
-                type: 'short-input' as const,
-                value: '',
-              },
-              cronExpression: {
-                id: 'cronExpression',
-                type: 'short-input' as const,
-                value: '',
+          const createdWorkflow = await response.json()
+          const serverWorkflowId = createdWorkflow.id
+
+          logger.info(`Successfully created workflow ${serverWorkflowId} on server`)
+
+          // Generate workflow metadata with server-generated ID
+          const newWorkflow: WorkflowMetadata = {
+            id: serverWorkflowId,
+            name: createdWorkflow.name,
+            lastModified: new Date(),
+            description: createdWorkflow.description,
+            color: createdWorkflow.color,
+            marketplaceData: options.marketplaceId
+              ? { id: options.marketplaceId, status: 'temp' as const }
+              : undefined,
+            workspaceId,
+            folderId: createdWorkflow.folderId,
+          }
+
+          let initialState: any
+
+          // If this is a marketplace import with existing state
+          if (options.marketplaceId && options.marketplaceState) {
+            initialState = {
+              blocks: options.marketplaceState.blocks || {},
+              edges: options.marketplaceState.edges || [],
+              loops: options.marketplaceState.loops || {},
+              parallels: options.marketplaceState.parallels || {},
+              isDeployed: false,
+              deployedAt: undefined,
+              deploymentStatuses: {}, // Initialize empty deployment statuses map
+              workspaceId, // Include workspace ID in the state object
+              history: {
+                past: [],
+                present: {
+                  state: {
+                    blocks: options.marketplaceState.blocks || {},
+                    edges: options.marketplaceState.edges || [],
+                    loops: options.marketplaceState.loops || {},
+                    parallels: options.marketplaceState.parallels || {},
+                    isDeployed: false,
+                    deployedAt: undefined,
+                    workspaceId, // Include workspace ID in history
+                  },
+                  timestamp: Date.now(),
+                  action: 'Imported from marketplace',
+                  subblockValues: {},
+                },
+                future: [],
               },
-              timezone: {
-                id: 'timezone',
-                type: 'dropdown' as const,
-                value: 'UTC',
+              lastSaved: Date.now(),
+            }
+
+            logger.info(`Created workflow from marketplace: ${options.marketplaceId}`)
+          } else {
+            // Create starter block for new workflow
+            const starterId = crypto.randomUUID()
+            const starterBlock = {
+              id: starterId,
+              type: 'starter' as const,
+              name: 'Start',
+              position: { x: 100, y: 100 },
+              subBlocks: {
+                startWorkflow: {
+                  id: 'startWorkflow',
+                  type: 'dropdown' as const,
+                  value: 'manual',
+                },
+                webhookPath: {
+                  id: 'webhookPath',
+                  type: 'short-input' as const,
+                  value: '',
+                },
+                webhookSecret: {
+                  id: 'webhookSecret',
+                  type: 'short-input' as const,
+                  value: '',
+                },
+                scheduleType: {
+                  id: 'scheduleType',
+                  type: 'dropdown' as const,
+                  value: 'daily',
+                },
+                minutesInterval: {
+                  id: 'minutesInterval',
+                  type: 'short-input' as const,
+                  value: '',
+                },
+                minutesStartingAt: {
+                  id: 'minutesStartingAt',
+                  type: 'short-input' as const,
+                  value: '',
+                },
+                hourlyMinute: {
+                  id: 'hourlyMinute',
+                  type: 'short-input' as const,
+                  value: '',
+                },
+                dailyTime: {
+                  id: 'dailyTime',
+                  type: 'short-input' as const,
+                  value: '',
+                },
+                weeklyDay: {
+                  id: 'weeklyDay',
+                  type: 'dropdown' as const,
+                  value: 'MON',
+                },
+                weeklyDayTime: {
+                  id: 'weeklyDayTime',
+                  type: 'short-input' as const,
+                  value: '',
+                },
+                monthlyDay: {
+                  id: 'monthlyDay',
+                  type: 'short-input' as const,
+                  value: '',
+                },
+                monthlyTime: {
+                  id: 'monthlyTime',
+                  type: 'short-input' as const,
+                  value: '',
+                },
+                cronExpression: {
+                  id: 'cronExpression',
+                  type: 'short-input' as const,
+                  value: '',
+                },
+                timezone: {
+                  id: 'timezone',
+                  type: 'dropdown' as const,
+                  value: 'UTC',
+                },
               },
-            },
-            outputs: {
-              response: {
-                type: {
-                  input: 'any',
+              outputs: {
+                response: {
+                  type: {
+                    input: 'any',
+                  },
                 },
               },
-            },
-            enabled: true,
-            horizontalHandles: true,
-            isWide: false,
-            height: 0,
-          }
+              enabled: true,
+              horizontalHandles: true,
+              isWide: false,
+              height: 0,
+            }
 
-          initialState = {
-            blocks: {
-              [starterId]: starterBlock,
-            },
-            edges: [],
-            loops: {},
-            parallels: {},
-            isDeployed: false,
-            deployedAt: undefined,
-            deploymentStatuses: {}, // Initialize empty deployment statuses map
-            workspaceId, // Include workspace ID in the state object
-            history: {
-              past: [],
-              present: {
-                state: {
-                  blocks: {
-                    [starterId]: starterBlock,
+            initialState = {
+              blocks: {
+                [starterId]: starterBlock,
+              },
+              edges: [],
+              loops: {},
+              parallels: {},
+              isDeployed: false,
+              deployedAt: undefined,
+              deploymentStatuses: {}, // Initialize empty deployment statuses map
+              workspaceId, // Include workspace ID in the state object
+              history: {
+                past: [],
+                present: {
+                  state: {
+                    blocks: {
+                      [starterId]: starterBlock,
+                    },
+                    edges: [],
+                    loops: {},
+                    parallels: {},
+                    isDeployed: false,
+                    deployedAt: undefined,
+                    workspaceId, // Include workspace ID in history
                   },
-                  edges: [],
-                  loops: {},
-                  parallels: {},
-                  isDeployed: false,
-                  deployedAt: undefined,
-                  workspaceId, // Include workspace ID in history
+                  timestamp: Date.now(),
+                  action: 'Initial state',
+                  subblockValues: {},
                 },
-                timestamp: Date.now(),
-                action: 'Initial state',
-                subblockValues: {},
+                future: [],
               },
-              future: [],
-            },
-            lastSaved: Date.now(),
-          }
-        }
-
-        // Add workflow to registry first
-        set((state) => ({
-          workflows: {
-            ...state.workflows,
-            [id]: newWorkflow,
-          },
-          error: null,
-        }))
-
-        // Initialize subblock values if this is a marketplace import
-        if (options.marketplaceId && options.marketplaceState?.blocks) {
-          useSubBlockStore.getState().initializeFromWorkflow(id, options.marketplaceState.blocks)
-        }
-
-        // Initialize subblock values to ensure they're available for sync
-        if (!options.marketplaceId) {
-          // For non-marketplace workflows, initialize subblock values from the starter block
-          const subblockValues: Record<string, Record<string, any>> = {}
-          const blocks = initialState.blocks as Record<string, BlockState>
-          for (const [blockId, block] of Object.entries(blocks)) {
-            subblockValues[blockId] = {}
-            for (const [subblockId, subblock] of Object.entries(block.subBlocks)) {
-              subblockValues[blockId][subblockId] = (subblock as any).value
+              lastSaved: Date.now(),
             }
           }
 
-          // Update the subblock store with the initial values
-          useSubBlockStore.setState((state) => ({
-            workflowValues: {
-              ...state.workflowValues,
-              [id]: subblockValues,
+          // Add workflow to registry with server-generated ID
+          set((state) => ({
+            workflows: {
+              ...state.workflows,
+              [serverWorkflowId]: newWorkflow,
             },
+            error: null,
           }))
-        }
 
-        // Properly set as active workflow and initialize state
-        set({ activeWorkflowId: id })
-        useWorkflowStore.setState(initialState)
-
-        // Immediately persist the new workflow to the database using dedicated endpoint
-        const persistWorkflow = async () => {
-          try {
-            const response = await fetch('/api/workflows', {
-              method: 'POST',
-              headers: { 'Content-Type': 'application/json' },
-              body: JSON.stringify({
-                name: newWorkflow.name,
-                description: newWorkflow.description,
-                color: newWorkflow.color,
-                workspaceId: newWorkflow.workspaceId,
-                folderId: newWorkflow.folderId,
-              }),
-            })
-
-            if (!response.ok) {
-              const errorData = await response.json()
-              throw new Error(
-                `Failed to create workflow: ${errorData.error || response.statusText}`
-              )
-            }
-
-            const createdWorkflow = await response.json()
-            logger.info(`Successfully created workflow ${createdWorkflow.id} on server`)
-
-            // Update the local workflow ID to match the server-generated one
-            if (createdWorkflow.id !== id) {
-              logger.info(`Updating local workflow ID from ${id} to ${createdWorkflow.id}`)
-
-              // Update registry with server ID
-              set((state) => {
-                const { [id]: oldWorkflow, ...otherWorkflows } = state.workflows
-                return {
-                  workflows: {
-                    ...otherWorkflows,
-                    [createdWorkflow.id]: {
-                      ...oldWorkflow,
-                      id: createdWorkflow.id,
-                    },
-                  },
-                  activeWorkflowId: createdWorkflow.id,
-                }
-              })
+          // Initialize subblock values if this is a marketplace import
+          if (options.marketplaceId && options.marketplaceState?.blocks) {
+            useSubBlockStore
+              .getState()
+              .initializeFromWorkflow(serverWorkflowId, options.marketplaceState.blocks)
+          }
 
-              // Return the server ID for the caller
-              return createdWorkflow.id
+          // Initialize subblock values to ensure they're available for sync
+          if (!options.marketplaceId) {
+            // For non-marketplace workflows, initialize subblock values from the starter block
+            const subblockValues: Record<string, Record<string, any>> = {}
+            const blocks = initialState.blocks as Record<string, BlockState>
+            for (const [blockId, block] of Object.entries(blocks)) {
+              subblockValues[blockId] = {}
+              for (const [subblockId, subblock] of Object.entries(block.subBlocks)) {
+                subblockValues[blockId][subblockId] = (subblock as any).value
+              }
             }
 
-            return id
-          } catch (error) {
-            logger.error(`Failed to create new workflow ${id}:`, error)
-            throw error // Re-throw to handle in calling code
+            // Update the subblock store with the initial values
+            useSubBlockStore.setState((state) => ({
+              workflowValues: {
+                ...state.workflowValues,
+                [serverWorkflowId]: subblockValues,
+              },
+            }))
           }
-        }
 
-        // Persist synchronously to ensure workflow exists before Socket.IO operations
-        let finalId = id
-        try {
-          finalId = await persistWorkflow()
-        } catch (error) {
-          logger.error(
-            `Critical: Failed to persist new workflow ${id}, Socket.IO operations may fail:`,
-            error
+          // Don't set as active workflow here - let the navigation/URL change handle that
+          // This prevents race conditions and flickering
+          logger.info(
+            `Created new workflow with ID ${serverWorkflowId} in workspace ${workspaceId || 'none'}`
           )
-          // Don't throw - allow workflow creation to continue in memory
-        }
-
-        logger.info(`Created new workflow with ID ${finalId} in workspace ${workspaceId || 'none'}`)
 
-        return finalId
+          return serverWorkflowId
+        } catch (error) {
+          logger.error(`Failed to create new workflow:`, error)
+          set({
+            error: `Failed to create workflow: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          })
+          throw error
+        }
       },
 
       /**
@@ -866,16 +830,15 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
         state: any,
         metadata: Partial<WorkflowMetadata>
       ) => {
-        const { workflows } = get()
         const id = crypto.randomUUID()
 
         // Generate workflow metadata with marketplace properties
         const newWorkflow: WorkflowMetadata = {
           id,
-          name: metadata.name || 'Marketplace workflow',
+          name: metadata.name || generateUniqueName(),
           lastModified: new Date(),
           description: metadata.description || 'Imported from marketplace',
-          color: metadata.color || getNextWorkflowColor(workflows),
+          color: metadata.color || getNextWorkflowColor(),
           marketplaceData: { id: marketplaceId, status: 'temp' as const },
         }
 
@@ -1031,7 +994,7 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
           name: `${sourceWorkflow.name} (Copy)`,
           lastModified: new Date(),
           description: sourceWorkflow.description,
-          color: getNextWorkflowColor(workflows),
+          color: getNextWorkflowColor(),
           workspaceId, // Include the workspaceId in the new workflow
           folderId: sourceWorkflow.folderId, // Include the folderId from source workflow
           // Do not copy marketplace data
diff --git a/apps/sim/stores/workflows/registry/utils.ts b/apps/sim/stores/workflows/registry/utils.ts
index d6812f109d..fd41d21a75 100644
--- a/apps/sim/stores/workflows/registry/utils.ts
+++ b/apps/sim/stores/workflows/registry/utils.ts
@@ -1,62 +1,247 @@
-import type { WorkflowMetadata } from './types'
-
 // Available workflow colors
 export const WORKFLOW_COLORS = [
-  '#3972F6',
-  '#F639DD',
-  '#F6B539',
-  '#8139F6',
-  '#39B54A',
-  '#39B5AB',
-  '#F66839',
-]
+  // Original colors
+  '#3972F6', // Blue
+  '#F639DD', // Pink/Magenta
+  '#F6B539', // Orange/Yellow
+  '#8139F6', // Purple
+  '#39B54A', // Green
+  '#39B5AB', // Teal
+  '#F66839', // Red/Orange
 
-// Generates a unique name for a new workflow
-export function generateUniqueName(existingWorkflows: Record<string, WorkflowMetadata>): string {
-  // Extract numbers from existing workflow names using regex
-  const numbers = Object.values(existingWorkflows)
-    .map((w) => {
-      const match = w.name.match(/Workflow (\d+)/)
-      return match ? Number.parseInt(match[1]) : 0
-    })
-    .filter((n) => n > 0)
-
-  if (numbers.length === 0) {
-    return 'Workflow 1'
-  }
-
-  // Find the maximum number and add 1
-  const nextNumber = Math.max(...numbers) + 1
-  return `Workflow ${nextNumber}`
-}
+  // Additional vibrant blues
+  '#2E5BFF', // Bright Blue
+  '#4A90FF', // Sky Blue
+  '#1E40AF', // Deep Blue
+  '#0EA5E9', // Cyan Blue
+  '#3B82F6', // Royal Blue
+  '#6366F1', // Indigo
+  '#1D4ED8', // Electric Blue
 
-// Determines the next color to use for a new workflow based on the color of the newest workflow
-export function getNextWorkflowColor(existingWorkflows: Record<string, WorkflowMetadata>): string {
-  const workflowArray = Object.values(existingWorkflows)
+  // Additional vibrant purples
+  '#A855F7', // Bright Purple
+  '#C084FC', // Light Purple
+  '#7C3AED', // Deep Purple
+  '#9333EA', // Violet
+  '#8B5CF6', // Medium Purple
+  '#6D28D9', // Dark Purple
+  '#5B21B6', // Deep Violet
 
-  if (workflowArray.length === 0) {
-    return WORKFLOW_COLORS[0]
-  }
+  // Additional vibrant pinks/magentas
+  '#EC4899', // Hot Pink
+  '#F97316', // Pink Orange
+  '#E11D48', // Rose
+  '#BE185D', // Deep Pink
+  '#DB2777', // Pink Red
+  '#F472B6', // Light Pink
+  '#F59E0B', // Amber Pink
 
-  // Sort workflows by lastModified date (newest first)
-  const sortedWorkflows = [...workflowArray].sort((a, b) => {
-    const dateA =
-      a.lastModified instanceof Date ? a.lastModified.getTime() : new Date(a.lastModified).getTime()
-    const dateB =
-      b.lastModified instanceof Date ? b.lastModified.getTime() : new Date(b.lastModified).getTime()
-    return dateB - dateA
-  })
+  // Additional vibrant greens
+  '#10B981', // Emerald
+  '#059669', // Green Teal
+  '#16A34A', // Forest Green
+  '#22C55E', // Lime Green
+  '#84CC16', // Yellow Green
+  '#65A30D', // Olive Green
+  '#15803D', // Dark Green
 
-  // Get the newest workflow (first in sorted array)
-  const newestWorkflow = sortedWorkflows[0]
+  // Additional vibrant teals/cyans
+  '#06B6D4', // Cyan
+  '#0891B2', // Dark Cyan
+  '#0E7490', // Teal Blue
+  '#14B8A6', // Turquoise
+  '#0D9488', // Dark Teal
+  '#047857', // Sea Green
+  '#059669', // Mint Green
 
-  // Find the index of the newest workflow's color, defaulting to -1 if undefined
-  const currentColorIndex = newestWorkflow?.color
-    ? WORKFLOW_COLORS.indexOf(newestWorkflow.color)
-    : -1
+  // Additional vibrant oranges/reds
+  '#EA580C', // Bright Orange
+  '#DC2626', // Red
+  '#B91C1C', // Dark Red
+  '#EF4444', // Light Red
+  '#F97316', // Orange
+  '#FB923C', // Light Orange
+  '#FDBA74', // Peach
+
+  // Additional vibrant yellows/golds
+  '#FBBF24', // Gold
+  '#F59E0B', // Amber
+  '#D97706', // Dark Amber
+  '#92400E', // Bronze
+  '#EAB308', // Yellow
+  '#CA8A04', // Dark Yellow
+  '#A16207', // Mustard
+
+  // Additional unique vibrant colors
+  '#FF6B6B', // Coral
+  '#4ECDC4', // Mint
+  '#45B7D1', // Light Blue
+  '#96CEB4', // Sage
+  '#FFEAA7', // Cream
+  '#DDA0DD', // Plum
+  '#98D8C8', // Seafoam
+  '#F7DC6F', // Banana
+  '#BB8FCE', // Lavender
+  '#85C1E9', // Baby Blue
+  '#F8C471', // Peach
+  '#82E0AA', // Light Green
+  '#F1948A', // Salmon
+  '#D7BDE2', // Lilac
+  '#D7BDE2', // Lilac
+]
 
-  // Get next color index, wrapping around to 0 if we reach the end
-  const nextColorIndex = (currentColorIndex + 1) % WORKFLOW_COLORS.length
+// Random adjectives and nouns for generating creative workflow names
+const ADJECTIVES = [
+  'Blazing',
+  'Crystal',
+  'Golden',
+  'Silver',
+  'Mystic',
+  'Cosmic',
+  'Electric',
+  'Frozen',
+  'Burning',
+  'Shining',
+  'Dancing',
+  'Flying',
+  'Roaring',
+  'Whispering',
+  'Glowing',
+  'Sparkling',
+  'Thunder',
+  'Lightning',
+  'Storm',
+  'Ocean',
+  'Mountain',
+  'Forest',
+  'Desert',
+  'Arctic',
+  'Tropical',
+  'Midnight',
+  'Dawn',
+  'Sunset',
+  'Rainbow',
+  'Diamond',
+  'Ruby',
+  'Emerald',
+  'Sapphire',
+  'Pearl',
+  'Jade',
+  'Amber',
+  'Coral',
+  'Ivory',
+  'Obsidian',
+  'Marble',
+  'Velvet',
+  'Silk',
+  'Satin',
+  'Linen',
+  'Cotton',
+  'Wool',
+  'Cashmere',
+  'Denim',
+  'Neon',
+  'Pastel',
+  'Vibrant',
+  'Muted',
+  'Bold',
+  'Subtle',
+  'Bright',
+  'Dark',
+]
+
+const NOUNS = [
+  'Phoenix',
+  'Dragon',
+  'Eagle',
+  'Wolf',
+  'Lion',
+  'Tiger',
+  'Panther',
+  'Falcon',
+  'Hawk',
+  'Raven',
+  'Swan',
+  'Dove',
+  'Butterfly',
+  'Firefly',
+  'Dragonfly',
+  'Hummingbird',
+  'Galaxy',
+  'Nebula',
+  'Comet',
+  'Meteor',
+  'Star',
+  'Moon',
+  'Sun',
+  'Planet',
+  'Asteroid',
+  'Constellation',
+  'Aurora',
+  'Eclipse',
+  'Solstice',
+  'Equinox',
+  'Horizon',
+  'Zenith',
+  'Castle',
+  'Tower',
+  'Bridge',
+  'Garden',
+  'Fountain',
+  'Palace',
+  'Temple',
+  'Cathedral',
+  'Lighthouse',
+  'Windmill',
+  'Waterfall',
+  'Canyon',
+  'Valley',
+  'Peak',
+  'Ridge',
+  'Cliff',
+  'Ocean',
+  'River',
+  'Lake',
+  'Stream',
+  'Pond',
+  'Bay',
+  'Cove',
+  'Harbor',
+  'Island',
+  'Peninsula',
+  'Archipelago',
+  'Atoll',
+  'Reef',
+  'Lagoon',
+  'Fjord',
+  'Delta',
+  'Cake',
+  'Cookie',
+  'Muffin',
+  'Cupcake',
+  'Pie',
+  'Tart',
+  'Brownie',
+  'Donut',
+  'Pancake',
+  'Waffle',
+  'Croissant',
+  'Bagel',
+  'Pretzel',
+  'Biscuit',
+  'Scone',
+  'Crumpet',
+]
+
+// Generates a random name for a new workflow
+export function generateUniqueName(): string {
+  const adjective = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)]
+  const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)]
+  return `${adjective.toLowerCase()}-${noun.toLowerCase()}`
+}
 
-  return WORKFLOW_COLORS[nextColorIndex]
+// Generates a random color for a new workflow
+export function getNextWorkflowColor(): string {
+  // Simply return a random color from the available colors
+  return WORKFLOW_COLORS[Math.floor(Math.random() * WORKFLOW_COLORS.length)]
 }