diff --git a/extension/src/entrypoints/background.ts b/extension/src/entrypoints/background.ts
index 19928f2..bf8d49e 100644
--- a/extension/src/entrypoints/background.ts
+++ b/extension/src/entrypoints/background.ts
@@ -6,7 +6,6 @@ import {
   StoredCustomKeyEvent,
   StoredEvent,
   StoredRrwebEvent,
-  StoredExtractionEvent,
 } from "../lib/types";
 import {
   ClickStep,
@@ -16,7 +15,6 @@ import {
   ScrollStep,
   Step,
   Workflow,
-  ExtractStep,
 } from "../lib/workflow-types";
 import {
   HttpEvent,
@@ -32,9 +30,36 @@ export default defineBackground(() => {
   // Store tab information (URL, potentially title)
   const tabInfo: { [tabId: number]: { url?: string; title?: string } } = {};
 
-  // Track recent user interactions to distinguish intentional vs side-effect navigation
-  const recentUserInteractions: { [tabId: number]: number } = {}; // timestamp of last user interaction
-  const USER_INTERACTION_TIMEOUT = 5000; // 5 seconds (increased for testing)
+  // Track which tabs have been explicitly activated (brought to foreground) by the user.
+  // We will ignore events originating from tabs that were never activated to reduce noise
+  // (for example: ad / tracker tabs that load in the background).
+  const activatedTabs = new Set<number>();
+
+  // Track user clicks that are likely to open a new tab (Ctrl/Cmd + click, target=_blank etc.).
+  // Content scripts will send a PREPARE_NEW_TAB signal; we keep timestamp to correlate
+  // shortly following chrome.tabs.onCreated events so we can mark those tabs as user initiated.
+  const recentNewTabIntents: { [openerTabId: number]: number } = {};
+  // Record iframe URLs that the user actually interacted with (via custom events) per tab
+  const interactedFrameUrls: Record<number, Set<string>> = {};
+  // Additionally track last interaction time per frame for time-window gating
+  const interactedFrameTimes: Record<number, Record<string, number>> = {};
+  // Hostname patterns for iframe navigation noise we want to suppress
+  const BLOCKED_IFRAME_HOST_PATTERNS: RegExp[] = [
+    /doubleclick\.net$/i,
+    /googlesyndication\.com$/i,
+    /googleadservices\.com$/i,
+    /amazon-adsystem\.com$/i,
+    /recaptcha\.google\.com$/i,
+    /recaptcha\.net$/i,
+    /googletagmanager\.com$/i,
+    /indexww\.com$/i,
+    /adtrafficquality\.google$/i,
+    /2mdn\.net$/i,
+    /gstaticadssl\.googleapis\.com$/i,
+  ];
+
+  // Heuristic window (ms) within which a created tab following a user intent is considered relevant.
+  const NEW_TAB_INTENT_WINDOW_MS = 4000;
 
   let isRecordingEnabled = true; // Default to disabled (OFF)
   let lastWorkflowHash: string | null = null; // Cache for the last logged workflow hash
@@ -69,100 +94,82 @@ export default defineBackground(() => {
     }
   }
 
-  // Function to generate step descriptions for semantic workflows
-  function generateStepDescription(step: Step): string | null {
-    switch (step.type) {
-      case "click":
-        return "Click element";
-      case "input":
-        return "Input element";
-      case "navigation":
-        return `Navigate to ${step.url}`;
-      case "scroll":
-        return null; // Scroll steps will have null description like in the example
-      case "key_press":
-        return "Key press element";
-      case "extract":
-        return "Extract information with AI";
-      default:
-        return "Unknown action";
-    }
-  }
-
   // Function to broadcast workflow data updates to the console bus
   async function broadcastWorkflowDataUpdate(): Promise<Workflow> {
     // console.log("[DEBUG] broadcastWorkflowDataUpdate: Entered function"); // Optional: Keep for debugging
-    const allSteps: Step[] = Object.keys(sessionLogs)
+    const rawSteps: Step[] = Object.keys(sessionLogs)
       .flatMap((tabIdStr) => {
         const tabId = parseInt(tabIdStr, 10);
         return convertStoredEventsToSteps(sessionLogs[tabId] || []);
       })
       .sort((a, b) => a.timestamp - b.timestamp); // Sort chronologically
 
-    console.log(`🔄 Processing ${allSteps.length} steps for workflow update`);
-    const extractionSteps = allSteps.filter(s => (s as any).type === 'extract');
-    console.log(`🤖 Found ${extractionSteps.length} extraction steps:`, extractionSteps);
-
-    // Convert steps to semantic format with proper descriptions
-    const semanticSteps = allSteps.map((step, index) => {
-      const semanticStep: any = {
-        ...step,
-        description: generateStepDescription(step),
-      };
-      
-      // Remove internal fields that shouldn't be in the final workflow
-      delete semanticStep.timestamp;
-      delete semanticStep.tabId;
-      delete semanticStep.frameUrl;
-      delete semanticStep.xpath;
-      delete semanticStep.elementTag;
-      delete semanticStep.elementText;
-      delete semanticStep.screenshot;
-      
-      // Handle different step types specifically
-      if (step.type === "scroll") {
-        delete semanticStep.targetId;
-        // Keep scrollX and scrollY for scroll steps
-      } else if (step.type === "extract") {
-        // For extraction steps, preserve extractionGoal and url
-        // Keep: extractionGoal, url, type, description
-        // Already removed: timestamp, tabId, screenshot (these are correct to remove)
-        console.log(`🤖 Processing extraction step:`, semanticStep);
+    // Post-process to collapse consecutive duplicates that only differ by timestamp (e.g. repeated identical navigations)
+    const allSteps: Step[] = [];
+    for (const step of rawSteps) {
+      const last = allSteps.length ? allSteps[allSteps.length - 1] : null;
+      if (!last) {
+        allSteps.push(step);
+        continue;
       }
-      
-      // Convert targetText to target_text for semantic workflow compatibility
-      if (semanticStep.targetText) {
-        semanticStep.target_text = semanticStep.targetText;
-        delete semanticStep.targetText;
+      let isDuplicate = false;
+      if (last.type === step.type) {
+        switch (step.type) {
+          case 'navigation':
+            isDuplicate = (last as NavigationStep).url === (step as NavigationStep).url && last.tabId === step.tabId;
+            break;
+          case 'input':
+            isDuplicate =
+              last.tabId === step.tabId &&
+              (last as any).url === (step as any).url &&
+              (last as any).frameUrl === (step as any).frameUrl &&
+              (last as any).xpath === (step as any).xpath &&
+              (last as any).elementTag === (step as any).elementTag &&
+              (last as any).value === (step as any).value;
+            break;
+          case 'click':
+            isDuplicate =
+              last.tabId === step.tabId &&
+              (last as any).url === (step as any).url &&
+              (last as any).frameUrl === (step as any).frameUrl &&
+              (last as any).xpath === (step as any).xpath &&
+              (last as any).elementTag === (step as any).elementTag &&
+              (last as any).elementText === (step as any).elementText;
+            break;
+          case 'scroll': {
+            const sameXY = (last as any).scrollX === (step as any).scrollX && (last as any).scrollY === (step as any).scrollY;
+            const sameUrl = (last as any).url === (step as any).url;
+            const nearTime = Math.abs(step.timestamp - last.timestamp) < 200;
+            isDuplicate = last.tabId === step.tabId && sameXY && sameUrl && nearTime;
+            break;
+          }
+          case 'key_press':
+            isDuplicate =
+              last.tabId === step.tabId &&
+              (last as any).url === (step as any).url &&
+              (last as any).key === (step as any).key &&
+              (last as any).xpath === (step as any).xpath;
+            break;
+        }
+      }
+      if (isDuplicate) {
+        // Update timestamp (and screenshot if present) to most recent but don't add new step
+        last.timestamp = step.timestamp;
+        if ((step as any).screenshot) {
+          (last as any).screenshot = (step as any).screenshot;
+        }
       } else {
-        // Ensure target_text field exists (set to null if no semantic text available)
-        semanticStep.target_text = null;
+        allSteps.push(step);
       }
-      
-      return semanticStep;
-    });
-
-    const semanticExtractionSteps = semanticSteps.filter(s => s.type === 'extract');
-    console.log(`✅ Final semantic steps include ${semanticExtractionSteps.length} extraction steps:`, semanticExtractionSteps);
-
-    // Create the workflowData object for the Python server (semantic format)
-    const semanticWorkflowData: Workflow = {
-      workflow_analysis: "Semantic version of recorded workflow. Uses visible text to identify elements instead of CSS selectors for improved reliability.",
-      name: "Recorded Workflow (Semantic)",
-      description: `Recorded on ${new Date().toLocaleString()}`,
-      version: "1.0",
-      input_schema: [],
-      steps: semanticSteps, // Use processed semantic steps
-    };
+    }
 
-    // Create the workflowData object for the UI (with original targetText)
-    const uiWorkflowData: Workflow = {
-      workflow_analysis: "Semantic version of recorded workflow. Uses visible text to identify elements instead of CSS selectors for improved reliability.",
-      name: "Recorded Workflow (Semantic)",
+    // Create the workflowData object *after* sorting steps, but hash only steps
+    const workflowData: Workflow = {
+      name: "Recorded Workflow",
       description: `Recorded on ${new Date().toLocaleString()}`,
-      version: "1.0",
+      version: "1.0.0",
       input_schema: [],
-      steps: allSteps, // Use original steps with targetText for UI
+      steps: allSteps, // allSteps is used here
     };
 
     const allStepsString = JSON.stringify(allSteps); // Hash based on allSteps
@@ -173,20 +180,20 @@ export default defineBackground(() => {
     // Condition to skip logging if the hash of steps is the same
     if (lastWorkflowHash !== null && currentWorkflowHash === lastWorkflowHash) {
       // console.log("[DEBUG] broadcastWorkflowDataUpdate: Steps unchanged, skipping log."); // Optional
-      return uiWorkflowData;
+      return workflowData;
     }
 
     lastWorkflowHash = currentWorkflowHash;
-    // console.log("[DEBUG] broadcastWorkflowDataUpdate: Steps changed, workflowData object:", JSON.parse(JSON.stringify(uiWorkflowData))); // Optional
+    // console.log("[DEBUG] broadcastWorkflowDataUpdate: Steps changed, workflowData object:", JSON.parse(JSON.stringify(workflowData))); // Optional
 
-    // Send semantic workflow update to Python server
+    // Send workflow update to Python server
     const eventToSend: HttpWorkflowUpdateEvent = {
       type: "WORKFLOW_UPDATE",
       timestamp: Date.now(),
-      payload: semanticWorkflowData, // Send semantic format to server
+      payload: workflowData,
     };
     sendEventToServer(eventToSend);
-    return uiWorkflowData; // Return UI format to extension
+    return workflowData;
   }
 
   // Function to broadcast the recording status to all content scripts and sidepanel
@@ -227,6 +234,16 @@ export default defineBackground(() => {
     console.log(`Sending ${type}:`, payload);
     const tabId = payload.tabId;
     if (tabId) {
+      // Skip capturing events for tabs that have never been activated AND are not the original opener
+      // unless we have positively identified them as a recent user initiated tab (click intent -> creation).
+      if (
+        type !== "CUSTOM_TAB_ACTIVATED" &&
+        !activatedTabs.has(tabId) &&
+        !(payload.openerTabId && recentNewTabIntents[payload.openerTabId] && Date.now() - recentNewTabIntents[payload.openerTabId] < NEW_TAB_INTENT_WINDOW_MS)
+      ) {
+        // Silently ignore background noise (ad/tracker tabs) until user actually focuses them.
+        return;
+      }
       if (!sessionLogs[tabId]) {
         sessionLogs[tabId] = [];
       }
@@ -254,6 +271,12 @@ export default defineBackground(() => {
       url: tab.pendingUrl || tab.url,
       windowId: tab.windowId,
       index: tab.index,
+      userInitiated:
+        !!(
+          tab.openerTabId &&
+          recentNewTabIntents[tab.openerTabId] &&
+          Date.now() - recentNewTabIntents[tab.openerTabId] < NEW_TAB_INTENT_WINDOW_MS
+        ),
     });
   });
 
@@ -271,6 +294,7 @@ export default defineBackground(() => {
   });
 
   chrome.tabs.onActivated.addListener((activeInfo) => {
+  activatedTabs.add(activeInfo.tabId);
     sendTabEvent("CUSTOM_TAB_ACTIVATED", {
       tabId: activeInfo.tabId,
       windowId: activeInfo.windowId,
@@ -295,119 +319,127 @@ export default defineBackground(() => {
 
   // --- Conversion Function ---
 
+  const DEFAULT_SETTINGS = {
+    enableIframes: true as boolean,
+    iframeWindow: 3000 as number,
+    blocklist: [
+      'doubleclick.net','googlesyndication.com','googleadservices.com',
+      'amazon-adsystem.com','2mdn.net','recaptcha.google.com','recaptcha.net',
+      'googletagmanager.com','indexww.com','adtrafficquality.google'
+    ] as string[],
+    allowlist: [] as string[],
+  };
+  let settings: { enableIframes: boolean; iframeWindow: number; blocklist: string[]; allowlist: string[] } = { ...DEFAULT_SETTINGS };
+  chrome.storage.sync.get(DEFAULT_SETTINGS, (s: any) => { settings = { ...settings, ...s }; });
+  chrome.storage.onChanged.addListener((changes, area) => {
+    if (area !== 'sync') return;
+    const next = { ...settings } as any;
+    for (const k of Object.keys(changes)) (next as any)[k] = (changes as any)[k].newValue;
+    settings = next;
+  });
+
   function convertStoredEventsToSteps(events: StoredEvent[]): Step[] {
     const steps: Step[] = [];
+    const lastNavigationIndexByTab: Record<number, number> = {};
+    const lastInputPerKey: Record<string, { idx: number; ts: number; value: string }> = {};
 
     for (const event of events) {
       switch (event.messageType) {
-        case "CUSTOM_CLICK_EVENT": {
-          const clickEvent = event as StoredCustomClickEvent;
-          // Ensure required fields are present, even if optional in source type for some reason
+        case "CUSTOM_TAB_CREATED":
+        case "CUSTOM_TAB_UPDATED":
+        case "CUSTOM_TAB_ACTIVATED": {
+          const navUrl = (event as any).url || (event as any).changeInfo?.url;
+          if (!navUrl) break;
+          const tabId = (event as any).tabId;
+          const userInitiated = (event as any).userInitiated;
+          if (!activatedTabs.has(tabId) && !userInitiated) break; // suppress background noise
+
+          const existingIdx = lastNavigationIndexByTab[tabId];
           if (
-            clickEvent.url &&
-            clickEvent.frameUrl &&
-            clickEvent.xpath &&
-            clickEvent.elementTag
+            existingIdx !== undefined &&
+            steps[existingIdx] &&
+            steps[existingIdx].type === "navigation"
           ) {
+            // Update existing navigation (redirect / title change)
+            (steps[existingIdx] as NavigationStep).url = navUrl;
+            steps[existingIdx].timestamp = event.timestamp;
+          } else {
+            const nav: NavigationStep = {
+              type: "navigation",
+              timestamp: event.timestamp,
+              tabId,
+              url: navUrl,
+            };
+            steps.push(nav);
+            lastNavigationIndexByTab[tabId] = steps.length - 1;
+          }
+          break;
+        }
+        case "CUSTOM_CLICK_EVENT": {
+          const click = event as StoredCustomClickEvent;
+          if (click.url && click.xpath && click.elementTag) {
             const step: ClickStep = {
               type: "click",
-              timestamp: clickEvent.timestamp,
-              tabId: clickEvent.tabId,
-              url: clickEvent.url,
-              frameUrl: clickEvent.frameUrl,
-              xpath: clickEvent.xpath,
-              elementTag: clickEvent.elementTag,
-              elementText: clickEvent.elementText,
-              screenshot: clickEvent.screenshot,
+              timestamp: click.timestamp,
+              tabId: click.tabId,
+              url: click.url,
+              frameUrl: click.frameUrl,
+              frameIdPath: (click as any).frameIdPath,
+              xpath: click.xpath,
+              cssSelector: click.cssSelector,
+              elementTag: click.elementTag,
+              elementText: click.elementText,
+              screenshot: click.screenshot,
             };
-            
-            // Prioritize target_text for semantic workflows, but include cssSelector for complex elements
-            if (clickEvent.targetText && clickEvent.targetText.trim()) {
-              step.targetText = clickEvent.targetText;
-              
-              // For radio buttons, checkboxes, and complex interactive elements, also include cssSelector
-              if (clickEvent.cssSelector && 
-                  (clickEvent.cssSelector.includes('radio') || 
-                   clickEvent.cssSelector.includes('checkbox') ||
-                   clickEvent.cssSelector.includes('role="radio"') ||
-                   clickEvent.cssSelector.includes('role="checkbox"') ||
-                   clickEvent.elementTag.toLowerCase() === 'button')) {
-                step.cssSelector = clickEvent.cssSelector;
-              }
-            } else if (clickEvent.cssSelector) {
-              step.cssSelector = clickEvent.cssSelector;
-            }
-            
             steps.push(step);
           } else {
-            console.warn("Skipping incomplete CUSTOM_CLICK_EVENT:", clickEvent);
+            console.warn("Skipping incomplete CUSTOM_CLICK_EVENT", click);
           }
           break;
         }
-
         case "CUSTOM_INPUT_EVENT": {
           const inputEvent = event as StoredCustomInputEvent;
-          if (
-            inputEvent.url &&
-            // inputEvent.frameUrl && // frameUrl might be null/undefined in some cases, let's allow merging if only one is present or both match
-            inputEvent.xpath &&
-            inputEvent.elementTag
-          ) {
+          if (inputEvent.url && inputEvent.xpath && inputEvent.elementTag) {
+            const key = `${inputEvent.tabId}|${inputEvent.xpath}`;
+            const prior = lastInputPerKey[key];
+            const nowTs = inputEvent.timestamp;
+            const isEmpty = (inputEvent as any).value === "";
+            if (isEmpty && prior && prior.value === "" && nowTs - prior.ts < 5000) {
+              // collapse rapid-fire repeated empties
+              steps[prior.idx].timestamp = nowTs;
+              break;
+            }
             const lastStep = steps.length > 0 ? steps[steps.length - 1] : null;
-
-            // Check if the last step was a mergeable input event
             if (
               lastStep &&
               lastStep.type === "input" &&
               lastStep.tabId === inputEvent.tabId &&
               lastStep.url === inputEvent.url &&
-              lastStep.frameUrl === inputEvent.frameUrl && // Ensure frameUrls match if both exist
+              lastStep.frameUrl === inputEvent.frameUrl &&
               lastStep.xpath === inputEvent.xpath &&
-              ((lastStep as InputStep).targetText === inputEvent.targetText || 
-               (lastStep as InputStep).cssSelector === inputEvent.cssSelector) &&
+              lastStep.cssSelector === inputEvent.cssSelector &&
               lastStep.elementTag === inputEvent.elementTag
             ) {
-              // Update the last input step
               (lastStep as InputStep).value = inputEvent.value;
-              lastStep.timestamp = inputEvent.timestamp; // Update to latest timestamp
-              (lastStep as InputStep).screenshot = inputEvent.screenshot; // Update to latest screenshot
-              
-              // Update semantic targeting if available
-              if (inputEvent.targetText && inputEvent.targetText.trim()) {
-                (lastStep as InputStep).targetText = inputEvent.targetText;
-                delete (lastStep as InputStep).cssSelector; // Remove cssSelector when we have targetText
-              }
+              lastStep.timestamp = inputEvent.timestamp;
+              (lastStep as InputStep).screenshot = inputEvent.screenshot;
+              lastInputPerKey[key] = { idx: steps.length - 1, ts: nowTs, value: (inputEvent as any).value };
             } else {
-              // Add a new input step
               const newStep: InputStep = {
                 type: "input",
                 timestamp: inputEvent.timestamp,
                 tabId: inputEvent.tabId,
                 url: inputEvent.url,
                 frameUrl: inputEvent.frameUrl,
+                frameIdPath: (inputEvent as any).frameIdPath,
                 xpath: inputEvent.xpath,
+                cssSelector: inputEvent.cssSelector,
                 elementTag: inputEvent.elementTag,
                 value: inputEvent.value,
                 screenshot: inputEvent.screenshot,
               };
-              
-              // Prioritize target_text for semantic workflows, but include cssSelector for complex elements
-              if (inputEvent.targetText && inputEvent.targetText.trim()) {
-                newStep.targetText = inputEvent.targetText;
-                
-                // For radio buttons, checkboxes, and complex input elements, also include cssSelector
-                if (inputEvent.cssSelector && 
-                    (inputEvent.cssSelector.includes('radio') || 
-                     inputEvent.cssSelector.includes('checkbox') ||
-                     inputEvent.cssSelector.includes('role="radio"') ||
-                     inputEvent.cssSelector.includes('role="checkbox"'))) {
-                  newStep.cssSelector = inputEvent.cssSelector;
-                }
-              } else if (inputEvent.cssSelector) {
-                newStep.cssSelector = inputEvent.cssSelector;
-              }
-              
               steps.push(newStep);
+              lastInputPerKey[key] = { idx: steps.length - 1, ts: nowTs, value: (inputEvent as any).value };
             }
           } else {
             console.warn("Skipping incomplete CUSTOM_INPUT_EVENT:", inputEvent);
@@ -426,6 +458,7 @@ export default defineBackground(() => {
               tabId: keyEvent.tabId,
               url: keyEvent.url,
               frameUrl: keyEvent.frameUrl, // Can be missing
+              frameIdPath: (keyEvent as any).frameIdPath,
               key: keyEvent.key,
               xpath: keyEvent.xpath,
               cssSelector: keyEvent.cssSelector,
@@ -452,14 +485,21 @@ export default defineBackground(() => {
               y: number;
             }; // Type assertion for clarity
             const currentTabInfo = tabInfo[rrEvent.tabId]; // Get associated tab info for URL
-
+            // Drop internal chrome pages like chrome://newtab/
+            if (currentTabInfo?.url?.startsWith('chrome://')) {
+              break;
+            }
             // Check if the last step added was a mergeable scroll event
             const lastStep = steps.length > 0 ? steps[steps.length - 1] : null;
             if (
               lastStep &&
               lastStep.type === "scroll" &&
               lastStep.tabId === rrEvent.tabId &&
-              (lastStep as ScrollStep).targetId === scrollData.id
+              // Treat same XY within a short time window as duplicate, regardless of targetId
+              (lastStep as ScrollStep).scrollX === scrollData.x &&
+              (lastStep as ScrollStep).scrollY === scrollData.y &&
+              Math.abs(rrEvent.timestamp - lastStep.timestamp) < 200 &&
+              (lastStep as any).url === currentTabInfo?.url
             ) {
               // Update the last scroll step
               (lastStep as ScrollStep).scrollX = scrollData.x;
@@ -479,38 +519,52 @@ export default defineBackground(() => {
               };
               steps.push(newStep);
             }
-          } else if ((rrEvent.type === EventType.Meta || rrEvent.type === EventType.FullSnapshot) && rrEvent.data?.href) {
-            // Handle rrweb meta and fullsnapshot events as navigation (filtering now happens at storage level)
+          } else if (rrEvent.type === EventType.Meta && rrEvent.data?.href) {
+            // Also handle rrweb meta events as navigation
             const metaData = rrEvent.data as { href: string };
+            const href = metaData.href;
+            // Drop about:blank always
+            if (href === 'about:blank') {
+              break;
+            }
+            try {
+              const urlObj = new URL(href);
+              const host = urlObj.hostname;
+              // Allowlist overrides blocklist
+              const inAllow = settings.allowlist.some(d => host.endsWith(d));
+              const inBlock = settings.blocklist.some(d => host.endsWith(d));
+              if (!inAllow && inBlock) {
+                break;
+              }
+              if (!settings.enableIframes && !(rrEvent as any).isTopFrame) {
+                break; // user disabled iframe recording
+              }
+              // If top frame, allow
+              if ((rrEvent as any).isTopFrame) {
+                // allowed
+              } else {
+                const fUrl = (rrEvent as any).frameUrl as string | undefined;
+                if (!fUrl) break;
+                const times = interactedFrameTimes[rrEvent.tabId] || {};
+                const lastTs = times[fUrl];
+                if (!lastTs) break;
+                if (Date.now() - lastTs > settings.iframeWindow) break;
+              }
+            } catch {
+              break;
+            }
             const step: NavigationStep = {
               type: "navigation",
               timestamp: rrEvent.timestamp,
               tabId: rrEvent.tabId,
               url: metaData.href,
+              // frameIdPath could be attached if needed
             };
             steps.push(step);
           }
           break;
         }
 
-        case "EXTRACTION_STEP": {
-          const extractEvent = event as any; // Type assertion for extraction event
-          if (extractEvent.url && extractEvent.extractionGoal) {
-            const step: ExtractStep = {
-              type: "extract",
-              timestamp: extractEvent.timestamp,
-              tabId: extractEvent.tabId,
-              url: extractEvent.url,
-              extractionGoal: extractEvent.extractionGoal,
-              screenshot: extractEvent.screenshot,
-            };
-            steps.push(step);
-          } else {
-            console.warn("Skipping incomplete EXTRACTION_STEP:", extractEvent);
-          }
-          break;
-        }
-
         // Add cases for other StoredEvent types to Step types if needed
         // e.g., CUSTOM_SELECT_EVENT -> SelectStep
         // e.g., CUSTOM_TAB_CREATED -> TabCreatedStep
@@ -537,6 +591,8 @@ export default defineBackground(() => {
       "CUSTOM_INPUT_EVENT",
       "CUSTOM_SELECT_EVENT",
       "CUSTOM_KEY_EVENT",
+  // Synthetic event we will emit from content script just before an expected new tab open.
+  "PREPARE_NEW_TAB",
     ];
     if (
       message.type === "RRWEB_EVENT" ||
@@ -553,6 +609,13 @@ export default defineBackground(() => {
       const tabId = sender.tab.id;
       const isCustomEvent = customEventTypes.includes(message.type);
 
+      // Record intent for new tab opening to correlate with onCreated event.
+      if (message.type === "PREPARE_NEW_TAB") {
+        recentNewTabIntents[sender.tab.id] = Date.now();
+        // We do not store this as a workflow step; it's only heuristic metadata.
+        return false;
+      }
+
       // Function to store the event
       const storeEvent = (eventPayload: any, screenshotDataUrl?: string) => {
         if (!sessionLogs[tabId]) {
@@ -568,37 +631,6 @@ export default defineBackground(() => {
           tabInfo[tabId].title = sender.tab.title;
         }
 
-        // Track user interactions for navigation filtering
-        if (customEventTypes.includes(message.type)) {
-          recentUserInteractions[tabId] = eventPayload.timestamp || Date.now();
-          console.log(`[NAV_FILTER] Tracked ${message.type} on tab ${tabId} at ${recentUserInteractions[tabId]}`);
-        }
-
-        // Log all rrweb events for debugging
-        if (message.type === "RRWEB_EVENT") {
-          console.log(`[NAV_FILTER] RRWEB event type ${eventPayload.type} (Meta=${EventType.Meta})`, eventPayload.data);
-        }
-
-        // Filter out side-effect navigation from rrweb meta and fullsnapshot events
-        if (message.type === "RRWEB_EVENT" && 
-            (eventPayload.type === EventType.Meta || eventPayload.type === EventType.FullSnapshot) && 
-            eventPayload.data?.href) {
-          const lastUserInteraction = recentUserInteractions[tabId] || 0;
-          const currentTime = eventPayload.timestamp || Date.now();
-          const timeSinceLastInteraction = currentTime - lastUserInteraction;
-          
-          // Check if this is the first event in the session (initial page load)
-          const isFirstEvent = !sessionLogs[tabId] || sessionLogs[tabId].length === 0;
-          
-          // Only store navigation if it's the first event (initial page load) or no user interaction has happened
-          if (lastUserInteraction === 0 || isFirstEvent) {
-            console.log(`[NAV_FILTER] STORING navigation: ${eventPayload.data.href} (lastInteraction: ${lastUserInteraction}, isFirst: ${isFirstEvent})`);
-          } else {
-            console.log(`[NAV_FILTER] FILTERED navigation: ${eventPayload.data.href} (${timeSinceLastInteraction}ms after interaction - always filter post-interaction navigation)`);
-            return; // Don't store this event
-          }
-        }
-
         const eventWithMeta = {
           ...eventPayload,
           tabId: tabId,
@@ -606,6 +638,13 @@ export default defineBackground(() => {
           screenshot: screenshotDataUrl,
         };
         sessionLogs[tabId].push(eventWithMeta);
+        // Mark frame as interacted so subsequent iframe meta navigations can be allowed
+        if (message.type.startsWith("CUSTOM_") && eventPayload.frameUrl) {
+          if (!interactedFrameUrls[tabId]) interactedFrameUrls[tabId] = new Set();
+          interactedFrameUrls[tabId].add(eventPayload.frameUrl);
+          if (!interactedFrameTimes[tabId]) interactedFrameTimes[tabId] = {};
+          interactedFrameTimes[tabId][eventPayload.frameUrl] = Date.now();
+        }
         broadcastWorkflowDataUpdate(); // Call is async, will not block
         // console.log(`Stored ${message.type} from tab ${tabId}`);
       };
@@ -663,9 +702,6 @@ export default defineBackground(() => {
         (key) => delete sessionLogs[parseInt(key)]
       );
       Object.keys(tabInfo).forEach((key) => delete tabInfo[parseInt(key)]);
-      Object.keys(recentUserInteractions).forEach(
-        (key) => delete recentUserInteractions[parseInt(key)]
-      );
       console.log("Cleared previous recording data.");
 
       // Start recording
@@ -700,83 +736,6 @@ export default defineBackground(() => {
       }
       sendResponse({ status: "stopped" }); // Send simple confirmation
     }
-    // --- Add Extraction Step from Sidepanel ---
-    else if (message.type === "ADD_EXTRACTION_STEP") {
-      console.log("🤖 Received ADD_EXTRACTION_STEP request:", message.payload);
-      
-      if (!isRecordingEnabled) {
-        console.error("❌ Recording is not enabled");
-        sendResponse({ status: "error", message: "Recording is not active" });
-        return false;
-      }
-
-      try {
-        // For sidepanel messages, we need to get the active tab
-        // Since this is from sidepanel, sender.tab will be undefined
-        // Let's use a direct approach with chrome.tabs.query but handle it synchronously
-        
-        isAsync = true;
-        
-        chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
-          try {
-            console.log("📋 Active tabs found:", tabs?.length || 0);
-            
-            if (chrome.runtime.lastError) {
-              console.error("❌ Chrome tabs query error:", chrome.runtime.lastError);
-              sendResponse({ status: "error", message: "Chrome tabs query failed" });
-              return;
-            }
-            
-            if (!tabs || tabs.length === 0 || !tabs[0]?.id) {
-              console.error("❌ No active tab found");
-              sendResponse({ status: "error", message: "No active tab found" });
-              return;
-            }
-
-            const tabId = tabs[0].id;
-            const tabUrl = tabs[0].url || "";
-            
-            console.log("✅ Using tab ID:", tabId, "URL:", tabUrl);
-            
-            const extractionStep: StoredExtractionEvent = {
-              timestamp: message.payload.timestamp,
-              tabId: tabId,
-              url: tabUrl,
-              extractionGoal: message.payload.extractionGoal,
-              messageType: "EXTRACTION_STEP",
-            };
-
-            console.log("📝 Creating extraction step:", extractionStep);
-
-            if (!sessionLogs[tabId]) {
-              console.log("🆕 Initializing sessionLogs for tab:", tabId);
-              sessionLogs[tabId] = [];
-            }
-            
-            sessionLogs[tabId].push(extractionStep);
-            console.log("✅ Added extraction step to sessionLogs. Total events for tab:", sessionLogs[tabId].length);
-            
-            // Broadcast update (don't await to avoid blocking)
-            broadcastWorkflowDataUpdate();
-            console.log("✅ Broadcasted workflow update");
-            
-            // Send success response
-            sendResponse({ status: "added" });
-            
-          } catch (error) {
-            console.error("❌ Error in tabs.query callback:", error);
-            sendResponse({ status: "error", message: `Callback error: ${error}` });
-          }
-        });
-        
-        return true; // Keep message channel open
-        
-      } catch (error) {
-        console.error("❌ Error setting up extraction step:", error);
-        sendResponse({ status: "error", message: `Setup error: ${error}` });
-        return false;
-      }
-    }
     // --- Status Request from Content Script ---
     else if (message.type === "REQUEST_RECORDING_STATUS" && sender.tab?.id) {
       console.log(
diff --git a/extension/src/entrypoints/content.ts b/extension/src/entrypoints/content.ts
index 08bef61..b2e6c85 100644
--- a/extension/src/entrypoints/content.ts
+++ b/extension/src/entrypoints/content.ts
@@ -122,6 +122,16 @@ function startRecorder() {
     emit(event) {
       if (!isRecordingActive) return;
 
+      const frameUrl = window.location.href;
+      const isTopFrame = window.self === window.top;
+      const frameIdPath = (() => {
+        try {
+          let win: any = window; const parts: number[] = [];
+          while (win !== win.parent) { const parent = win.parent; let idx=0; for (let i=0;i<parent.frames.length;i++){ if(parent.frames[i]===win){idx=i;break;} } parts.unshift(idx); win=parent; if(parts.length>10) break; }
+          return parts.length ? parts.join('.') : '0';
+        } catch { return '0'; }
+      })();
+
       // Handle scroll events with debouncing and direction detection
       if (
         event.type === EventType.IncrementalSnapshot &&
@@ -157,7 +167,10 @@ function startRecorder() {
             type: "RRWEB_EVENT",
             payload: {
               ...event,
-              data: roundedScrollData, // Use rounded coordinates
+              data: roundedScrollData,
+              frameUrl,
+              frameIdPath,
+              isTopFrame,
             },
           });
           lastDirection = currentDirection;
@@ -178,15 +191,18 @@ function startRecorder() {
             type: "RRWEB_EVENT",
             payload: {
               ...event,
-              data: roundedScrollData, // Use rounded coordinates
+              data: roundedScrollData,
+              frameUrl,
+              frameIdPath,
+              isTopFrame,
             },
           });
           scrollTimeout = null;
           lastDirection = null; // Reset direction for next scroll
         }, DEBOUNCE_MS);
       } else {
-        // Pass through non-scroll events unchanged
-        chrome.runtime.sendMessage({ type: "RRWEB_EVENT", payload: event });
+        // Pass through non-scroll events unchanged, but include frame context for filtering in background
+        chrome.runtime.sendMessage({ type: "RRWEB_EVENT", payload: { ...event, frameUrl, frameIdPath, isTopFrame } });
       }
     },
     maskInputOptions: {
@@ -536,7 +552,24 @@ function handleCustomClick(event: MouseEvent) {
   if (!isRecordingActive) return;
   const targetElement = event.target as HTMLElement;
   if (!targetElement) return;
-
+  // Determine a frame identifier (best-effort). Top frame = 0, nested frames build path.
+  const frameIdPath = (() => {
+    try {
+      let win: any = window;
+      const parts: number[] = [];
+      while (win !== win.parent) {
+        const parent = win.parent;
+        let index = 0;
+        for (let i = 0; i < parent.frames.length; i++) {
+          if (parent.frames[i] === win) { index = i; break; }
+        }
+        parts.unshift(index);
+        win = parent;
+        if (parts.length > 10) break; // safety
+      }
+      return parts.length ? parts.join('.') : '0';
+    } catch { return '0'; }
+  })();
   try {
     const xpath = getXPath(targetElement);
     const semanticInfo = extractSemanticInfo(targetElement);
@@ -594,9 +627,10 @@ function handleCustomClick(event: MouseEvent) {
     
     const clickData = {
       timestamp: Date.now(),
-      url: document.location.href, // Use document.location for main page URL
-      frameUrl: window.location.href, // URL of the frame where the event occurred
-      xpath: xpath,
+      url: document.location.href,
+      frameUrl: window.location.href,
+      frameIdPath,
+      xpath,
       cssSelector: getEnhancedCSSSelector(targetElement, xpath),
       elementTag: targetElement.tagName,
       elementText: semanticInfo.textContent,
@@ -608,14 +642,8 @@ function handleCustomClick(event: MouseEvent) {
       // Enhanced radio button information
       radioButtonInfo: semanticInfo.radioButtonInfo,
     };
-    console.log("Sending CUSTOM_CLICK_EVENT:", clickData);
-    chrome.runtime.sendMessage({
-      type: "CUSTOM_CLICK_EVENT",
-      payload: clickData,
-    });
-  } catch (error) {
-    console.error("Error capturing click data:", error);
-  }
+    chrome.runtime.sendMessage({ type: "CUSTOM_CLICK_EVENT", payload: clickData });
+  } catch (error) { console.error("Error capturing click data:", error); }
 }
 
 // Helper function to determine if we should skip capturing this click event
@@ -658,12 +686,24 @@ function isElementVisible(element: HTMLElement): boolean {
 // --- End Custom Click Handler ---
 
 // --- Custom Input Handler ---
+// Maintain last recorded value & timestamp per element (keyed by xpath) to suppress noisy repeats
+const lastInputRecord: Record<string, { value: string; ts: number }> = {};
 function handleInput(event: Event) {
   if (!isRecordingActive) return;
   const targetElement = event.target as HTMLInputElement | HTMLTextAreaElement;
   if (!targetElement || !("value" in targetElement)) return;
   const isPassword = targetElement.type === "password";
 
+  // Ignore programmatic (non user-trusted) input events – these often cause massive duplication
+  if (!(event as InputEvent).isTrusted) return;
+
+  const frameIdPath = (() => {
+    try {
+      let win: any = window; const parts: number[] = [];
+      while (win !== win.parent) { const parent = win.parent; let idx=0; for (let i=0;i<parent.frames.length;i++){ if(parent.frames[i]===win){idx=i;break;} } parts.unshift(idx); win=parent; if(parts.length>10) break; }
+      return parts.length ? parts.join('.') : '0';
+    } catch { return '0'; }
+  })();
   try {
     const xpath = getXPath(targetElement);
     const semanticInfo = extractSemanticInfo(targetElement as HTMLElement);
@@ -681,6 +721,7 @@ function handleInput(event: Event) {
       timestamp: Date.now(),
       url: document.location.href,
       frameUrl: window.location.href,
+      frameIdPath,
       xpath: xpath,
       cssSelector: getEnhancedCSSSelector(targetElement, xpath),
       elementTag: targetElement.tagName,
@@ -690,6 +731,26 @@ function handleInput(event: Event) {
       targetText: targetText,
       semanticInfo: semanticInfo,
     };
+
+    // Dedupe rule 1: If value unchanged for this element and within debounce window, skip
+    const DEBOUNCE_MS_INPUT = 1500;
+    const prev = lastInputRecord[xpath];
+    if (prev && prev.value === inputData.value && inputData.timestamp - prev.ts < DEBOUNCE_MS_INPUT) {
+      return; // Suppress noisy duplicate
+    }
+
+    // Dedupe rule 2: If value is empty string and we already recorded empty in last 5s, suppress further empties
+    if (
+      inputData.value === "" &&
+      prev &&
+      prev.value === "" &&
+      inputData.timestamp - prev.ts < 5000
+    ) {
+      return;
+    }
+
+    // Store/update last record metadata
+    lastInputRecord[xpath] = { value: inputData.value, ts: inputData.timestamp };
     console.log("Sending CUSTOM_INPUT_EVENT:", inputData);
     chrome.runtime.sendMessage({
       type: "CUSTOM_INPUT_EVENT",
@@ -707,6 +768,7 @@ function handleSelectChange(event: Event) {
   const targetElement = event.target as HTMLSelectElement;
   // Ensure it's a select element
   if (!targetElement || targetElement.tagName !== "SELECT") return;
+  const frameIdPath = (() => { try { let win:any=window; const parts:number[]=[]; while(win!==win.parent){const parent=win.parent; let idx=0; for(let i=0;i<parent.frames.length;i++){ if(parent.frames[i]===win){idx=i;break;} } parts.unshift(idx); win=parent; if(parts.length>10) break;} return parts.length?parts.join('.'):'0'; } catch { return '0'; } })();
 
   try {
     const xpath = getXPath(targetElement);
@@ -731,6 +793,7 @@ function handleSelectChange(event: Event) {
       timestamp: Date.now(),
       url: document.location.href,
       frameUrl: window.location.href,
+      frameIdPath,
       xpath: xpath,
       cssSelector: getEnhancedCSSSelector(targetElement, xpath),
       elementTag: targetElement.tagName,
@@ -807,11 +870,13 @@ function handleKeydown(event: KeyboardEvent) {
       }
     }
 
+    const frameIdPath = (() => { try { let win:any=window; const parts:number[]=[]; while(win!==win.parent){const parent=win.parent; let idx=0; for(let i=0;i<parent.frames.length;i++){ if(parent.frames[i]===win){idx=i;break;} } parts.unshift(idx); win=parent; if(parts.length>10) break;} return parts.length?parts.join('.'):'0'; } catch { return '0'; } })();
     try {
       const keyData = {
         timestamp: Date.now(),
         url: document.location.href,
         frameUrl: window.location.href,
+        frameIdPath,
         key: keyToLog, // The key or combination pressed
         xpath: xpath, // XPath of the element in focus (if any)
         cssSelector: cssSelector, // CSS selector of the element in focus (if any)
@@ -974,6 +1039,9 @@ function handleBlur(event: FocusEvent) {
 
 export default defineContentScript({
   matches: ["<all_urls>"],
+  // Ensure injection into all frames (iframes) so we can capture interactions inside nested documents.
+  allFrames: true,
+  matchAboutBlank: true,
   main(ctx) {
     // Listener for status updates from the background script
     chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
diff --git a/extension/src/entrypoints/options.html b/extension/src/entrypoints/options.html
new file mode 100644
index 0000000..dfb7bf4
--- /dev/null
+++ b/extension/src/entrypoints/options.html
@@ -0,0 +1,80 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <title>Workflow Use - Options</title>
+    <style>
+      body { font-family: system-ui, sans-serif; margin: 16px; }
+      label { display: block; margin: 8px 0 4px; font-weight: 600; }
+      textarea { width: 100%; height: 100px; font-family: ui-monospace, monospace; }
+      input[type="number"] { width: 160px; }
+      .row { margin-bottom: 12px; }
+      .hint { color: #555; font-size: 12px; }
+      .section { border: 1px solid #ddd; padding: 12px; border-radius: 8px; margin-bottom: 16px; }
+    </style>
+  </head>
+  <body>
+    <h2>Recording Settings</h2>
+    <div class="section">
+      <div class="row">
+        <label>
+          <input type="checkbox" id="enableIframes" /> Enable recording from iframes
+        </label>
+        <div class="hint">When disabled, iframe-originated navigation/meta events are ignored.</div>
+      </div>
+      <div class="row">
+        <label for="iframeWindow">Iframe allow window (ms)</label>
+        <input type="number" id="iframeWindow" min="0" step="100" />
+        <div class="hint">Time after a user interaction in an iframe during which rrweb meta navigations are allowed.</div>
+      </div>
+      <div class="row">
+        <label for="blocklist">Blocked domains (newline separated)</label>
+        <textarea id="blocklist" placeholder="example.com\nads.example.org"></textarea>
+      </div>
+      <div class="row">
+        <label for="allowlist">Allowed domains (newline separated)</label>
+        <textarea id="allowlist" placeholder="Optional allowlist overrides blocklist"></textarea>
+      </div>
+      <button id="save">Save</button>
+      <span id="status" class="hint"></span>
+    </div>
+
+    <script>
+      const DEFAULTS = {
+        enableIframes: true,
+        iframeWindow: 3000,
+        blocklist: [
+          'doubleclick.net','googlesyndication.com','googleadservices.com',
+          'amazon-adsystem.com','2mdn.net','recaptcha.google.com','recaptcha.net',
+          'googletagmanager.com','indexww.com','adtrafficquality.google'
+        ],
+        allowlist: [],
+      };
+
+      function toLines(str){ return (str||'').split(/\r?\n/).map(s=>s.trim()).filter(Boolean); }
+      function fromLines(arr){ return (arr||[]).join('\n'); }
+
+      async function load() {
+        const store = await chrome.storage.sync.get(DEFAULTS);
+        document.getElementById('enableIframes').checked = !!store.enableIframes;
+        document.getElementById('iframeWindow').value = store.iframeWindow;
+        document.getElementById('blocklist').value = fromLines(store.blocklist);
+        document.getElementById('allowlist').value = fromLines(store.allowlist);
+      }
+
+      async function save() {
+        const enableIframes = document.getElementById('enableIframes').checked;
+        const iframeWindow = parseInt(document.getElementById('iframeWindow').value || '0', 10);
+        const blocklist = toLines(document.getElementById('blocklist').value);
+        const allowlist = toLines(document.getElementById('allowlist').value);
+        await chrome.storage.sync.set({ enableIframes, iframeWindow, blocklist, allowlist });
+        const el = document.getElementById('status');
+        el.textContent = 'Saved';
+        setTimeout(()=> el.textContent = '', 1500);
+      }
+
+      document.getElementById('save').addEventListener('click', save);
+      load();
+    </script>
+  </body>
+</html>
diff --git a/extension/src/entrypoints/sidepanel/components/recording-view.tsx b/extension/src/entrypoints/sidepanel/components/recording-view.tsx
index 00ebfd8..1aa8a0d 100644
--- a/extension/src/entrypoints/sidepanel/components/recording-view.tsx
+++ b/extension/src/entrypoints/sidepanel/components/recording-view.tsx
@@ -1,193 +1,30 @@
-import React, { useState } from "react";
+import React from "react";
 import { useWorkflow } from "../context/workflow-provider";
 import { Button } from "@/components/ui/button";
-import { EventViewer } from "./event-viewer"; // Import EventViewer
+import { EventViewer } from "./event-viewer";
 
 export const RecordingView: React.FC = () => {
-  const { stopRecording, workflow, recordingStatus } = useWorkflow();
+  const { stopRecording, workflow } = useWorkflow();
   const stepCount = workflow?.steps?.length || 0;
-  const [showExtractionDialog, setShowExtractionDialog] = useState(false);
-  const [extractionGoal, setExtractionGoal] = useState("");
-
-  const handleAddExtraction = () => {
-    if (extractionGoal.trim()) {
-      const payload = {
-        extractionGoal: extractionGoal.trim(),
-        timestamp: Date.now(),
-      };
-      
-      console.log("🤖 Sending extraction step request:", payload);
-      console.log("📊 Current workflow stats:", stats);
-      console.log("📝 Current workflow:", workflow);
-      console.log("🔴 Recording status:", recordingStatus);
-      
-      // Set up a timeout to handle potential message port issues
-      let timeoutId: NodeJS.Timeout;
-      let responseReceived = false;
-      
-      const timeoutPromise = new Promise((_, reject) => {
-        timeoutId = setTimeout(() => {
-          if (!responseReceived) {
-            reject(new Error("Request timeout - no response received within 5 seconds"));
-          }
-        }, 5000);
-      });
-      
-      // Send extraction step to background script
-      chrome.runtime.sendMessage({
-        type: "ADD_EXTRACTION_STEP",
-        payload: payload
-      }, (response) => {
-        responseReceived = true;
-        clearTimeout(timeoutId);
-        
-        console.log("📨 Extraction step response:", response);
-        
-        if (chrome.runtime.lastError) {
-          console.error("❌ Chrome runtime error:", chrome.runtime.lastError);
-          alert(`Chrome runtime error: ${chrome.runtime.lastError.message}\n\nTry reloading the extension and starting a new recording.`);
-          return;
-        }
-        
-        if (response?.status === "added") {
-          console.log("✅ Extraction step added successfully");
-          setExtractionGoal("");
-          setShowExtractionDialog(false);
-        } else {
-          console.error("❌ Failed to add extraction step:", response);
-          const errorMessage = response?.message || 'Unknown error';
-          alert(`Failed to add extraction step: ${errorMessage}`);
-        }
-      });
-      
-      // Handle timeout case
-      timeoutPromise.catch((error) => {
-        if (!responseReceived) {
-          console.error("❌ Request timeout:", error);
-          alert("Request timed out. Please try again or reload the extension.");
-        }
-      });
-      
-    } else {
-      console.warn("⚠️ Extraction goal is empty");
-    }
-  };
-
-  // Get workflow stats
-  const stats = React.useMemo(() => {
-    if (!workflow?.steps) return { actions: 0, extractions: 0, navigations: 0 };
-    
-    const actions = workflow.steps.filter(s => ['click', 'input', 'key_press'].includes(s.type)).length;
-    const extractions = workflow.steps.filter(s => (s as any).type === 'extract').length;
-    const navigations = workflow.steps.filter(s => s.type === 'navigation').length;
-    
-    return { actions, extractions, navigations };
-  }, [workflow?.steps]);
 
   return (
-    <div className="flex flex-col h-full bg-white">
-      {/* Header */}
-      <div className="flex items-center justify-between p-3 border-b border-gray-200 bg-white">
-        <div className="flex items-center space-x-3">
+    <div className="flex flex-col h-full">
+      <div className="flex items-center justify-between p-4 border-b border-border">
+        <div className="flex items-center space-x-2">
           <span className="relative flex h-3 w-3">
             <span className="animate-ping absolute inline-flex h-full w-full rounded-full bg-red-400 opacity-75"></span>
             <span className="relative inline-flex rounded-full h-3 w-3 bg-red-500"></span>
           </span>
-          <div>
-            <span className="text-sm font-medium text-gray-900">
-              Recording ({stepCount} steps)
-            </span>
-            <div className="text-xs text-gray-500">
-              {stats.actions} actions • {stats.navigations} nav • {stats.extractions} AI extractions
-            </div>
-            {/* Debug status */}
-            <div className="text-xs text-blue-600 font-mono">
-              Status: {recordingStatus}
-            </div>
-          </div>
+          <span className="text-sm font-medium">
+            Recording ({stepCount} steps)
+          </span>
         </div>
-        <div className="flex space-x-2">
-          <Button 
-            variant="outline" 
-            size="sm" 
-            onClick={() => setShowExtractionDialog(true)}
-            className="bg-blue-50 hover:bg-blue-100 text-blue-700 border-blue-200 text-xs px-3 py-1"
-          >
-            🤖 Extract with AI
-          </Button>
-          <Button 
-            variant="destructive" 
-            size="sm" 
-            onClick={stopRecording}
-            className="text-xs px-3 py-1"
-          >
+        <div className="flex items-center gap-2">
+          <Button variant="destructive" size="sm" onClick={stopRecording}>
             Stop Recording
           </Button>
         </div>
       </div>
-      
-      {/* Extraction Dialog */}
-      {showExtractionDialog && (
-        <div className="p-4 bg-blue-50 border-b border-blue-200">
-          <div className="space-y-3">
-            <h3 className="text-sm font-medium text-blue-900">Add AI Extraction Step</h3>
-            <p className="text-xs text-blue-700">
-              Describe what information you want to extract from the current page:
-            </p>
-            <textarea
-              value={extractionGoal}
-              onChange={(e) => setExtractionGoal(e.target.value)}
-              placeholder="e.g., Extract flight prices, departure times, airlines, and booking links from the search results page"
-              className="w-full p-2 text-sm border border-blue-200 rounded resize-none focus:outline-none focus:ring-1 focus:ring-blue-500 focus:border-blue-500"
-              rows={3}
-            />
-            <div className="flex space-x-2">
-              <Button 
-                size="sm" 
-                onClick={handleAddExtraction}
-                disabled={!extractionGoal.trim()}
-                className="text-xs px-3 py-1"
-              >
-                Add Extraction
-              </Button>
-              <Button 
-                variant="outline" 
-                size="sm" 
-                onClick={() => {
-                  setShowExtractionDialog(false);
-                  setExtractionGoal("");
-                }}
-                className="text-xs px-3 py-1"
-              >
-                Cancel
-              </Button>
-            </div>
-            <div className="text-xs text-blue-600 bg-blue-100 p-2 rounded">
-              💡 Tip: Be specific about what data you want (prices, dates, names, etc.) and the format you prefer
-            </div>
-          </div>
-        </div>
-      )}
-
-      {/* Workflow preview/tips */}
-      {stepCount > 0 && (
-        <div className="px-4 py-2 bg-gray-50 border-b text-xs text-gray-600">
-          <div className="flex items-center justify-between">
-            <span className="flex items-center space-x-1">
-              {stats.navigations > 0 && <span>🧭 Navigation</span>}
-              {stats.actions > 0 && <span>→ 🖱️ {stats.actions} interactions</span>}
-              {stats.extractions > 0 && <span>→ 🤖 {stats.extractions} AI extractions</span>}
-            </span>
-            {stepCount >= 3 && stats.extractions === 0 && (
-              <span className="text-blue-600 font-medium">
-                💡 Add AI extraction to capture data
-              </span>
-            )}
-          </div>
-        </div>
-      )}
-      
-      {/* Event Viewer */}
       <div className="flex-grow overflow-hidden p-4">
         <EventViewer />
       </div>
diff --git a/extension/src/lib/types.ts b/extension/src/lib/types.ts
index 8b1db99..e0438f4 100644
--- a/extension/src/lib/types.ts
+++ b/extension/src/lib/types.ts
@@ -2,6 +2,7 @@ export interface StoredCustomClickEvent {
   timestamp: number;
   url: string;
   frameUrl: string;
+  frameIdPath?: string;
   xpath: string;
   cssSelector?: string;
   elementTag: string;
@@ -16,6 +17,7 @@ export interface StoredCustomInputEvent {
   timestamp: number;
   url: string;
   frameUrl: string;
+  frameIdPath?: string;
   xpath: string;
   cssSelector?: string;
   elementTag: string;
@@ -30,6 +32,7 @@ export interface StoredCustomSelectEvent {
   timestamp: number;
   url: string;
   frameUrl: string;
+  frameIdPath?: string;
   xpath: string;
   cssSelector?: string;
   elementTag: string;
@@ -44,6 +47,7 @@ export interface StoredCustomKeyEvent {
   timestamp: number;
   url: string;
   frameUrl: string;
+  frameIdPath?: string;
   key: string;
   xpath?: string; // XPath of focused element
   cssSelector?: string;
@@ -84,6 +88,7 @@ export interface StoredRrwebEvent {
   data: any;
   timestamp: number;
   tabId: number;
+  frameUrl?: string; // URL of the frame where the rrweb event originated (when injected per-frame)
   messageType: "RRWEB_EVENT";
 }
 
diff --git a/extension/src/lib/workflow-types.ts b/extension/src/lib/workflow-types.ts
index 54e16e5..05e2c05 100644
--- a/extension/src/lib/workflow-types.ts
+++ b/extension/src/lib/workflow-types.ts
@@ -39,12 +39,14 @@ export interface NavigationStep extends BaseStep {
   type: "navigation";
   url: string; // Navigation implies a URL change
   screenshot?: string; // Optional in source
+  frameIdPath?: string; // Optional frame context
 }
 
 export interface ClickStep extends BaseStep {
   type: "click";
   url: string;
   frameUrl: string;
+  frameIdPath?: string;
   xpath: string;
   cssSelector?: string; // Optional in source
   elementTag: string;
@@ -58,6 +60,7 @@ export interface InputStep extends BaseStep {
   type: "input";
   url: string;
   frameUrl: string;
+  frameIdPath?: string;
   xpath: string;
   cssSelector?: string; // Optional in source
   elementTag: string;
@@ -70,6 +73,7 @@ export interface KeyPressStep extends BaseStep {
   type: "key_press";
   url?: string; // Can be missing if key press happens without element focus? Source is optional.
   frameUrl?: string; // Might be missing
+  frameIdPath?: string;
   key: string;
   xpath?: string; // Optional in source
   cssSelector?: string; // Optional in source
@@ -82,6 +86,7 @@ export interface ScrollStep extends BaseStep {
   targetId: number; // The rrweb ID of the element being scrolled
   scrollX: number;
   scrollY: number;
+  frameIdPath?: string;
   // Note: url might be missing if scroll happens on initial load before meta event?
 }
 
diff --git a/extension/wxt.config.ts b/extension/wxt.config.ts
index 9d7ae4e..83bf64d 100644
--- a/extension/wxt.config.ts
+++ b/extension/wxt.config.ts
@@ -13,9 +13,15 @@ export default defineConfig({
       // WXT-specific overrides (optional)
     }),
   manifest: {
-    permissions: ["tabs", "sidePanel", "<all_urls>"],
-    host_permissions: ["http://127.0.0.1/*"],
-    // options_page: "options.html",
+    permissions: ["tabs", "sidePanel", "storage", "<all_urls>"],
+    // Broaden host permissions so content script can inject into iframes on external sites.
+    // Note: <all_urls> in permissions allows some access, but host_permissions explicitly grants injection rights.
+    host_permissions: [
+      "http://127.0.0.1/*",
+      "https://*/*",
+      "http://*/*"
+    ],
+    options_page: "options.html",
     // action: {
     //   default_popup: "popup.html",
     // },
diff --git a/workflows/examples/test_iframes.json b/workflows/examples/test_iframes.json
new file mode 100644
index 0000000..b183435
--- /dev/null
+++ b/workflows/examples/test_iframes.json
@@ -0,0 +1,101 @@
+{
+  "name": "Recorded Workflow",
+  "description": "Recorded on 8/11/2025, 4:20:47 AM",
+  "version": "1.0.0",
+  "input_schema": [],
+  "steps": [
+    {
+      "type": "navigation",
+      "timestamp": 1754866228439,
+      "tabId": 388342781,
+      "url": "https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_iframe"
+    },
+    {
+      "type": "scroll",
+      "timestamp": 1754866228608,
+      "tabId": 388342781,
+      "targetId": 219,
+      "scrollX": 0,
+      "scrollY": 7,
+      "url": "https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_iframe"
+    },
+    {
+      "type": "navigation",
+      "timestamp": 1754866228634,
+      "tabId": 388342781,
+      "url": "https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_iframe"
+    },
+    {
+      "type": "click",
+      "timestamp": 1754866228849,
+      "tabId": 388342781,
+      "url": "https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_iframe",
+      "frameUrl": "https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_iframe",
+      "frameIdPath": "0",
+      "xpath": "id(\"textareawrapper\")/div[1]/div[6]",
+      "cssSelector": "div.CodeMirror-scroll",
+      "elementTag": "DIV",
+      "elementText": "<!DOCTYPE html><html><body>​<h1>The iframe element</h1>​<iframe src=\"https://www.w3schools.com\" title=\"W3Schools Free Online Web Tutorials\"></iframe>​</body></html>​"
+    },
+    {
+      "type": "navigation",
+      "timestamp": 1754866230495,
+      "tabId": 388342781,
+      "url": "https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_iframe"
+    },
+    {
+      "type": "click",
+      "timestamp": 1754866231531,
+      "tabId": 388342781,
+      "url": "https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_iframe",
+      "frameUrl": "https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_iframe",
+      "frameIdPath": "0",
+      "xpath": "body/div[2]/div[1]/a[4]",
+      "cssSelector": "a.w3-button.w3-bar-item.w3-hide-small.topnav-icons.fa.fa-rotate.ga-tryit[href=\"javascript:void(0);\"][title*=\"Change Orientation\"]",
+      "elementTag": "A",
+      "elementText": ""
+    },
+    {
+      "type": "navigation",
+      "timestamp": 1754866237707,
+      "tabId": 388342781,
+      "url": "https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_iframe"
+    },
+    {
+      "type": "click",
+      "timestamp": 1754866238574,
+      "tabId": 388342781,
+      "url": "https://www.w3schools.com/",
+      "frameUrl": "https://www.w3schools.com/",
+      "frameIdPath": "0.0",
+      "xpath": "id(\"subtopnav\")/a[3]",
+      "cssSelector": "a.ga-nav[href=\"/js/default.asp\"][title*=\"JavaScript Tutorial\"]",
+      "elementTag": "A",
+      "elementText": "JAVASCRIPT"
+    },
+    {
+      "type": "navigation",
+      "timestamp": 1754866242778,
+      "tabId": 388342781,
+      "url": "https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_iframe"
+    },
+    {
+      "type": "click",
+      "timestamp": 1754866242882,
+      "tabId": 388342781,
+      "url": "https://www.w3schools.com/js/default.asp",
+      "frameUrl": "https://www.w3schools.com/js/default.asp",
+      "frameIdPath": "0.0",
+      "xpath": "id(\"subtopnav\")/a[1]",
+      "cssSelector": "a.ga-nav.subtopnav_firstitem[href=\"/html/default.asp\"][title*=\"HTML Tutorial\"]",
+      "elementTag": "A",
+      "elementText": "HTML"
+    },
+    {
+      "type": "navigation",
+      "timestamp": 1754866246395,
+      "tabId": 388342781,
+      "url": "https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_iframe"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/workflows/pyproject.toml b/workflows/pyproject.toml
index e6cd951..befd519 100644
--- a/workflows/pyproject.toml
+++ b/workflows/pyproject.toml
@@ -13,7 +13,7 @@ classifiers = [
 
 dependencies = [
     "aiofiles>=24.1.0",
-    "browser-use>=0.7.9",
+    "browser-use>=0.9.1",
     "fastapi>=0.115.12",
     "fastmcp>=2.3.4",
     "typer>=0.15.3",
diff --git a/workflows/uv.lock b/workflows/uv.lock
index 4c33414..4a2757b 100644
--- a/workflows/uv.lock
+++ b/workflows/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.11"
 resolution-markers = [
     "python_full_version >= '3.13'",
@@ -194,7 +194,7 @@ wheels = [
 
 [[package]]
 name = "browser-use"
-version = "0.7.10"
+version = "0.9.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -209,8 +209,8 @@ dependencies = [
     { name = "google-auth-oauthlib" },
     { name = "google-genai" },
     { name = "groq" },
-    { name = "html2text" },
     { name = "httpx" },
+    { name = "markdownify" },
     { name = "mcp" },
     { name = "ollama" },
     { name = "openai" },
@@ -229,9 +229,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid7" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c1/ee/e4f4c198dbef1f7ad1bbf74259a4e5a8a9802d29c33ebd0dee3d3938bc0d/browser_use-0.7.10.tar.gz", hash = "sha256:f93ce59e06906c12d120360dee4aa33d83618ddf7c9a575dd0ac517d2de7ccbc", size = 334820, upload-time = "2025-09-29T17:51:56.348Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/52/e4/7a878e36de58d84eef2d1c2cc2dcd67f15efc985d5cb66a0de2c56690b6a/browser_use-0.9.1.tar.gz", hash = "sha256:c1529cfe487e0dc627512eeab0554c4afa771cacf64632ddb484c63985c3bf50", size = 404187, upload-time = "2025-10-24T09:55:47.067Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/10/bd/ed34c505661476c8e319000ecde8f78516c60001f50bd36926c2b9f50651/browser_use-0.7.10-py3-none-any.whl", hash = "sha256:669e12571a0c0c4c93e5fd26abf9e2534eb9bacbc510328aedcab795bd8906a9", size = 409141, upload-time = "2025-09-29T17:51:53.224Z" },
+    { url = "https://files.pythonhosted.org/packages/34/1a/1b4b8ff7cbc0a002515d5a2bc96ae827b2e481ccbacce147ef443b0ebeb0/browser_use-0.9.1-py3-none-any.whl", hash = "sha256:4700c40a4cf8397f33797ef1b980b13a86f1f1ca4eb66bbe2d58e5d212e7838a", size = 487156, upload-time = "2025-10-24T09:55:45.477Z" },
 ]
 
 [[package]]
@@ -808,15 +808,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
 ]
 
-[[package]]
-name = "html2text"
-version = "2025.4.15"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f8/27/e158d86ba1e82967cc2f790b0cb02030d4a8bef58e0c79a8590e9678107f/html2text-2025.4.15.tar.gz", hash = "sha256:948a645f8f0bc3abe7fd587019a2197a12436cd73d0d4908af95bfc8da337588", size = 64316, upload-time = "2025-04-15T04:02:30.045Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/84/1a0f9555fd5f2b1c924ff932d99b40a0f8a6b12f6dd625e2a47f415b00ea/html2text-2025.4.15-py3-none-any.whl", hash = "sha256:00569167ffdab3d7767a4cdf589b7f57e777a5ed28d12907d8c58769ec734acc", size = 34656, upload-time = "2025-04-15T04:02:28.44Z" },
-]
-
 [[package]]
 name = "httpcore"
 version = "1.0.9"
@@ -4784,7 +4775,7 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "aiofiles", specifier = ">=24.1.0" },
-    { name = "browser-use", specifier = ">=0.7.9" },
+    { name = "browser-use", specifier = ">=0.9.1" },
     { name = "faiss-cpu", specifier = "==1.10.0" },
     { name = "fastapi", specifier = ">=0.115.12" },
     { name = "fastmcp", specifier = ">=2.3.4" },
diff --git a/workflows/workflow_use/controller/service.py b/workflows/workflow_use/controller/service.py
index 4205a95..7395d7f 100644
--- a/workflows/workflow_use/controller/service.py
+++ b/workflows/workflow_use/controller/service.py
@@ -3,10 +3,11 @@
 
 from browser_use import Browser
 from browser_use.agent.views import ActionResult
-from browser_use.controller import Controller
-from browser_use.llm.base import BaseChatModel
+from browser_use.controller.service import Controller
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.prompts import PromptTemplate
 
-from workflow_use.controller.utils import get_best_element_handle, truncate_selector
+from workflow_use.controller.utils import ElementHandle, get_best_element_handle, truncate_selector
 from workflow_use.controller.views import (
 	ClickElementDeterministicAction,
 	InputTextDeterministicAction,
@@ -19,14 +20,14 @@
 
 logger = logging.getLogger(__name__)
 
-DEFAULT_ACTION_TIMEOUT_MS = 1000
+DEFAULT_ACTION_TIMEOUT_MS = 2500
 
 # List of default actions from browser_use.controller.service.Controller to disable
 # todo: come up with a better way to filter out the actions (filter IN the actions would be much nicer in this case)
 DISABLED_DEFAULT_ACTIONS = [
 	'done',
 	'search_google',
-	'go_to_url',  # I am using this action from the main controller to avoid duplication
+	'go_to_url',
 	'go_back',
 	'wait',
 	'click_element_by_index',
@@ -54,7 +55,6 @@
 
 class WorkflowController(Controller):
 	def __init__(self, *args, **kwargs):
-		# Pass the list of actions to exclude to the base class constructor
 		super().__init__(*args, exclude_actions=DISABLED_DEFAULT_ACTIONS, **kwargs)
 		self.__register_actions()
 
@@ -62,14 +62,8 @@ def __register_actions(self):
 		# Navigate to URL ------------------------------------------------------------
 		@self.registry.action('Manually navigate to URL', param_model=NavigationAction)
 		async def navigation(params: NavigationAction, browser_session: Browser) -> ActionResult:
-			"""Navigate to the given URL."""
-			page = await browser_session.get_current_page()
-			await page.goto(params.url)
-			# Wait for page to load (CDP navigate doesn't wait automatically)
-			import asyncio
-			await asyncio.sleep(2)
-
-			msg = f'🔗  Navigated to URL: {params.url}'
+			await browser_session.navigate_to(params.url)
+			msg = f'Navigated to URL: {params.url}'
 			logger.info(msg)
 			return ActionResult(extracted_content=msg, include_in_memory=True)
 
@@ -80,26 +74,31 @@ async def navigation(params: NavigationAction, browser_session: Browser) -> Acti
 			param_model=ClickElementDeterministicAction,
 		)
 		async def click(params: ClickElementDeterministicAction, browser_session: Browser) -> ActionResult:
-			"""Click the first element matching *params.cssSelector* with fallback mechanisms."""
-			page = await browser_session.get_current_page()
 			original_selector = params.cssSelector
 
-			try:
-				locator, selector_used = await get_best_element_handle(
-					page,
-					params.cssSelector,
-					params,
-					timeout_ms=DEFAULT_ACTION_TIMEOUT_MS,
-				)
-				await locator.click(force=True)
-
-				msg = f'🖱️  Clicked element with CSS selector: {truncate_selector(selector_used)} (original: {truncate_selector(original_selector)})'
-				logger.info(msg)
-				return ActionResult(extracted_content=msg, include_in_memory=True)
-			except Exception as e:
-				error_msg = f'Failed to click element. Original selector: {truncate_selector(original_selector)}. Error: {str(e)}'
-				logger.error(error_msg)
-				raise Exception(error_msg)
+			page = await browser_session.must_get_current_page()
+			current_url = (await page.get_url() or '').split('#')[0]
+			declared_url = (getattr(params, 'url', None) or '').split('#')[0]
+			has_frame_hints = bool(getattr(params, 'frameIdPath', None) or getattr(params, 'frameUrl', None))
+
+			if declared_url and declared_url.startswith('http') and not has_frame_hints and declared_url != current_url:
+				await browser_session.navigate_to(declared_url)
+
+			handle: ElementHandle = await get_best_element_handle(
+				browser_session,
+				params.cssSelector,
+				params,
+				timeout_ms=DEFAULT_ACTION_TIMEOUT_MS,
+			)
+
+			await handle.element.click()
+
+			msg = (
+				f'Clicked element with CSS selector: {truncate_selector(handle.selector_used)} '
+				f'(original: {truncate_selector(original_selector)})'
+			)
+			logger.info(msg)
+			return ActionResult(extracted_content=msg, include_in_memory=True)
 
 		# Input text into element --------------------------------------------------------
 		@self.registry.action(
@@ -111,39 +110,25 @@ async def input(
 			browser_session: Browser,
 			has_sensitive_data: bool = False,
 		) -> ActionResult:
-			"""Fill text into the element located with *params.cssSelector*."""
-			page = await browser_session.get_current_page()
 			original_selector = params.cssSelector
 
-			try:
-				locator, selector_used = await get_best_element_handle(
-					page,
-					params.cssSelector,
-					params,
-					timeout_ms=DEFAULT_ACTION_TIMEOUT_MS,
-				)
-
-				# Check if it's a SELECT element
-				is_select = await locator.evaluate('(el) => el.tagName === "SELECT"')
-				if is_select:
-					return ActionResult(
-						extracted_content='Ignored input into select element',
-						include_in_memory=True,
-					)
-
-				# Add a small delay and click to ensure the element is focused
-				await locator.fill(params.value)
-				await asyncio.sleep(0.5)
-				await locator.click(force=True)
-				await asyncio.sleep(0.5)
-
-				msg = f'⌨️  Input "{params.value}" into element with CSS selector: {truncate_selector(selector_used)} (original: {truncate_selector(original_selector)})'
-				logger.info(msg)
-				return ActionResult(extracted_content=msg, include_in_memory=True)
-			except Exception as e:
-				error_msg = f'Failed to input text. Original selector: {truncate_selector(original_selector)}. Error: {str(e)}'
-				logger.error(error_msg)
-				raise Exception(error_msg)
+			handle: ElementHandle = await get_best_element_handle(
+				browser_session,
+				params.cssSelector,
+				params,
+				timeout_ms=DEFAULT_ACTION_TIMEOUT_MS,
+			)
+
+			await handle.element.fill(params.value)
+			# Allow UI time to reflect the change and avoid flakiness
+			await asyncio.sleep(0.2)
+
+			msg = (
+				f'Input "{params.value}" into element with CSS selector: {truncate_selector(handle.selector_used)} '
+				f'(original: {truncate_selector(original_selector)})'
+			)
+			logger.info(msg)
+			return ActionResult(extracted_content=msg, include_in_memory=True)
 
 		# Select dropdown option ---------------------------------------------------------
 		@self.registry.action(
@@ -151,27 +136,23 @@ async def input(
 			param_model=SelectDropdownOptionDeterministicAction,
 		)
 		async def select_change(params: SelectDropdownOptionDeterministicAction, browser_session: Browser) -> ActionResult:
-			"""Select dropdown option whose visible text equals *params.value*."""
-			page = await browser_session.get_current_page()
 			original_selector = params.cssSelector
 
-			try:
-				locator, selector_used = await get_best_element_handle(
-					page,
-					params.cssSelector,
-					params,
-					timeout_ms=DEFAULT_ACTION_TIMEOUT_MS,
-				)
+			handle: ElementHandle = await get_best_element_handle(
+				browser_session,
+				params.cssSelector,
+				params,
+				timeout_ms=DEFAULT_ACTION_TIMEOUT_MS,
+			)
 
-				await locator.select_option(label=params.selectedText)
+			await handle.element.select_option(label=params.selectedText)
 
-				msg = f'Selected option "{params.selectedText}" in dropdown {truncate_selector(selector_used)} (original: {truncate_selector(original_selector)})'
-				logger.info(msg)
-				return ActionResult(extracted_content=msg, include_in_memory=True)
-			except Exception as e:
-				error_msg = f'Failed to select option. Original selector: {truncate_selector(original_selector)}. Error: {str(e)}'
-				logger.error(error_msg)
-				raise Exception(error_msg)
+			msg = (
+				f'Selected option "{params.selectedText}" in dropdown {truncate_selector(handle.selector_used)} '
+				f'(original: {truncate_selector(original_selector)})'
+			)
+			logger.info(msg)
+			return ActionResult(extracted_content=msg, include_in_memory=True)
 
 		# Key press action ------------------------------------------------------------
 		@self.registry.action(
@@ -179,35 +160,36 @@ async def select_change(params: SelectDropdownOptionDeterministicAction, browser
 			param_model=KeyPressDeterministicAction,
 		)
 		async def key_press(params: KeyPressDeterministicAction, browser_session: Browser) -> ActionResult:
-			"""Press *params.key* on the element identified by *params.cssSelector*."""
-			page = await browser_session.get_current_page()
 			original_selector = params.cssSelector
 
-			try:
-				locator, selector_used = await get_best_element_handle(page, params.cssSelector, params, timeout_ms=5000)
-
-				await locator.press(params.key)
-
-				msg = f"🔑  Pressed key '{params.key}' on element with CSS selector: {truncate_selector(selector_used)} (original: {truncate_selector(original_selector)})"
-				logger.info(msg)
-				return ActionResult(extracted_content=msg, include_in_memory=True)
-			except Exception as e:
-				error_msg = f'Failed to press key. Original selector: {truncate_selector(original_selector)}. Error: {str(e)}'
-				logger.error(error_msg)
-				raise Exception(error_msg)
+			handle: ElementHandle = await get_best_element_handle(
+				browser_session,
+				params.cssSelector,
+				params,
+				timeout_ms=5000,
+			)
+
+			await handle.element.focus()
+			page = handle.frame_context.create_page()
+			await page.press(params.key)
+
+			msg = (
+				f"Pressed key '{params.key}' on element with CSS selector: "
+				f'{truncate_selector(handle.selector_used)} (original: {truncate_selector(original_selector)})'
+			)
+			logger.info(msg)
+			return ActionResult(extracted_content=msg, include_in_memory=True)
 
 		# Scroll action --------------------------------------------------------------
 		@self.registry.action('Scroll page', param_model=ScrollDeterministicAction)
 		async def scroll(params: ScrollDeterministicAction, browser_session: Browser) -> ActionResult:
-			"""Scroll the page by the given x/y pixel offsets."""
-			page = await browser_session.get_current_page()
-			await page.evaluate(f'() => window.scrollBy({params.scrollX}, {params.scrollY})')
-			msg = f'📜  Scrolled page by (x={params.scrollX}, y={params.scrollY})'
+			page = await browser_session.must_get_current_page()
+			await page.evaluate('([x, y]) => { window.scrollBy(x, y); }', [params.scrollX, params.scrollY])
+			msg = f'Scrolled page by (x={params.scrollX}, y={params.scrollY})'
 			logger.info(msg)
 			return ActionResult(extracted_content=msg, include_in_memory=True)
 
-			# Extract content ------------------------------------------------------------
-
+		# Extract content ------------------------------------------------------------
 		@self.registry.action(
 			'Extract page content to retrieve specific information from the page, e.g. all company names, a specific description, all information about, links with companies in structured format or simply links',
 			param_model=PageExtractionAction,
@@ -215,27 +197,31 @@ async def scroll(params: ScrollDeterministicAction, browser_session: Browser) ->
 		async def extract_page_content(
 			params: PageExtractionAction, browser_session: Browser, page_extraction_llm: BaseChatModel
 		):
-			page = await browser_session.get_current_page()
+			page = await browser_session.must_get_current_page()
 			import markdownify
 
-			strip = ['a', 'img']
+			try:
+				html = await page.evaluate('() => document.documentElement.outerHTML')
+			except Exception as exc:
+				logger.debug('Failed to capture page HTML via evaluate: %s', exc)
+				html = ''
 
-			# Get page HTML content using CDP evaluate
-			html_content = await page.evaluate('() => document.documentElement.outerHTML')
-			content = markdownify.markdownify(html_content, strip=strip)
+			content = markdownify.markdownify(html, strip=['a', 'img']) if html else ''
 
-			# Note: iframe content extraction is not yet supported in CDP-based implementation
-			# TODO: Implement iframe content extraction using CDP
 
-			prompt = f'Your task is to extract the content of the page. You will be given a page and a goal and you should extract all relevant information around this goal from the page. If the goal is vague, summarize the page. Respond in json format. Extraction goal: {params.goal}, Page: {content}'
+			prompt = (
+				'Your task is to extract the content of the page. You will be given a page and a goal and you should '
+				'extract all relevant information around this goal from the page. If the goal is vague, summarize the '
+				'page. Respond in json format. Extraction goal: {goal}, Page: {page}'
+			)
+			template = PromptTemplate(input_variables=['goal', 'page'], template=prompt)
 			try:
-				from browser_use.llm import UserMessage
-				output = await page_extraction_llm.ainvoke([UserMessage(content=prompt)])
-				msg = f'📄  Extracted from page\n: {output.completion}\n'
+				output = await page_extraction_llm.ainvoke(template.format(goal=params.goal, page=content))
+				msg = f'Extracted from page: {output.content}'
 				logger.info(msg)
 				return ActionResult(extracted_content=msg, include_in_memory=True)
 			except Exception as e:
-				logger.debug(f'Error extracting content: {e}')
-				msg = f'📄  Extracted from page\n: {content}\n'
+				logger.debug('Error extracting content with LLM: %s', e)
+				msg = f'Extracted from page: {content}'
 				logger.info(msg)
 				return ActionResult(extracted_content=msg)
diff --git a/workflows/workflow_use/controller/utils.py b/workflows/workflow_use/controller/utils.py
index fd33980..f206cfe 100644
--- a/workflows/workflow_use/controller/utils.py
+++ b/workflows/workflow_use/controller/utils.py
@@ -1,51 +1,347 @@
+import asyncio
 import logging
 import re
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+from urllib.parse import urlparse
+
+from browser_use.browser.session import BrowserSession, CDPSession
+from browser_use.actor.element import Element
+from browser_use.actor.page import Page
 
 logger = logging.getLogger(__name__)
 
 
+@dataclass
+class FrameContext:
+	browser_session: BrowserSession
+	frame_id: str | None
+	frame_info: dict[str, Any] | None
+	session: CDPSession
+
+	@property
+	def target_id(self) -> str:
+		return self.session.target_id
+
+	def create_page(self) -> Page:
+		return Page(self.browser_session, self.target_id, session_id=self.session.session_id)
+
+
+@dataclass
+class ElementHandle:
+	element: Element
+	selector_used: str
+	frame_context: FrameContext
+
+
 def truncate_selector(selector: str, max_length: int = 35) -> str:
 	"""Truncate a CSS selector to a maximum length, adding ellipsis if truncated."""
 	return selector if len(selector) <= max_length else f'{selector[:max_length]}...'
 
 
-async def get_best_element_handle(page, selector, params=None, timeout_ms=100):
-	"""Find element using stability-ranked selector strategies."""
-	original_selector = selector
-
-	# Generate stability-ranked fallback selectors
-	fallbacks = generate_stable_selectors(selector, params)
+def _safe_get(params: Any, name: str, default: Any = None) -> Any:
+	if params is None:
+		return default
+	if isinstance(params, dict):
+		return params.get(name, default)
+	return getattr(params, name, default)
 
-	# Try all selectors with exponential backoff for timeouts
-	selectors_to_try = [original_selector] + fallbacks
 
-	for try_selector in selectors_to_try:
+def _parse_frame_path(frame_id_path: str | None) -> List[int]:
+	if not frame_id_path or frame_id_path == '0':
+		return []
+	segments: List[int] = []
+	for part in frame_id_path.split('.'):
+		part = part.strip()
+		if not part:
+			continue
 		try:
-			logger.info(f'Trying selector: {truncate_selector(try_selector)}')
-			locator = page.locator(try_selector)
-			await locator.wait_for(state='visible', timeout=timeout_ms)
-			logger.info(f'Found element with selector: {truncate_selector(try_selector)}')
-			return locator, try_selector
-		except Exception as e:
-			logger.error(f'Selector failed: {truncate_selector(try_selector)} with error: {e}')
-
-	# Try XPath as last resort
-	if params and getattr(params, 'xpath', None):
-		xpath = params.xpath
+			segments.append(int(part))
+		except ValueError:
+			logger.debug('Skipping invalid frameIdPath segment: %s', part)
+	return segments
+
+
+def _score_frame_url(frame_url: str | None, target_url: str | None) -> int:
+	if not frame_url or not target_url:
+		return 0
+	try:
+		candidate = urlparse(frame_url)
+		target = urlparse(target_url)
+	except Exception:
+		return 0
+
+	score = 0
+	if (candidate.scheme, candidate.netloc) == (target.scheme, target.netloc):
+		score += 2
+		if candidate.path.startswith(target.path):
+			score += 1
+	if frame_url.startswith(target_url):
+		score += 1
+	return score
+
+
+async def _ensure_agent_focus(browser_session: BrowserSession) -> CDPSession:
+	if browser_session.agent_focus is None:
+		return await browser_session.get_or_create_cdp_session()
+	return browser_session.agent_focus
+
+
+def _find_root_frame(all_frames: dict[str, dict[str, Any]], focus_target_id: str | None) -> Tuple[str | None, dict[str, Any] | None]:
+	if not all_frames:
+		return None, None
+	if focus_target_id:
+		for frame_id, info in all_frames.items():
+			if info.get('parentFrameId') is None and info.get('frameTargetId') == focus_target_id:
+				return frame_id, info
+	for frame_id, info in all_frames.items():
+		if info.get('parentFrameId') is None:
+			return frame_id, info
+	# Fallback: first entry
+	first_id = next(iter(all_frames.keys()))
+	return first_id, all_frames[first_id]
+
+
+def _follow_frame_path(
+	all_frames: dict[str, dict[str, Any]],
+	root_id: str | None,
+	path_segments: List[int],
+) -> Tuple[str | None, dict[str, Any] | None]:
+	if root_id is None:
+		return None, None
+	current_id = root_id
+	current_info = all_frames.get(current_id)
+	for index in path_segments:
+		if not current_info:
+			return None, None
+		children = current_info.get('childFrameIds') or []
+		if 0 <= index < len(children):
+			current_id = children[index]
+			current_info = all_frames.get(current_id)
+		else:
+			logger.debug('Frame path index %s out of range for frame %s', index, current_id)
+			return None, None
+	return current_id, current_info
+
+
+def _find_best_frame_by_url(
+	all_frames: dict[str, dict[str, Any]],
+	prefer_url: str | None,
+	current_id: str | None,
+) -> Tuple[str | None, dict[str, Any] | None]:
+	if not prefer_url or not all_frames:
+		return current_id, all_frames.get(current_id) if current_id else (None, None)
+
+	best_id = current_id
+	best_info = all_frames.get(current_id) if current_id else None
+	best_score = _score_frame_url(best_info.get('url') if best_info else None, prefer_url)
+
+	for frame_id, info in all_frames.items():
+		score = _score_frame_url(info.get('url'), prefer_url)
+		if score > best_score:
+			best_id = frame_id
+			best_info = info
+			best_score = score
+
+	return best_id, best_info
+
+
+async def _build_frame_context(
+	browser_session: BrowserSession,
+	frame_id: str | None,
+	frame_info: dict[str, Any] | None,
+	fallback_session: CDPSession,
+) -> FrameContext:
+	target_id = frame_info.get('frameTargetId') if frame_info else None
+	try:
+		if target_id:
+			session = await browser_session.get_or_create_cdp_session(target_id, focus=False)
+		else:
+			session = fallback_session
+	except Exception as exc:
+		logger.debug('Failed to get CDP session for frame %s (%s), using fallback: %s', frame_id, target_id, exc)
+		session = fallback_session
+
+	return FrameContext(
+		browser_session=browser_session,
+		frame_id=frame_id,
+		frame_info=frame_info,
+		session=session,
+	)
+
+
+async def _resolve_frame_context(
+	browser_session: BrowserSession,
+	params: Any,
+) -> Tuple[FrameContext, dict[str, dict[str, Any]], dict[str, str]]:
+	focus_session = await _ensure_agent_focus(browser_session)
+
+	try:
+		all_frames, target_sessions = await browser_session.get_all_frames()
+	except Exception as exc:
+		logger.debug('Failed to collect frame hierarchy: %s', exc)
+		all_frames, target_sessions = {}, {}
+
+	root_id, root_info = _find_root_frame(all_frames, focus_session.target_id if focus_session else None)
+
+	frame_id_path = _safe_get(params, 'frameIdPath')
+	segments = _parse_frame_path(frame_id_path)
+	if segments:
+		selected_id, selected_info = _follow_frame_path(all_frames, root_id, segments)
+	else:
+		selected_id, selected_info = root_id, root_info
+
+	prefer_url = _safe_get(params, 'frameUrl')
+	if prefer_url:
+		selected_id, selected_info = _find_best_frame_by_url(all_frames, prefer_url, selected_id)
+
+	if not selected_id and not selected_info:
+		selected_id, selected_info = root_id, root_info
+
+	frame_ctx = await _build_frame_context(browser_session, selected_id, selected_info, focus_session)
+	return frame_ctx, all_frames, target_sessions
+
+
+async def _query_selector_in_frame(frame_ctx: FrameContext, selector: str) -> Element | None:
+	session = frame_ctx.session
+	params: Dict[str, Any] = {'depth': 1}
+	if frame_ctx.frame_id:
+		params['frameId'] = frame_ctx.frame_id
+	try:
+		document = await session.cdp_client.send.DOM.getDocument(params=params, session_id=session.session_id)
+	except Exception:
+		# Fall back to default document retrieval if frame-specific query fails
+		document = await session.cdp_client.send.DOM.getDocument(session_id=session.session_id)
+
+	root_node_id = document.get('root', {}).get('nodeId')
+	if root_node_id is None:
+		return None
+
+	query = await session.cdp_client.send.DOM.querySelector(
+		params={'nodeId': root_node_id, 'selector': selector},
+		session_id=session.session_id,
+	)
+	node_id = query.get('nodeId')
+	if not node_id:
+		return None
+
+	describe = await session.cdp_client.send.DOM.describeNode({'nodeId': node_id}, session_id=session.session_id)
+	backend_node_id = describe.get('node', {}).get('backendNodeId')
+	if backend_node_id is None:
+		return None
+
+	return Element(frame_ctx.browser_session, backend_node_id, session.session_id)
+
+
+async def _is_element_visible(element: Element) -> bool:
+	try:
+		bounds = await element.get_bounding_box()
+	except Exception:
+		return False
+	if not bounds:
+		return False
+	return bounds.width > 0 and bounds.height > 0
+
+
+async def _wait_for_visible_element(
+	frame_ctx: FrameContext,
+	selectors: Iterable[str],
+	timeout_ms: int,
+) -> Tuple[Element, str]:
+	selectors_list = list(dict.fromkeys(selectors))
+	loop = asyncio.get_running_loop()
+	deadline = loop.time() + (timeout_ms / 1000)
+
+	while True:
+		remaining = deadline - loop.time()
+		if remaining <= 0:
+			break
+
+		for selector in selectors_list:
+			try:
+				element = await _query_selector_in_frame(frame_ctx, selector)
+			except Exception as exc:
+				logger.debug('Selector %s failed in frame %s: %s', selector, frame_ctx.frame_id, exc)
+				continue
+
+			if element and await _is_element_visible(element):
+				return element, selector
+
+		await asyncio.sleep(min(0.1, max(remaining / 4, 0.05)))
+
+	raise TimeoutError('Timed out waiting for visible element')
+
+
+async def _try_selectors_once(
+	frame_ctx: FrameContext,
+	selectors: Iterable[str],
+) -> Tuple[Element, str] | None:
+	for selector in selectors:
 		try:
-			# Generate stable XPath alternatives
-			xpath_alternatives = [xpath] + generate_stable_xpaths(xpath, params)
-
-			for try_xpath in xpath_alternatives:
-				xpath_selector = f'xpath={try_xpath}'
-				logger.info(f'Trying XPath: {truncate_selector(xpath_selector)}')
-				locator = page.locator(xpath_selector)
-				await locator.wait_for(state='visible', timeout=timeout_ms)
-				return locator, xpath_selector
-		except Exception as e:
-			logger.error(f'All XPaths failed with error: {e}')
-
-	raise Exception(f'Failed to find element. Original: {original_selector}')
+			element = await _query_selector_in_frame(frame_ctx, selector)
+		except Exception:
+			continue
+		if element and await _is_element_visible(element):
+			return element, selector
+	return None
+
+
+async def _collect_other_frame_contexts(
+	browser_session: BrowserSession,
+	current_ctx: FrameContext,
+	all_frames: dict[str, dict[str, Any]],
+	prefer_url: str | None,
+) -> List[FrameContext]:
+	if not all_frames:
+		return []
+
+	seen = set()
+	contexts: List[FrameContext] = []
+	focus_session = await _ensure_agent_focus(browser_session)
+
+	for frame_id, info in sorted(
+		all_frames.items(),
+		key=lambda item: _score_frame_url(item[1].get('url'), prefer_url),
+		reverse=True,
+	):
+		if frame_id == current_ctx.frame_id:
+			continue
+		if frame_id in seen:
+			continue
+		seen.add(frame_id)
+		ctx = await _build_frame_context(browser_session, frame_id, info, focus_session)
+		contexts.append(ctx)
+	return contexts
+
+
+async def get_best_element_handle(
+	browser_session: BrowserSession,
+	selector: str,
+	params: Any | None = None,
+	timeout_ms: int = 100,
+) -> ElementHandle:
+	selectors: List[str] = [selector]
+	selectors.extend(generate_stable_selectors(selector, params))
+	selectors = list(dict.fromkeys(selectors))
+
+	frame_ctx, all_frames, _ = await _resolve_frame_context(browser_session, params)
+
+	try:
+		element, selector_used = await _wait_for_visible_element(frame_ctx, selectors, timeout_ms)
+		return ElementHandle(element=element, selector_used=selector_used, frame_context=frame_ctx)
+	except TimeoutError as exc:
+		logger.debug('Primary frame lookup timed out for selector %s: %s', truncate_selector(selector), exc)
+
+	prefer_url = _safe_get(params, 'frameUrl') or _safe_get(params, 'url')
+
+	other_contexts = await _collect_other_frame_contexts(browser_session, frame_ctx, all_frames, prefer_url)
+	for ctx in other_contexts:
+		result = await _try_selectors_once(ctx, selectors)
+		if result:
+			element, selector_used = result
+			return ElementHandle(element=element, selector_used=selector_used, frame_context=ctx)
+
+	raise Exception(f'Failed to find element. Original selector: {selector}')
 
 
 def generate_stable_selectors(selector, params=None):
diff --git a/workflows/workflow_use/controller/views.py b/workflows/workflow_use/controller/views.py
index 1df0900..ffb25b4 100644
--- a/workflows/workflow_use/controller/views.py
+++ b/workflows/workflow_use/controller/views.py
@@ -13,9 +13,8 @@ class Config:
 
 # Mixin for shared step metadata (timestamp and tab context)
 class StepMeta(_BaseExtra):
-	# timestamp: int
-	# tabId: int
-	pass
+	timestamp: int
+	tabId: int
 
 
 # Common optional fields present in recorder events
@@ -24,6 +23,8 @@ class RecorderBase(StepMeta):
 	elementTag: Optional[str] = None
 	elementText: Optional[str] = None
 	frameUrl: Optional[str] = None
+	frameIdPath: Optional[str] = None
+	url: Optional[str] = None
 	screenshot: Optional[str] = None
 
 
diff --git a/workflows/workflow_use/recorder/service.py b/workflows/workflow_use/recorder/service.py
index 756ca6b..85538f0 100644
--- a/workflows/workflow_use/recorder/service.py
+++ b/workflows/workflow_use/recorder/service.py
@@ -2,6 +2,7 @@
 import json
 import pathlib
 from typing import Optional
+from urllib.parse import urlparse
 
 import uvicorn
 from browser_use import Browser
@@ -84,7 +85,36 @@ async def _capture_and_signal_final_workflow(self, trigger_reason: str):
 		async with self.final_workflow_processed_lock:
 			if not self.final_workflow_processed_flag and self.last_workflow_update_event:
 				print(f'[Service] Capturing final workflow (Trigger: {trigger_reason}).')
-				self.final_workflow_output = self.last_workflow_update_event.payload
+				wf = self.last_workflow_update_event.payload
+				# Backend safety filter: drop about:blank and obvious ad/analytics iframe navigations
+				try:
+					def _step_field(step, field: str):
+						if isinstance(step, dict):
+							return step.get(field)
+						return getattr(step, field, None)
+
+					clean_steps = []
+					for s in wf.steps:
+						st = _step_field(s, 'type')
+						url = _step_field(s, 'url')
+						if st == 'navigation':
+							if not url or url == 'about:blank':
+								continue
+							host = urlparse(url).hostname or ''
+							blocked = any(
+								pat in host for pat in (
+									'doubleclick.net', 'googlesyndication.com', 'googleadservices.com',
+									'amazon-adsystem.com', '2mdn.net', 'recaptcha.google.com', 'recaptcha.net',
+									'googletagmanager.com', 'indexww.com', 'adtrafficquality.google'
+								)
+							)
+							if blocked:
+								continue
+						clean_steps.append(s)
+					wf.steps = clean_steps
+				except Exception as e:
+					print(f'[Service] Backend filter failed: {e}')
+				self.final_workflow_output = wf
 				self.final_workflow_processed_flag = True
 				processed_this_call = True
 
@@ -96,7 +126,7 @@ async def _capture_and_signal_final_workflow(self, trigger_reason: str):
 			if trigger_reason == 'RecordingStoppedEvent' and self.browser:
 				print('[Service] Attempting to close browser due to RecordingStoppedEvent...')
 				try:
-					await self.browser.stop()
+					await self.browser.close()
 					print('[Service] Browser close command issued.')
 				except Exception as e_close:
 					print(f'[Service] Error closing browser on recording stop: {e_close}')
@@ -113,7 +143,6 @@ async def _launch_browser_and_wait(self):
 		print(f'[Service] Using browser user data directory: {USER_DATA_DIR}')
 
 		try:
-			# Create browser profile with extension support
 			profile = BrowserProfile(
 				headless=False,
 				user_data_dir=str(USER_DATA_DIR.resolve()),
@@ -123,10 +152,12 @@ async def _launch_browser_and_wait(self):
 					'--no-default-browser-check',
 					'--no-first-run',
 				],
+				disable_security=True,
+				deterministic_rendering=True,
+				cross_origin_iframes=True,
 				keep_alive=True,
 			)
 
-			# Create and configure browser
 			self.browser = Browser(browser_profile=profile)
 
 			print('[Service] Starting browser with extensions...')
@@ -150,7 +181,7 @@ async def _launch_browser_and_wait(self):
 			print('[Service] Browser task cancelled.')
 			if self.browser:
 				try:
-					await self.browser.stop()
+					await self.browser.close()
 				except:
 					pass  # Best effort
 			raise  # Re-raise to be caught by gather
@@ -218,7 +249,7 @@ async def capture_workflow(self) -> Optional[WorkflowDefinitionSchema]:
 				print('[Service] Ensuring browser is closed in cleanup...')
 				try:
 					self.browser.browser_profile.keep_alive = False
-					await self.browser.stop()
+					await self.browser.close()
 				except Exception as e_browser_close:
 					print(f'[Service] Error closing browser in final cleanup: {e_browser_close}')
 				# self.browser = None
diff --git a/workflows/workflow_use/workflow/service.py b/workflows/workflow_use/workflow/service.py
index e8bedad..0a20fe3 100644
--- a/workflows/workflow_use/workflow/service.py
+++ b/workflows/workflow_use/workflow/service.py
@@ -6,25 +6,32 @@
 import logging
 from pathlib import Path
 from typing import Any, Dict, List, TypeVar
-from typing import cast as _cast
 
 from browser_use import Agent, Browser
 from browser_use.agent.views import ActionResult, AgentHistoryList
-from browser_use.llm.base import BaseChatModel
-from browser_use.llm import SystemMessage, UserMessage
-from pydantic import BaseModel, Field, create_model
+from langchain.agents import AgentExecutor, create_tool_calling_agent
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.tools import StructuredTool
+from pydantic import BaseModel, create_model
 
 from workflow_use.controller.service import WorkflowController
 from workflow_use.controller.utils import get_best_element_handle
 from workflow_use.schema.views import (
 	AgenticWorkflowStep,
+	ClickStep,
 	DeterministicWorkflowStep,
+	InputStep,
+	KeyPressStep,
+	NavigationStep,
+	ScrollStep,
+	SelectChangeStep,
 	WorkflowDefinitionSchema,
 	WorkflowInputSchemaDefinition,
 	WorkflowStep,
 )
-from workflow_use.workflow.prompts import AGENT_STEP_SYSTEM_PROMPT, STRUCTURED_OUTPUT_PROMPT
-from workflow_use.workflow.step_agent.controller import WorkflowStepAgentController
+from workflow_use.workflow.prompts import STRUCTURED_OUTPUT_PROMPT, WORKFLOW_FALLBACK_PROMPT_TEMPLATE
 from workflow_use.workflow.views import WorkflowRunOutput
 
 logger = logging.getLogger(__name__)
@@ -40,13 +47,12 @@ class Workflow:
 	def __init__(
 		self,
 		workflow_schema: WorkflowDefinitionSchema,
-		llm: BaseChatModel,
 		*,
 		controller: WorkflowController | None = None,
 		browser: Browser | None = None,
+		llm: BaseChatModel | None = None,
 		page_extraction_llm: BaseChatModel | None = None,
 		fallback_to_agent: bool = True,
-		use_cloud: bool = False,
 	) -> None:
 		"""Initialize a new Workflow instance from a schema object.
 
@@ -56,16 +62,21 @@ def __init__(
 			browser: Optional Browser instance to use for browser automation
 			llm: Optional language model for fallback agent functionality
 			fallback_to_agent: Whether to fall back to agent-based execution on step failure
-			use_cloud: Whether to use browser-use cloud browser service instead of local browser
 
 		Raises:
 			ValueError: If the workflow schema is invalid (though Pydantic handles most).
 		"""
 		self.schema = workflow_schema  # Store the schema object
 
+		self.name = self.schema.name
+		self.description = self.schema.description
+		self.version = self.schema.version
+		self.steps = self.schema.steps
+
 		self.controller = controller or WorkflowController()
 
-		self.browser = browser or Browser(use_cloud=use_cloud)
+		self.browser = browser or Browser()
+		self.browser.browser_profile.cross_origin_iframes = True
 
 		# Hack to not close it after agent kicks in
 		self.browser.browser_profile.keep_alive = True
@@ -85,12 +96,11 @@ def __init__(
 	def load_from_file(
 		cls,
 		file_path: str | Path,
-		llm: BaseChatModel,
 		*,
 		controller: WorkflowController | None = None,
 		browser: Browser | None = None,
+		llm: BaseChatModel | None = None,
 		page_extraction_llm: BaseChatModel | None = None,
-		use_cloud: bool = False,
 	) -> Workflow:
 		"""Load a workflow from a file."""
 		with open(file_path, 'r', encoding='utf-8') as f:
@@ -102,7 +112,6 @@ def load_from_file(
 			browser=browser,
 			llm=llm,
 			page_extraction_llm=page_extraction_llm,
-			use_cloud=use_cloud,
 		)
 
 	# --- Runners ---
@@ -127,167 +136,125 @@ def truncate_selector(selector: str) -> str:
 
 		# Determine if this is not the last step, and extract next step's cssSelector if available
 		current_index = step_index
-		if current_index < len(self.schema.steps) - 1:
-			next_step = self.schema.steps[current_index + 1]
+		if current_index < len(self.steps) - 1:
+			next_step = self.steps[current_index + 1]
 			next_step_resolved = self._resolve_placeholders(next_step)
 			css_selector = getattr(next_step_resolved, 'cssSelector', None)
 			if css_selector:
 				try:
-					page = await self.browser.get_current_page()
-
-					logger.info(f'Waiting for element with selector: {truncate_selector(css_selector)}')
-					locator, selector_used = await get_best_element_handle(
-						page, css_selector, next_step_resolved, timeout_ms=WAIT_FOR_ELEMENT_TIMEOUT
-					)
-					logger.info(f'Element with selector found: {truncate_selector(selector_used)}')
+					await self.browser._wait_for_stable_network()
+					page = await self.browser.must_get_current_page()
+
+					# If the next step declares a URL/frameUrl and it does not match the current page URL,
+					# skip waiting for its element on the current page (prevents false failures like step 7).
+					curr_url = (await page.get_url() or '').split('#')[0]
+					declared_next_url = (getattr(next_step_resolved, 'url', None) or getattr(next_step_resolved, 'frameUrl', None) or '').split('#')[0]
+					if declared_next_url and declared_next_url != curr_url:
+						logger.info(
+							f"Skipping pre-wait for next selector because declared next URL ({truncate_selector(declared_next_url)}) != current URL ({truncate_selector(curr_url)})"
+						)
+					else:
+						logger.info(f'Waiting for element with selector: {truncate_selector(css_selector)}')
+						handle = await get_best_element_handle(
+							self.browser, css_selector, next_step_resolved, timeout_ms=WAIT_FOR_ELEMENT_TIMEOUT
+						)
+						logger.info(f'Element with selector found: {truncate_selector(handle.selector_used)}')
 				except Exception as e:
 					logger.error(f'Failed to wait for element with selector: {truncate_selector(css_selector)}. Error: {e}')
 					raise Exception(f'Failed to wait for element. Selector: {css_selector}') from e
 
 		return result
 
-	def _format_agent_step_context(self, current_step: AgenticWorkflowStep, step_index: int) -> str:
-		"""Format the workflow step context for the agent with extended context (last 2, current, next 2 steps)."""
-
-		def format_step_info(step: WorkflowStep, step_num: int) -> str:
-			"""Format step information consistently."""
-			info = [f'Step {step_num}: Type: {step.type}']
-			if step.description:
-				info.append(f'Description: {step.description}')
-			# For agent steps, show the task
-			if isinstance(step, AgenticWorkflowStep):
-				info.append(f'Task: {step.task}')
-			return '\n'.join(info)
-
-		sections = []
-		total_steps = len(self.schema.steps)
-
-		# Add previous steps context (last 2 steps)
-		prev_steps = []
-		for i in range(max(0, step_index - 2), step_index):
-			prev_step = self.schema.steps[i]
-			prev_steps.append(format_step_info(prev_step, i + 1))
-
-		if prev_steps:
-			sections.extend(['=== PREVIOUS STEPS (FOR CONTEXT ONLY) ===', '\n\n'.join(prev_steps), ''])
-
-		# Add current step context
-		sections.extend(['=== CURRENT STEP (YOUR TASK) ===', format_step_info(current_step, step_index + 1), ''])
-
-		# Add next steps context (next 2 steps)
-		next_steps = []
-		for i in range(step_index + 1, min(total_steps, step_index + 3)):
-			next_step = self.schema.steps[i]
-			next_steps.append(format_step_info(next_step, i + 1))
-
-		if next_steps:
-			sections.extend(
-				[
-					'=== NEXT STEPS (FOR CONTEXT ONLY) ===',
-					'\n\n'.join(next_steps),
-				]
-			)
-
-		return '\n'.join(sections)
-
-	async def _run_agent_step(self, step: AgenticWorkflowStep, step_index: int) -> AgentHistoryList:
+	async def _run_agent_step(self, step: AgenticWorkflowStep) -> AgentHistoryList:
 		"""Spin-up an Agent based on step dictionary."""
-		# Create contextual task with extended context (last 2, current, next 2 steps)
-		contextual_task = self._format_agent_step_context(step, step_index)
-
-		# logger.info(f'Contextual task: {contextual_task}')
-
-		# 		task = """
-		# {step.task}
+		if self.llm is None:
+			raise ValueError("An 'llm' instance must be supplied for agent-based steps")
 
-		# Please do not make up any fake data.
-		# """
+		task: str = step.task
+		max_steps: int = step.max_steps or 5
 
 		agent = Agent(
-			task=step.task,  # Only the current step task goes into ultimate task
-			message_context=contextual_task,  # Extended context with surrounding steps
+			task=task,
 			llm=self.llm,
 			browser_session=self.browser,
-			controller=WorkflowStepAgentController(),
-			# use_vision=True,  # Consider making this configurable via WorkflowStep schema
-			override_system_message=AGENT_STEP_SYSTEM_PROMPT,
+			use_vision=True,  # Consider making this configurable via WorkflowStep schema
+		)
+		return await agent.run(max_steps=max_steps)
+
+	async def _fallback_to_agent(
+		self,
+		step_resolved: WorkflowStep,
+		step_index: int,
+		error: Exception | str | None = None,
+	) -> AgentHistoryList:
+		"""Handle step failure by delegating to an agent."""
+		if self.llm is None:
+			raise ValueError("Cannot fall back to agent: An 'llm' instance must be supplied")
+		# print('Workflow steps:', step_resolved)
+		# Extract details from the failed step dictionary
+		failed_action_name = step_resolved.type
+		failed_params = step_resolved.model_dump()
+		step_description = step_resolved.description or 'No description provided'
+		error_msg = str(error) if error else 'Unknown error'
+		total_steps = len(self.steps)
+		fail_details = (
+			f"step={step_index + 1}/{total_steps}, action='{failed_action_name}', "
+			f"description='{step_description}', params={str(failed_params)}, error='{error_msg}'"
 		)
 
-		return await agent.run()
-
-	# async def _fallback_to_agent(
-	# 	self,
-	# 	step_resolved: WorkflowStep,
-	# 	step_index: int,
-	# 	error: Exception | str | None = None,
-	# ) -> AgentHistoryList:
-	# 	"""Handle step failure by delegating to an agent."""
-
-	# 	# print('Workflow steps:', step_resolved)
-	# 	# Extract details from the failed step dictionary
-	# 	failed_action_name = step_resolved.type
-	# 	failed_params = step_resolved.model_dump()
-	# 	step_description = step_resolved.description or 'No description provided'
-	# 	error_msg = str(error) if error else 'Unknown error'
-	# 	total_steps = len(self.steps)
-	# 	fail_details = (
-	# 		f"step={step_index + 1}/{total_steps}, action='{failed_action_name}', "
-	# 		f"description='{step_description}', params={str(failed_params)}, error='{error_msg}'"
-	# 	)
-
-	# 	# Determine the failed_value based on step type and attributes
-	# 	failed_value = None
-	# 	description_prefix = f'Purpose: {step_description}. ' if step_description else ''
-
-	# 	if isinstance(step_resolved, NavigationStep):
-	# 		failed_value = f'{description_prefix}Navigate to URL: {step_resolved.url}'
-	# 	elif isinstance(step_resolved, ClickStep):
-	# 		# element_info = step_resolved.elementText or step_resolved.cssSelector
-	# 		# failed_value = f"{description_prefix}Click element: {element_info}"
-	# 		failed_value = f'Find and click element with description: {step_resolved.description}'
-	# 	elif isinstance(step_resolved, InputStep):
-	# 		failed_value = f"{description_prefix}Input text: '{step_resolved.value}' into element."
-	# 	elif isinstance(step_resolved, SelectChangeStep):
-	# 		failed_value = f"{description_prefix}Select option: '{step_resolved.selectedText}' in dropdown."
-	# 	elif isinstance(step_resolved, KeyPressStep):
-	# 		failed_value = f"{description_prefix}Press key: '{step_resolved.key}'"
-	# 	elif isinstance(step_resolved, ScrollStep):
-	# 		failed_value = f'{description_prefix}Scroll to position: (x={step_resolved.scrollX}, y={step_resolved.scrollY})'
-	# 	else:
-	# 		failed_value = f"{description_prefix}No specific target value available for action '{failed_action_name}'"
-
-	# 	# Build workflow overview using the stored dictionaries
-	# 	workflow_overview_lines: list[str] = []
-	# 	for idx, step in enumerate(self.steps):
-	# 		desc = step.description or ''
-	# 		step_type_info = step.type
-	# 		details = step.model_dump()
-	# 		workflow_overview_lines.append(f'  {idx + 1}. ({step_type_info}) {desc} - {details}')
-	# 	workflow_overview = '\n'.join(workflow_overview_lines)
-	# 	# print(workflow_overview)
-
-	# 	# Build the fallback task with the failed_value
-	# 	fallback_task = WORKFLOW_FALLBACK_PROMPT_TEMPLATE.format(
-	# 		step_index=step_index + 1,
-	# 		total_steps=len(self.steps),
-	# 		workflow_details=workflow_overview,
-	# 		action_type=failed_action_name,
-	# 		fail_details=fail_details,
-	# 		failed_value=failed_value,
-	# 		step_description=step_description,
-	# 	)
-	# 	logger.info(f'Agent fallback task: {fallback_task}')
-
-	# 	# Prepare agent step config based on the failed step, adding task
-	# 	agent_step_config = AgenticWorkflowStep(
-	# 		type='agent',
-	# 		task=fallback_task,
-	# 		max_steps=5,
-	# 		output=None,
-	# 		description='Fallback agent to handle step failure',
-	# 	)
-
-	# 	return await self._run_agent_step(agent_step_config)
+		# Determine the failed_value based on step type and attributes
+		failed_value = None
+		description_prefix = f'Purpose: {step_description}. ' if step_description else ''
+
+		if isinstance(step_resolved, NavigationStep):
+			failed_value = f'{description_prefix}Navigate to URL: {step_resolved.url}'
+		elif isinstance(step_resolved, ClickStep):
+			# element_info = step_resolved.elementText or step_resolved.cssSelector
+			# failed_value = f"{description_prefix}Click element: {element_info}"
+			failed_value = f'Find and click element with description: {step_resolved.description}'
+		elif isinstance(step_resolved, InputStep):
+			failed_value = f"{description_prefix}Input text: '{step_resolved.value}' into element."
+		elif isinstance(step_resolved, SelectChangeStep):
+			failed_value = f"{description_prefix}Select option: '{step_resolved.selectedText}' in dropdown."
+		elif isinstance(step_resolved, KeyPressStep):
+			failed_value = f"{description_prefix}Press key: '{step_resolved.key}'"
+		elif isinstance(step_resolved, ScrollStep):
+			failed_value = f'{description_prefix}Scroll to position: (x={step_resolved.scrollX}, y={step_resolved.scrollY})'
+		else:
+			failed_value = f"{description_prefix}No specific target value available for action '{failed_action_name}'"
+
+		# Build workflow overview using the stored dictionaries
+		workflow_overview_lines: list[str] = []
+		for idx, step in enumerate(self.steps):
+			desc = step.description or ''
+			step_type_info = step.type
+			details = step.model_dump()
+			workflow_overview_lines.append(f'  {idx + 1}. ({step_type_info}) {desc} - {details}')
+		workflow_overview = '\n'.join(workflow_overview_lines)
+		# print(workflow_overview)
+
+		# Build the fallback task with the failed_value
+		fallback_task = WORKFLOW_FALLBACK_PROMPT_TEMPLATE.format(
+			step_index=step_index + 1,
+			total_steps=len(self.steps),
+			workflow_details=workflow_overview,
+			action_type=failed_action_name,
+			fail_details=fail_details,
+			failed_value=failed_value,
+			step_description=step_description,
+		)
+		logger.info(f'Agent fallback task: {fallback_task}')
+
+		# Prepare agent step config based on the failed step, adding task
+		agent_step_config = AgenticWorkflowStep(
+			type='agent',
+			task=fallback_task,
+			max_steps=5,
+			output=None,
+			description='Fallback agent to handle step failure',
+		)
+
+		return await self._run_agent_step(agent_step_config)
 
 	def _validate_inputs(self, inputs: dict[str, Any]) -> None:
 		"""Validate provided inputs against the workflow's input schema definition."""
@@ -421,35 +388,31 @@ async def _execute_step(self, step_index: int, step_resolved: WorkflowStep) -> A
 				logger.warning(
 					f'Deterministic step {step_index + 1} ({action_name}) failed: {e}. Attempting fallback with agent.'
 				)
-
-				raise ValueError(f'Deterministic step {step_index + 1} ({action_name}) failed: {e}')
-
-				# if self.fallback_to_agent:
-				# 	result = await self._fallback_to_agent(step_resolved, step_index, e)
-				# 	if not result.is_successful():
-				# 		raise ValueError(f'Deterministic step {step_index + 1} ({action_name}) failed even after fallback')
-				# else:
-				# 	raise ValueError(f'Deterministic step {step_index + 1} ({action_name}) failed: {e}')
-
+				if self.llm is None:
+					raise ValueError('Cannot fall back to agent: LLM instance required.')
+				if self.fallback_to_agent:
+					result = await self._fallback_to_agent(step_resolved, step_index, e)
+					if not result.is_successful():
+						raise ValueError(f'Deterministic step {step_index + 1} ({action_name}) failed even after fallback')
+				else:
+					raise ValueError(f'Deterministic step {step_index + 1} ({action_name}) failed: {e}')
 		elif isinstance(step_resolved, AgenticWorkflowStep):
 			# Use task key from step dictionary
 			task_description = step_resolved.task
 			logger.info(f'Running agent task: {task_description}')
 			try:
-				result = await self._run_agent_step(step_resolved, step_index)
+				result = await self._run_agent_step(step_resolved)
 				if not result.is_successful():
 					logger.warning(f'Agent step {step_index + 1} failed evaluation.')
 					raise ValueError(f'Agent step {step_index + 1} failed evaluation.')
-
 			except Exception as e:
-				raise ValueError(f'Agent step {step_index + 1} failed: {e}. (Agent fallback is disabled)')
-
 				if self.fallback_to_agent:
 					logger.warning(f'Agent step {step_index + 1} failed: {e}. Attempting fallback with agent.')
-
-					# result = await self._fallback_to_agent(step_resolved, step_index, e)
-					# if not result.is_successful():
-					# 	raise ValueError(f'Agent step {step_index + 1} failed even after fallback')
+					if self.llm is None:
+						raise ValueError('Cannot fall back to agent: LLM instance required.')
+					result = await self._fallback_to_agent(step_resolved, step_index, e)
+					if not result.is_successful():
+						raise ValueError(f'Agent step {step_index + 1} failed even after fallback')
 				else:
 					raise ValueError(f'Agent step {step_index + 1} failed: {e}')
 
@@ -463,7 +426,7 @@ async def _convert_results_to_output_model(
 	) -> T:
 		"""Convert workflow results to a specified output model.
 
-		Filters ActionResults with extracted_content, then uses LLM to parse
+		Filters ActionResults with extracted_content, then uses LangChain to parse
 		all extracted texts into the structured output model.
 
 		Args:
@@ -476,6 +439,9 @@ async def _convert_results_to_output_model(
 		if not results:
 			raise ValueError('No results to convert')
 
+		if self.llm is None:
+			raise ValueError('LLM is required for structured output conversion')
+
 		# Extract all content from ActionResults
 		extracted_contents = []
 
@@ -496,13 +462,15 @@ async def _convert_results_to_output_model(
 		# Combine all extracted contents
 		combined_text = '\n\n'.join(extracted_contents)
 
-		messages = [
+		messages: list[BaseMessage] = [
 			SystemMessage(content=STRUCTURED_OUTPUT_PROMPT),
-			UserMessage(content=combined_text),
+			HumanMessage(content=combined_text),
 		]
 
-		response = await self.llm.ainvoke(messages, output_format=output_model)
-		return response.completion
+		chain = self.llm.with_structured_output(output_model)
+		chain_result: T = await chain.ainvoke(messages)  # type: ignore
+
+		return chain_result
 
 	async def run_step(self, step_index: int, inputs: dict[str, Any] | None = None):
 		"""Run a *single* workflow step asynchronously and return its result.
@@ -516,8 +484,8 @@ async def run_step(self, step_index: int, inputs: dict[str, Any] | None = None):
 				are validated and injected into :pyattr:`context`.  Subsequent
 				calls can omit *inputs* as :pyattr:`context` is already populated.
 		"""
-		if not (0 <= step_index < len(self.schema.steps)):
-			raise IndexError(f'step_index {step_index} is out of range for workflow with {len(self.schema.steps)} steps')
+		if not (0 <= step_index < len(self.steps)):
+			raise IndexError(f'step_index {step_index} is out of range for workflow with {len(self.steps)} steps')
 
 		# Initialise/augment context once with the provided inputs
 		if inputs is not None or not self.context:
@@ -531,7 +499,7 @@ async def run_step(self, step_index: int, inputs: dict[str, Any] | None = None):
 				self.context.update(runtime_inputs)
 
 		async with self.browser:
-			raw_step_cfg = self.schema.steps[step_index]
+			raw_step_cfg = self.steps[step_index]
 			step_resolved = self._resolve_placeholders(raw_step_cfg)
 			result = await self._execute_step(step_index, step_resolved)
 			# Persist outputs (if declared) for future steps
@@ -573,8 +541,9 @@ async def run(
 
 		await self.browser.start()
 		try:
-			for step_index, step_dict in enumerate(self.schema.steps):  # self.steps now holds dictionaries
+			for step_index, step_dict in enumerate(self.steps):  # self.steps now holds dictionaries
 				await asyncio.sleep(0.1)
+				await self.browser._wait_for_stable_network()
 
 				# Check if cancellation was requested
 				if cancel_event and cancel_event.is_set():
@@ -583,7 +552,7 @@ async def run(
 
 				# Use description from the step dictionary
 				step_description = step_dict.description or 'No description provided'
-				logger.info(f'--- Running Step {step_index + 1}/{len(self.schema.steps)} -- {step_description} ---')
+				logger.info(f'--- Running Step {step_index + 1}/{len(self.steps)} -- {step_description} ---')
 				# Resolve placeholders using the current context (works on the dictionary)
 				step_resolved = self._resolve_placeholders(step_dict)
 
@@ -604,67 +573,39 @@ async def run(
 			# Clean-up browser after finishing workflow
 			if close_browser_at_end:
 				self.browser.browser_profile.keep_alive = False
-				await self.browser.stop()
+				await self.browser.close()
 
 		return WorkflowRunOutput(step_results=results, output_model=output_model_result)
 
 	# ------------------------------------------------------------------
-	# LLM tool wrapper
+	# LangChain tool wrapper
 	# ------------------------------------------------------------------
 
 	def _build_input_model(self) -> type[BaseModel]:
-		"""Return a *pydantic* model matching the workflow's ``input_schema`` section.
-
-		This creates a dynamic Pydantic model that includes format information in field
-		descriptions, making format requirements visible to LLMs when workflows are used as tools.
-		"""
-
+		"""Return a *pydantic* model matching the workflow's ``input_schema`` section."""
 		if not self.inputs_def:
 			# No declared inputs -> generate an empty model
 			# Use schema name for uniqueness, fallback if needed
 			model_name = f'{(self.schema.name or "Workflow").replace(" ", "_")}_NoInputs'
 			return create_model(model_name)
 
-		# Map workflow input types to Python types
 		type_mapping = {
 			'string': str,
 			'number': float,
-			'bool': bool,
+			'bool': bool,  # Added boolean type
 		}
-
-		# Build fields dictionary for create_model()
 		fields: Dict[str, tuple[type, Any]] = {}
-
 		for input_def in self.inputs_def:
 			name = input_def.name
 			type_str = input_def.type
 			py_type = type_mapping.get(type_str)
-
 			if py_type is None:
 				raise ValueError(f'Unsupported input type: {type_str!r} for field {name!r}')
-
-			# Create field description with format information if available
-			# This helps LLMs understand expected input formats when workflow is used as a tool
-			field_description = None
-			if hasattr(input_def, 'format') and input_def.format:
-				field_description = f'Format: {input_def.format}'
-
-			# Build field tuple: (type, default_or_field_info)
 			# Pydantic's create_model uses ... (Ellipsis) to mark required fields
-			if input_def.required:
-				if field_description:
-					# Required field with format description
-					fields[name] = (py_type, Field(..., description=field_description))
-				else:
-					# Required field without format description
-					fields[name] = (py_type, ...)
-			else:
-				if field_description:
-					# Optional field with format description
-					fields[name] = (py_type, Field(None, description=field_description))
-				else:
-					# Optional field without format description
-					fields[name] = (py_type, None)
+			default = ... if input_def.required else None
+			fields[name] = (py_type, default)
+
+		from typing import cast as _cast
 
 		# The raw ``create_model`` helper from Pydantic deliberately uses *dynamic*
 		# signatures, which the static type checker cannot easily verify.  We cast
@@ -674,119 +615,65 @@ def _build_input_model(self) -> type[BaseModel]:
 			**_cast(Dict[str, Any], fields),
 		)
 
-	async def run_as_tool(self, prompt: str) -> str:
-		"""Run the workflow with inputs parsed from a natural language prompt.
-
-		Args:
-			prompt: Natural language description of the task and inputs
+	def as_tool(self, *, name: str | None = None, description: str | None = None):  # noqa: D401
+		"""Expose the entire workflow as a LangChain *StructuredTool* instance.
 
-		Returns:
-			JSON string with workflow results
+		The generated tool validates its arguments against the workflow's input
+		schema (if present) and then returns the JSON-serialised output of
+		:py:meth:`run`.
 		"""
-		if self.llm is None:
-			raise ValueError("LLM is required for run_as_tool to parse inputs from prompt")
-
-		# Parse inputs from prompt using LLM
-		input_model = self._build_input_model()
 
-		system_prompt = f"""You are a helpful assistant that extracts workflow input parameters from user prompts.
-The workflow requires the following inputs:
-{json.dumps(input_model.model_json_schema(), indent=2)}
-
-Extract the values from the user's prompt and return them in the required format."""
-
-		messages = [
-			SystemMessage(content=system_prompt),
-			UserMessage(content=prompt)
-		]
-
-		response = await self.llm.ainvoke(messages, output_format=input_model)
-		inputs = response.completion.model_dump()
-
-		# Run the workflow with parsed inputs
-		result = await self.run(inputs=inputs, close_browser_at_end=True)
-
-		# Return results as JSON
-		output = {
-			"success": True,
-			"steps_executed": len(result.step_results),
-			"inputs_used": inputs,
-			"context": self.context
-		}
-
-		return json.dumps(output, indent=2)
-
-	async def run_with_no_ai(
-		self,
-		inputs: dict[str, Any] | None = None,
-		close_browser_at_end: bool = True,
-		cancel_event: asyncio.Event | None = None,
-		output_model: type[T] | None = None,
-	) -> WorkflowRunOutput[T]:
-		"""Execute the workflow using semantic abstraction without any AI/LLM involvement.
-
-		This method uses semantic mapping to convert visible text to deterministic selectors,
-		avoiding expensive LLM calls and fragile CSS selectors.
+		InputModel = self._build_input_model()
+		# Use schema name as default, sanitize for tool name requirements
+		default_name = ''.join(c if c.isalnum() else '_' for c in self.name)
+		tool_name = name or default_name[:50]
+		doc = description or self.description  # Use schema description
+
+		# `self` is closed over via the inner function so we can keep state.
+		async def _invoke(**kwargs):  # type: ignore[override]
+			logger.info(f'Running workflow as tool with inputs: {kwargs}')
+			augmented_inputs = kwargs.copy() if kwargs else {}
+			for input_def in self.inputs_def:
+				if not input_def.required and input_def.name not in augmented_inputs:
+					augmented_inputs[input_def.name] = None
+			result = await self.run(inputs=augmented_inputs)
+			# Serialise non-string output so models that expect a string tool
+			# response still work.
+			try:
+				return _json.dumps(result, default=str)
+			except Exception:
+				return str(result)
 
-		Args:
-			inputs: Optional dictionary of workflow inputs
-			close_browser_at_end: Whether to close the browser when done
-			cancel_event: Optional event to signal cancellation
-			output_model: Optional Pydantic model class to convert results to
+		return StructuredTool.from_function(
+			coroutine=_invoke,
+			name=tool_name,
+			description=doc,
+			args_schema=InputModel,
+		)
 
-		Returns:
-			WorkflowRunOutput containing all step results
+	async def run_as_tool(self, prompt: str) -> str:
 		"""
-		from workflow_use.workflow.semantic_executor import SemanticWorkflowExecutor
-
-		runtime_inputs = inputs or {}
-		# 1. Validate inputs against definition
-		self._validate_inputs(runtime_inputs)
-		# 2. Initialize context with validated inputs
-		self.context = runtime_inputs.copy()  # Start with a fresh context
-
-		results: List[ActionResult | AgentHistoryList] = []
-
-		await self.browser.start()
-		semantic_executor = SemanticWorkflowExecutor(self.browser, page_extraction_llm=self.page_extraction_llm)
-
-		try:
-			for step_index, step_dict in enumerate(self.schema.steps):
-				await asyncio.sleep(0.1)
+		Run the workflow with a prompt and automatically parse the required variables.
 
-				# Check if cancellation was requested
-				if cancel_event and cancel_event.is_set():
-					logger.info('Cancellation requested - stopping workflow execution')
-					break
-
-				# Use description from the step dictionary
-				step_description = step_dict.description or 'No description provided'
-				logger.info(f'--- Running Step {step_index + 1}/{len(self.schema.steps)} -- {step_description} ---')
-
-				# Resolve placeholders using the current context (works on the dictionary)
-				step_resolved = self._resolve_placeholders(step_dict)
-
-				# Only process deterministic steps (no agent steps)
-				if step_resolved.type == 'agent':
-					raise Exception(f"Agent steps are not supported in run_with_no_ai mode. Step {step_index + 1} is an agent step.")
-
-				# Execute step using semantic executor
-				result = await semantic_executor.execute_step(step_resolved)
-
-				results.append(result)
-				# Persist outputs using the resolved step dictionary
-				self._store_output(step_resolved, result)
-				logger.info(f'--- Finished Step {step_index + 1} ---\n')
-
-			# Convert results to output model if requested
-			output_model_result: T | None = None
-			if output_model:
-				output_model_result = await self._convert_results_to_output_model(results, output_model)
+		@dev Uses AgentExecutor to properly handle the tool invocation loop.
+		"""
 
-		finally:
-			# Clean-up browser after finishing workflow
-			if close_browser_at_end:
-				self.browser.browser_profile.keep_alive = False
-				await self.browser.stop()
+		# For now I kept it simple but one could think of using a react agent here.
+		if self.llm is None:
+			raise ValueError("Cannot run as tool: An 'llm' instance must be supplied for tool-based steps")
+
+		prompt_template = ChatPromptTemplate.from_messages(
+			[
+				('system', 'You are a helpful assistant'),
+				('human', '{input}'),
+				# Placeholders fill up a **list** of messages
+				('placeholder', '{agent_scratchpad}'),
+			]
+		)
 
-		return WorkflowRunOutput(step_results=results, output_model=output_model_result)
+		# Create the workflow tool
+		workflow_tool = self.as_tool()
+		agent = create_tool_calling_agent(self.llm, [workflow_tool], prompt_template)
+		agent_executor = AgentExecutor(agent=agent, tools=[workflow_tool])
+		result = await agent_executor.ainvoke({'input': prompt})
+		return result['output']