diff --git a/app/api/agent/stream/route.ts b/app/api/agent/stream/route.ts
index 79a3f0c..62ae5be 100644
--- a/app/api/agent/stream/route.ts
+++ b/app/api/agent/stream/route.ts
@@ -8,7 +8,9 @@ export const maxDuration = 600;
 
 function sseEncode(event: string, data: unknown): Uint8Array {
   const encoder = new TextEncoder();
-  return encoder.encode(`event: ${event}\n` + `data: ${JSON.stringify(data)}\n\n`);
+  return encoder.encode(
+    `event: ${event}\n` + `data: ${JSON.stringify(data)}\n\n`
+  );
 }
 
 function sseComment(comment: string): Uint8Array {
@@ -18,7 +20,11 @@ function sseComment(comment: string): Uint8Array {
 
 export async function GET(request: Request) {
   const { searchParams } = new URL(request.url);
-  const [sessionId, goal] = [searchParams.get("sessionId"), searchParams.get("goal")];
+  const [sessionId, goal, fromChat] = [
+    searchParams.get("sessionId"),
+    searchParams.get("goal"),
+    searchParams.get("fromChat") === "true",
+  ];
 
   if (!sessionId || !goal) {
     return new Response(
@@ -39,11 +45,14 @@ export async function GET(request: Request) {
       }, 15000);
 
       let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
-      timeoutTimer = setTimeout(async () => {
-        console.log(`[SSE] Timeout reached for session ${sessionId}`);
-        send("error", { message: "Agent run timed out after 10 minutes" });
-        await cleanup();
-      }, 10 * 60 * 1000);
+      timeoutTimer = setTimeout(
+        async () => {
+          console.log(`[SSE] Timeout reached for session ${sessionId}`);
+          send("error", { message: "Agent run timed out after 10 minutes" });
+          await cleanup();
+        },
+        10 * 60 * 1000
+      );
 
       let closed = false;
 
@@ -52,7 +61,10 @@ export async function GET(request: Request) {
         try {
           controller.enqueue(chunk);
         } catch (err) {
-          console.error(`[SSE] enqueue error`, err instanceof Error ? err.message : String(err));
+          console.error(
+            `[SSE] enqueue error`,
+            err instanceof Error ? err.message : String(err)
+          );
         }
       };
 
@@ -61,7 +73,10 @@ export async function GET(request: Request) {
         try {
           safeEnqueue(sseEncode(event, data));
         } catch (err) {
-          console.error(`[SSE] send error`, err instanceof Error ? err.message : String(err));
+          console.error(
+            `[SSE] send error`,
+            err instanceof Error ? err.message : String(err)
+          );
         }
       };
 
@@ -89,11 +104,14 @@ export async function GET(request: Request) {
       }, 15000);
 
       // Hard timeout at 10 minutes
-      timeoutTimer = setTimeout(async () => {
-        console.log(`[SSE] Timeout reached for session ${sessionId}`);
-        send("error", { message: "Agent run timed out after 10 minutes" });
-        await cleanup();
-      }, 10 * 60 * 1000);
+      timeoutTimer = setTimeout(
+        async () => {
+          console.log(`[SSE] Timeout reached for session ${sessionId}`);
+          send("error", { message: "Agent run timed out after 10 minutes" });
+          await cleanup();
+        },
+        10 * 60 * 1000
+      );
 
       console.log(`[SSE] Starting Stagehand agent run`, {
         sessionId,
@@ -101,7 +119,9 @@ export async function GET(request: Request) {
         hasInstructions: true,
       });
 
-      const logger = createStagehandUserLogger(send, { forwardStepEvents: false });
+      const logger = createStagehandUserLogger(send, {
+        forwardStepEvents: false,
+      });
 
       const stagehand = new Stagehand({
         env: "BROWSERBASE",
@@ -118,6 +138,7 @@ export async function GET(request: Request) {
               width: 1288,
               height: 711,
             },
+            solveCaptchas: !fromChat, // false if session is from a search param, true otherwise
           },
         },
         useAPI: false,
@@ -140,7 +161,7 @@ export async function GET(request: Request) {
         });
 
         const agent = stagehand.agent({
-          provider: "google", 
+          provider: "google",
           model: "computer-use-preview-10-2025",
           options: {
             apiKey: process.env.GOOGLE_API_KEY,
@@ -149,24 +170,24 @@ export async function GET(request: Request) {
         });
 
         const result = await agent.execute({
-            instruction: goal,
-            autoScreenshot: true,
-            waitBetweenActions: 200,
-            maxSteps: 100,
+          instruction: goal,
+          autoScreenshot: true,
+          waitBetweenActions: 200,
+          maxSteps: 100,
         });
 
         try {
-        console.log(`[SSE] metrics snapshot`, stagehand.metrics);
-        send("metrics", stagehand.metrics);
+          console.log(`[SSE] metrics snapshot`, stagehand.metrics);
+          send("metrics", stagehand.metrics);
         } catch {}
 
-          const finalMessage = logger.getLastReasoning();
-          console.log(`[SSE] done`, {
-            success: result.success,
-            completed: result.completed,
-            finalMessage: finalMessage
-          });
-          send("done", { ...result, finalMessage });
+        const finalMessage = logger.getLastReasoning();
+        console.log(`[SSE] done`, {
+          success: result.success,
+          completed: result.completed,
+          finalMessage: finalMessage,
+        });
+        send("done", { ...result, finalMessage });
 
         await cleanup(stagehand);
       } catch (error) {
diff --git a/app/api/session/route.ts b/app/api/session/route.ts
index c640ebf..de60c05 100644
--- a/app/api/session/route.ts
+++ b/app/api/session/route.ts
@@ -7,70 +7,107 @@ type BrowserbaseRegion =
   | "eu-central-1"
   | "ap-southeast-1";
 
-// Exact timezone matches for east coast cities
-const exactTimezoneMap: Record<string, BrowserbaseRegion> = {
-  "America/New_York": "us-east-1",
-  "America/Detroit": "us-east-1",
-  "America/Toronto": "us-east-1",
-  "America/Montreal": "us-east-1",
-  "America/Boston": "us-east-1",
-  "America/Chicago": "us-east-1",
+// Timezone abbreviation to region mapping
+const timezoneAbbreviationMap: Record<string, BrowserbaseRegion> = {
+  // US East Coast
+  EST: "us-east-1",
+  EDT: "us-east-1",
+
+  // US West Coast
+  PST: "us-west-2",
+  PDT: "us-west-2",
+
+  // US Mountain/Central - route to appropriate region
+  MST: "us-west-2",
+  MDT: "us-west-2",
+  CST: "us-east-1",
+  CDT: "us-east-1",
+
+  // Europe
+  GMT: "eu-central-1",
+  BST: "eu-central-1",
+  CET: "eu-central-1",
+  CEST: "eu-central-1",
+  EET: "eu-central-1",
+  EEST: "eu-central-1",
+  WET: "eu-central-1",
+  WEST: "eu-central-1",
+
+  // Asia-Pacific
+  JST: "ap-southeast-1", // Japan Standard Time
+  // Note: CST conflicts between US Central and China Standard - US takes priority
+  KST: "ap-southeast-1", // Korea Standard Time
+  IST: "ap-southeast-1",
+  AEST: "ap-southeast-1",
+  AEDT: "ap-southeast-1",
+  AWST: "ap-southeast-1",
+  NZST: "ap-southeast-1",
+  NZDT: "ap-southeast-1",
 };
 
-// Prefix-based region mapping
-const prefixToRegion: Record<string, BrowserbaseRegion> = {
-  America: "us-west-2",
-  US: "us-west-2",
-  Canada: "us-west-2",
-  Europe: "eu-central-1",
-  Africa: "eu-central-1",
-  Asia: "ap-southeast-1",
-  Australia: "ap-southeast-1",
-  Pacific: "ap-southeast-1",
+// Probability distributions for region routing
+const distributions: Record<
+  BrowserbaseRegion,
+  Record<BrowserbaseRegion, number>
+> = {
+  "us-west-2": {
+    "us-west-2": 100,
+    "us-east-1": 0,
+    "eu-central-1": 0,
+    "ap-southeast-1": 0,
+  },
+  "us-east-1": {
+    "us-east-1": 100,
+    "us-west-2": 0,
+    "eu-central-1": 0,
+    "ap-southeast-1": 0,
+  },
+  "eu-central-1": {
+    "eu-central-1": 100,
+    "us-east-1": 0,
+    "us-west-2": 0,
+    "ap-southeast-1": 0,
+  },
+  "ap-southeast-1": {
+    "ap-southeast-1": 100,
+    "eu-central-1": 0,
+    "us-west-2": 0,
+    "us-east-1": 0,
+  },
 };
 
-// Offset ranges to regions (inclusive bounds)
-const offsetRanges: {
-  min: number;
-  max: number;
-  region: BrowserbaseRegion;
-}[] = [
-  { min: -24, max: -4, region: "us-west-2" }, // UTC-24 to UTC-4
-  { min: -3, max: 4, region: "eu-central-1" }, // UTC-3 to UTC+4
-  { min: 5, max: 24, region: "ap-southeast-1" }, // UTC+5 to UTC+24
-];
-
-function getClosestRegion(timezone?: string): BrowserbaseRegion {
-  try {
-    if (!timezone) {
-      return "us-west-2"; // Default if no timezone provided
+function selectRegionWithProbability(
+  baseRegion: BrowserbaseRegion
+): BrowserbaseRegion {
+  const distribution = distributions[baseRegion];
+  const random = Math.random() * 100; // Generate random number between 0-100
+
+  let cumulativeProbability = 0;
+  for (const [region, probability] of Object.entries(distribution)) {
+    cumulativeProbability += probability;
+    if (random < cumulativeProbability) {
+      return region as BrowserbaseRegion;
     }
+  }
 
-    // Check exact matches first
-    if (timezone in exactTimezoneMap) {
-      return exactTimezoneMap[timezone];
-    }
+  // Fallback to base region if something goes wrong
+  return baseRegion;
+}
 
-    // Check prefix matches
-    const prefix = timezone.split("/")[0];
-    if (prefix in prefixToRegion) {
-      return prefixToRegion[prefix];
+function getRegionFromTimezoneAbbr(timezoneAbbr?: string): BrowserbaseRegion {
+  try {
+    if (!timezoneAbbr) {
+      return "us-west-2"; // Default if no timezone provided
     }
 
-    // Use offset-based fallback
-    const date = new Date();
-    // Create a date formatter for the given timezone
-    const formatter = new Intl.DateTimeFormat("en-US", { timeZone: timezone });
-    // Get the timezone offset in minutes
-    const timeString = formatter.format(date);
-    const testDate = new Date(timeString);
-    const hourOffset = (testDate.getTime() - date.getTime()) / (1000 * 60 * 60);
-
-    const matchingRange = offsetRanges.find(
-      (range) => hourOffset >= range.min && hourOffset <= range.max
-    );
+    // Direct lookup from timezone abbreviation
+    const region = timezoneAbbreviationMap[timezoneAbbr.toUpperCase()];
+    if (region) {
+      return region;
+    }
 
-    return matchingRange?.region ?? "us-west-2";
+    // Fallback to us-west-2 for unknown abbreviations
+    return "us-west-2";
   } catch {
     return "us-west-2";
   }
@@ -81,26 +118,32 @@ async function createSession(timezone?: string) {
     apiKey: process.env.BROWSERBASE_API_KEY!,
   });
 
-  const browserSettings: Browserbase.Sessions.SessionCreateParams.BrowserSettings = {
-    viewport: {
-      width: 2560,
-      height: 1440,
-    },
-    //@ts-expect-error - not present in the types, but valid
-    os: "windows",
-    blockAds: true,
-    advancedStealth: true
-  };
-
-  console.log("timezone ", timezone);
-  console.log("getClosestRegion(timezone)", getClosestRegion(timezone));
+  const browserSettings: Browserbase.Sessions.SessionCreateParams.BrowserSettings =
+    {
+      viewport: {
+        width: 2560,
+        height: 1440,
+      },
+      // @ts-expect-error - os is not a valid property
+      os: "windows",
+      blockAds: true,
+      advancedStealth: true,
+    };
+
+  // Use timezone abbreviation to determine region
+  const closestRegion = getRegionFromTimezoneAbbr(timezone);
+  console.log("timezone abbreviation:", timezone);
+  console.log("mapped to region:", closestRegion);
+
+  const finalRegion = selectRegionWithProbability(closestRegion);
+  console.log("finalRegion after probability routing", finalRegion);
 
   const session = await bb.sessions.create({
     projectId: process.env.BROWSERBASE_PROJECT_ID!,
     proxies: true,
     browserSettings,
     keepAlive: true,
-    region: getClosestRegion(timezone),
+    region: finalRegion,
   });
   return {
     session,
diff --git a/app/components/BrowserSessionContainer.tsx b/app/components/BrowserSessionContainer.tsx
index 072d2c7..68eaba2 100644
--- a/app/components/BrowserSessionContainer.tsx
+++ b/app/components/BrowserSessionContainer.tsx
@@ -11,6 +11,7 @@ interface BrowserSessionContainerProps {
   isCompleted: boolean;
   initialMessage: string | undefined;
   sessionTime?: number;
+  isFromSearchParam?: boolean;
   onStop?: () => void;
   onRestart?: () => void;
 }
@@ -104,6 +105,7 @@ const BrowserSessionContainer: React.FC<BrowserSessionContainerProps> = ({
   isCompleted,
   initialMessage,
   sessionTime = 0,
+  isFromSearchParam = false,
   onStop = () => {},
   onRestart = () => {},
 }) => {
@@ -192,7 +194,7 @@ const BrowserSessionContainer: React.FC<BrowserSessionContainerProps> = ({
               sessionUrl ? (
                 <iframe
                   src={sessionUrl}
-                  className="w-full h-full border-none pointer-events-none"
+                  className={`w-full h-full border-none ${!isFromSearchParam ? 'pointer-events-none' : ''}`}
                   sandbox="allow-same-origin allow-scripts allow-forms"
                   allow="clipboard-read; clipboard-write"
                   loading="lazy"
diff --git a/app/components/ChatFeed.tsx b/app/components/ChatFeed.tsx
index 7701ec3..b707706 100644
--- a/app/components/ChatFeed.tsx
+++ b/app/components/ChatFeed.tsx
@@ -19,6 +19,7 @@ import { ChatFeedProps, AgentState, BrowserStep } from "../types/ChatFeed";
 
 export default function ChatFeed({
   initialMessage,
+  isFromSearchParam = false,
   onClose,
 }: ChatFeedProps) {
   const renderCount = useRef(0);
@@ -199,6 +200,7 @@ export default function ChatFeed({
   } = useAgentStream({
     sessionId: null,
     goal: initialMessage,
+    isFromSearchParam,
     onStart: handleStart,
     onDone: handleDone,
     onError: handleError,
@@ -297,6 +299,7 @@ export default function ChatFeed({
                 isCompleted={agentFinished}
                 initialMessage={initialMessage || undefined}
                 sessionTime={sessionTime}
+                isFromSearchParam={isFromSearchParam}
                 onStop={handleDone}
                 onRestart={onClose}
               />
diff --git a/app/components/NavBar.tsx b/app/components/NavBar.tsx
index 2e94247..a170cb8 100644
--- a/app/components/NavBar.tsx
+++ b/app/components/NavBar.tsx
@@ -31,7 +31,7 @@ export default function NavBar({
     >
       <div className="flex items-center gap-2">
         <a
-          href="https://browserbase.com/computer-use"
+          href="https://www.browserbase.com/cua/google"
           target="_blank"
           rel="noopener noreferrer"
           className="flex items-center gap-3 hover:opacity-90 transition-opacity duration-200"
@@ -50,7 +50,7 @@ export default function NavBar({
       </div>
       <div className="flex items-center gap-2">
         <a
-          href="https://browserbase.com/computer-use"
+          href="https://www.browserbase.com/cua/google"
           target="_blank"
           rel="noopener noreferrer"
         >
@@ -69,7 +69,7 @@ export default function NavBar({
         </a>
         {showGitHubButton && (
           <a
-            href="https://github.com/browserbase/cua-browser"
+            href="https://github.com/browserbase/google-cua-browser"
             target="_blank"
             rel="noopener noreferrer"
           >
diff --git a/app/hooks/useAgentStream.ts b/app/hooks/useAgentStream.ts
index 414a109..3072898 100644
--- a/app/hooks/useAgentStream.ts
+++ b/app/hooks/useAgentStream.ts
@@ -1,24 +1,37 @@
 "use client";
 
-import { useState, useEffect, useRef, useCallback } from "react";
+import moment from "moment-timezone";
+import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  AgentLog,
+  AgentStreamState,
+  LogEvent,
+  UseAgentStreamProps,
+} from "../types/Agent";
 import { BrowserStep } from "../types/ChatFeed";
-import { AgentLog, UseAgentStreamProps, AgentStreamState, LogEvent } from "../types/Agent";
 
 // Global trackers to avoid duplicate session creation in React Strict Mode
 // by sharing a single in-flight promise across mounts for the same goal.
 const sessionCreationPromises = new Map<
   string,
-  Promise<{ sessionId: string; sessionUrl: string | null; connectUrl: string | null }>
+  Promise<{
+    sessionId: string;
+    sessionUrl: string | null;
+    connectUrl: string | null;
+  }>
 >();
 
 export function useAgentStream({
   sessionId,
   goal,
+  isFromSearchParam = false,
   onStart,
   onDone,
   onError,
 }: UseAgentStreamProps) {
-  console.log(`[useAgentStream] Hook called with goal: "${goal?.substring(0, 50)}...", sessionId: ${sessionId}`);
+  console.log(
+    `[useAgentStream] Hook called with goal: "${goal?.substring(0, 50)}...", sessionId: ${sessionId}`
+  );
   const [state, setState] = useState<AgentStreamState>({
     sessionId: sessionId,
     sessionUrl: null,
@@ -68,7 +81,9 @@ export function useAgentStream({
       return { kind: "summary", step: parseInt(execMatch[1], 10), text: "" };
     }
     // Function call lines, optionally without args, and possibly multi-line JSON
-    const fnMatch = raw.match(/^Found function call:\s*([A-Za-z0-9_]+)(?:\s+with args:\s*([\s\S]+))?$/i);
+    const fnMatch = raw.match(
+      /^Found function call:\s*([A-Za-z0-9_]+)(?:\s+with args:\s*([\s\S]+))?$/i
+    );
     if (fnMatch) {
       let args: unknown = {};
       const jsonText = (fnMatch[2] || "").trim();
@@ -79,16 +94,31 @@ export function useAgentStream({
           args = jsonText; // keep raw if not valid JSON
         }
       }
-      return { kind: "action", step: stepCounterRef.current, tool: fnMatch[1], args };
+      return {
+        kind: "action",
+        step: stepCounterRef.current,
+        tool: fnMatch[1],
+        args,
+      };
     }
     return null;
   }, []);
 
-  const isPlainObject = useCallback((v: unknown) => typeof v === "object" && v !== null && !Array.isArray(v), []);
-  const isEmptyObject = useCallback((v: unknown) => isPlainObject(v) && Object.keys(v as Record<string, unknown>).length === 0, [isPlainObject]);
+  const isPlainObject = useCallback(
+    (v: unknown) => typeof v === "object" && v !== null && !Array.isArray(v),
+    []
+  );
+  const isEmptyObject = useCallback(
+    (v: unknown) =>
+      isPlainObject(v) &&
+      Object.keys(v as Record<string, unknown>).length === 0,
+    [isPlainObject]
+  );
 
   useEffect(() => {
-    console.log(`[useAgentStream] useEffect triggered with goal: "${goal?.substring(0, 50)}..."`);
+    console.log(
+      `[useAgentStream] useEffect triggered with goal: "${goal?.substring(0, 50)}..."`
+    );
     if (!goal) {
       console.log(`[useAgentStream] No goal, returning`);
       return;
@@ -107,20 +137,36 @@ export function useAgentStream({
           let promise = sessionCreationPromises.get(goal);
           if (!promise) {
             promise = (async () => {
+              // Detect timezone using moment-timezone for simplicity
+              const getTimezoneAbbreviation = () => {
+                try {
+                  const abbr = moment.tz(moment.tz.guess()).format("z");
+                  return abbr;
+                } catch {
+                  return "PDT"; // Fallback
+                }
+              };
+
+              const timezone = getTimezoneAbbreviation();
+
               const sessionResponse = await fetch("/api/session", {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({
-                  timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+                  timezone: timezone,
                 }),
               });
 
               const sessionData = await sessionResponse.json();
               if (!sessionData.success) {
-                throw new Error(sessionData.error || "Failed to create session");
+                throw new Error(
+                  sessionData.error || "Failed to create session"
+                );
               }
 
-              console.log(`[useAgentStream] Session created successfully: ${sessionData.sessionId}`);
+              console.log(
+                `[useAgentStream] Session created successfully: ${sessionData.sessionId}`
+              );
               return {
                 sessionId: sessionData.sessionId as string,
                 sessionUrl: (sessionData.sessionUrl as string) ?? null,
@@ -141,8 +187,13 @@ export function useAgentStream({
             connectUrl: result.connectUrl,
           }));
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Failed to create session";
-          setState((prev) => ({ ...prev, error: errorMessage, isLoading: false }));
+          const errorMessage =
+            error instanceof Error ? error.message : "Failed to create session";
+          setState((prev) => ({
+            ...prev,
+            error: errorMessage,
+            isLoading: false,
+          }));
           onErrorRef.current?.(errorMessage);
           // Allow retries by clearing promise on error
           sessionCreationPromises.delete(goal);
@@ -162,6 +213,7 @@ export function useAgentStream({
       const params = new URLSearchParams({
         sessionId: currentSessionId!,
         goal,
+        fromChat: String(isFromSearchParam),
       });
 
       const es = new EventSource(`/api/agent/stream?${params.toString()}`);
@@ -183,193 +235,234 @@ export function useAgentStream({
         }
       });
 
-    es.addEventListener("log", (e) => {
-      if (cancelled) return;
-      try {
-        const payload = JSON.parse((e as MessageEvent).data) as LogEvent;
-        const parsed = parseLog(payload.message);
-
-        setState((prev) => {
-          const newLogs = [...prev.logs, payload];
-          if (!parsed) {
-            return { ...prev, logs: newLogs };
-          }
+      es.addEventListener("log", (e) => {
+        if (cancelled) return;
+        try {
+          const payload = JSON.parse((e as MessageEvent).data) as LogEvent;
+          const parsed = parseLog(payload.message);
 
-          if (parsed.kind === "summary") {
-            // If the first visible step starts at >1 (because step 1 was hidden),
-            // shift numbering so the first visible step is Step 1.
-            if (stepOffsetRef.current === 0 && prev.steps.length === 0 && parsed.step > 1) {
-              stepOffsetRef.current = parsed.step - 1;
-            }
-            const displayStep = Math.max(1, parsed.step - stepOffsetRef.current);
-            stepCounterRef.current = displayStep;
-
-            const trimmedText = (parsed.text || "").trim();
-
-            // Update existing step with matching number if present; else append
-            const existingIndex = prev.steps.findIndex((s) => s.stepNumber === displayStep);
-            if (existingIndex >= 0) {
-              const existing = prev.steps[existingIndex];
-              const existingText = (existing.text || "").trim();
-              // If text is identical, no change; otherwise update text/instruction
-              if (trimmedText && trimmedText !== existingText) {
-                const updated: BrowserStep = {
-                  ...existing,
-                  // Keep whatever tool it currently has (may have been upgraded to an action)
-                  text: parsed.text,
-                  instruction: parsed.text,
-                };
-                const newSteps = [...prev.steps];
-                newSteps[existingIndex] = updated;
-                return { ...prev, logs: newLogs, steps: newSteps };
-              }
+          setState((prev) => {
+            const newLogs = [...prev.logs, payload];
+            if (!parsed) {
               return { ...prev, logs: newLogs };
             }
 
-            const newStep: BrowserStep = {
-              stepNumber: displayStep,
-              text: parsed.text,
-              reasoning: "",
-              tool: "MESSAGE",
-              instruction: parsed.text,
-            };
-            return { ...prev, logs: newLogs, steps: [...prev.steps, newStep] };
-          }
+            if (parsed.kind === "summary") {
+              // If the first visible step starts at >1 (because step 1 was hidden),
+              // shift numbering so the first visible step is Step 1.
+              if (
+                stepOffsetRef.current === 0 &&
+                prev.steps.length === 0 &&
+                parsed.step > 1
+              ) {
+                stepOffsetRef.current = parsed.step - 1;
+              }
+              const displayStep = Math.max(
+                1,
+                parsed.step - stepOffsetRef.current
+              );
+              stepCounterRef.current = displayStep;
+
+              const trimmedText = (parsed.text || "").trim();
+
+              // Update existing step with matching number if present; else append
+              const existingIndex = prev.steps.findIndex(
+                (s) => s.stepNumber === displayStep
+              );
+              if (existingIndex >= 0) {
+                const existing = prev.steps[existingIndex];
+                const existingText = (existing.text || "").trim();
+                // If text is identical, no change; otherwise update text/instruction
+                if (trimmedText && trimmedText !== existingText) {
+                  const updated: BrowserStep = {
+                    ...existing,
+                    // Keep whatever tool it currently has (may have been upgraded to an action)
+                    text: parsed.text,
+                    instruction: parsed.text,
+                  };
+                  const newSteps = [...prev.steps];
+                  newSteps[existingIndex] = updated;
+                  return { ...prev, logs: newLogs, steps: newSteps };
+                }
+                return { ...prev, logs: newLogs };
+              }
 
-          if (parsed.kind === "thought") {
-            if (prev.steps.length === 0) {
-              // create a placeholder step 1 to hold the thought
-              const placeholder: BrowserStep = {
-                stepNumber: stepCounterRef.current,
-                text: "",
-                reasoning: parsed.text,
+              const newStep: BrowserStep = {
+                stepNumber: displayStep,
+                text: parsed.text,
+                reasoning: "",
                 tool: "MESSAGE",
-                instruction: "",
+                instruction: parsed.text,
+              };
+              return {
+                ...prev,
+                logs: newLogs,
+                steps: [...prev.steps, newStep],
               };
-              return { ...prev, logs: newLogs, steps: [...prev.steps, placeholder] };
             }
-            const updated = prev.steps.map((s, idx, arr) =>
-              idx === arr.length - 1 ? { ...s, reasoning: parsed.text } : s
-            );
-            return { ...prev, logs: newLogs, steps: updated };
-          }
-
-          if (parsed.kind === "action") {
-            const toolName = parsed.tool;
-            const tool: BrowserStep["tool"] = toolName; 
-
-            // Track invoked tool names (dedupe)
-            const nextInvoked = new Set(prev.invokedTools);
-            nextInvoked.add(toolName);
 
-            // Align action to adjusted step numbering
-            if (stepOffsetRef.current === 0 && prev.steps.length === 0 && parsed.step > 1) {
-              stepOffsetRef.current = parsed.step - 1;
+            if (parsed.kind === "thought") {
+              if (prev.steps.length === 0) {
+                // create a placeholder step 1 to hold the thought
+                const placeholder: BrowserStep = {
+                  stepNumber: stepCounterRef.current,
+                  text: "",
+                  reasoning: parsed.text,
+                  tool: "MESSAGE",
+                  instruction: "",
+                };
+                return {
+                  ...prev,
+                  logs: newLogs,
+                  steps: [...prev.steps, placeholder],
+                };
+              }
+              const updated = prev.steps.map((s, idx, arr) =>
+                idx === arr.length - 1 ? { ...s, reasoning: parsed.text } : s
+              );
+              return { ...prev, logs: newLogs, steps: updated };
             }
-            const displayStep = Math.max(1, parsed.step - stepOffsetRef.current);
-
-            // Prefer updating the step with matching number; else update the last
-            const updated = (prev.steps.length > 0 ? prev.steps : []).map((s) => {
-              if (s.stepNumber !== displayStep) return s;
-              const sameTool = s.tool === tool;
-              const sameArgs = JSON.stringify(s.actionArgs) === JSON.stringify(parsed.args);
-              if (sameTool && sameArgs) return s;
-              return { ...s, tool, actionArgs: parsed.args };
-            });
-            // If there is no step to attach to, create one
-            const hasTarget = updated.length > 0 && updated.some((s) => s.stepNumber === displayStep);
-            if (!hasTarget) {
-              const newStep: BrowserStep = {
-                stepNumber: displayStep,
-                text: "",
-                reasoning: "",
-                tool,
-                instruction: "",
-                actionArgs: parsed.args,
+
+            if (parsed.kind === "action") {
+              const toolName = parsed.tool;
+              const tool: BrowserStep["tool"] = toolName;
+
+              // Track invoked tool names (dedupe)
+              const nextInvoked = new Set(prev.invokedTools);
+              nextInvoked.add(toolName);
+
+              // Align action to adjusted step numbering
+              if (
+                stepOffsetRef.current === 0 &&
+                prev.steps.length === 0 &&
+                parsed.step > 1
+              ) {
+                stepOffsetRef.current = parsed.step - 1;
+              }
+              const displayStep = Math.max(
+                1,
+                parsed.step - stepOffsetRef.current
+              );
+
+              // Prefer updating the step with matching number; else update the last
+              const updated = (prev.steps.length > 0 ? prev.steps : []).map(
+                (s) => {
+                  if (s.stepNumber !== displayStep) return s;
+                  const sameTool = s.tool === tool;
+                  const sameArgs =
+                    JSON.stringify(s.actionArgs) ===
+                    JSON.stringify(parsed.args);
+                  if (sameTool && sameArgs) return s;
+                  return { ...s, tool, actionArgs: parsed.args };
+                }
+              );
+              // If there is no step to attach to, create one
+              const hasTarget =
+                updated.length > 0 &&
+                updated.some((s) => s.stepNumber === displayStep);
+              if (!hasTarget) {
+                const newStep: BrowserStep = {
+                  stepNumber: displayStep,
+                  text: "",
+                  reasoning: "",
+                  tool,
+                  instruction: "",
+                  actionArgs: parsed.args,
+                };
+                return {
+                  ...prev,
+                  logs: newLogs,
+                  invokedTools: Array.from(nextInvoked),
+                  steps: [...prev.steps, newStep],
+                };
+              }
+              return {
+                ...prev,
+                logs: newLogs,
+                invokedTools: Array.from(nextInvoked),
+                steps: updated,
               };
-              return { ...prev, logs: newLogs, invokedTools: Array.from(nextInvoked), steps: [...prev.steps, newStep] };
             }
-            return { ...prev, logs: newLogs, invokedTools: Array.from(nextInvoked), steps: updated };
-          }
-
-          return { ...prev, logs: newLogs };
-        });
-      } catch (err) {
-        console.error("Error parsing log event:", err);
-        setState((prev) => ({
-          ...prev,
-          logs: [...prev.logs, { message: String((e as MessageEvent).data) }],
-        }));
-      }
-    });
 
-    // Disable SSE 'step' duplication: logs already carry summary/action
-    es.addEventListener("step", () => {});
+            return { ...prev, logs: newLogs };
+          });
+        } catch (err) {
+          console.error("Error parsing log event:", err);
+          setState((prev) => ({
+            ...prev,
+            logs: [...prev.logs, { message: String((e as MessageEvent).data) }],
+          }));
+        }
+      });
 
-    es.addEventListener("done", (e) => {
-      try {
-        const payload = JSON.parse((e as MessageEvent).data);
-        console.log("[useAgentStream] Done event received:", payload);
+      // Disable SSE 'step' duplication: logs already carry summary/action
+      es.addEventListener("step", () => {});
 
-        // If there's a final message, add it as the last step
-        if (payload.finalMessage) {
-          console.log("[useAgentStream] Adding final message as step");
-          setState((prev) => {
-            const finalStep: BrowserStep = {
-              stepNumber: prev.steps.length + 1,
-              text: payload.finalMessage,
-              reasoning: "",
-              tool: "MESSAGE",
-              instruction: "Final Answer",
-            };
-            console.log("[useAgentStream] Final step created:", finalStep);
-            return {
+      es.addEventListener("done", (e) => {
+        try {
+          const payload = JSON.parse((e as MessageEvent).data);
+          console.log("[useAgentStream] Done event received:", payload);
+
+          // If there's a final message, add it as the last step
+          if (payload.finalMessage) {
+            console.log("[useAgentStream] Adding final message as step");
+            setState((prev) => {
+              const finalStep: BrowserStep = {
+                stepNumber: prev.steps.length + 1,
+                text: payload.finalMessage,
+                reasoning: "",
+                tool: "MESSAGE",
+                instruction: "Final Answer",
+              };
+              console.log("[useAgentStream] Final step created:", finalStep);
+              return {
+                ...prev,
+                steps: [...prev.steps, finalStep],
+                isFinished: true,
+              };
+            });
+          } else {
+            setState((prev) => ({
               ...prev,
-              steps: [...prev.steps, finalStep],
               isFinished: true,
-            };
-          });
-        } else {
+            }));
+          }
+
+          onDoneRef.current?.(payload);
+          // Clear the session promise for this goal to allow future runs
+          sessionCreationPromises.delete(goal);
+        } catch (err) {
+          console.error("Error parsing done event:", err);
+        }
+        es.close();
+        eventSourceRef.current = null;
+      });
+
+      es.addEventListener("error", (e) => {
+        try {
+          const payload = JSON.parse((e as MessageEvent).data);
+          const errorMessage =
+            payload.message || "Connection lost. Please try again.";
           setState((prev) => ({
             ...prev,
+            error: errorMessage,
             isFinished: true,
           }));
+          onErrorRef.current?.(errorMessage);
+        } catch {
+          const errorMessage = "Connection lost. Please try again.";
+          setState((prev) => ({
+            ...prev,
+            error: errorMessage,
+            isFinished: true,
+          }));
+          onErrorRef.current?.(errorMessage);
         }
-
-        onDoneRef.current?.(payload);
-        // Clear the session promise for this goal to allow future runs
+        // Clear the session promise for this goal to allow retries
         sessionCreationPromises.delete(goal);
-      } catch (err) {
-        console.error("Error parsing done event:", err);
-      }
-      es.close();
-      eventSourceRef.current = null;
-    });
-
-    es.addEventListener("error", (e) => {
-      try {
-        const payload = JSON.parse((e as MessageEvent).data);
-        const errorMessage = payload.message || "Connection lost. Please try again.";
-        setState((prev) => ({
-          ...prev,
-          error: errorMessage,
-          isFinished: true,
-        }));
-        onErrorRef.current?.(errorMessage);
-      } catch {
-        const errorMessage = "Connection lost. Please try again.";
-        setState((prev) => ({
-          ...prev,
-          error: errorMessage,
-          isFinished: true,
-        }));
-        onErrorRef.current?.(errorMessage);
-      }
-      // Clear the session promise for this goal to allow retries
-      sessionCreationPromises.delete(goal);
-      es.close();
-      eventSourceRef.current = null;
-    });
+        es.close();
+        eventSourceRef.current = null;
+      });
 
       // Store es in a variable for cleanup
       return () => {
@@ -387,10 +480,10 @@ export function useAgentStream({
         eventSourceRef.current.close();
       }
     };
-  }, [sessionId, goal, parseLog, isEmptyObject]);
+  }, [sessionId, goal, parseLog, isEmptyObject, isFromSearchParam]);
 
   return {
     ...state,
     stop,
   };
-}
\ No newline at end of file
+}
diff --git a/app/page.tsx b/app/page.tsx
index 5a0059c..be6f7be 100644
--- a/app/page.tsx
+++ b/app/page.tsx
@@ -2,6 +2,7 @@
 
 import { useState, useEffect, useCallback, useRef } from "react";
 import { AnimatePresence, motion } from "framer-motion";
+import { useSearchParams } from "next/navigation";
 import AnimatedButton from "./components/ui/AnimatedButton";
 import posthog from "posthog-js";
 import ChatFeed from "./components/ChatFeed";
@@ -47,10 +48,30 @@ const Tooltip = ({
 };
 
 export default function Home() {
-  const [isChatVisible, setIsChatVisible] = useState(false);
-  const [initialMessage, setInitialMessage] = useState<string | null>(null);
+  const searchParams = useSearchParams();
+  const rawChatParam = searchParams.get("chat");
+  const chatParam = rawChatParam?.replace(/^["']|["']$/g, '') || null;
+  
+  const [isChatVisible, setIsChatVisible] = useState(() => !!chatParam);
+  const [initialMessage, setInitialMessage] = useState<string | null>(() => chatParam);
   const inputRef = useRef<HTMLInputElement>(null);
 
+  const startChat = useCallback(
+    (finalMessage: string) => {
+      setInitialMessage(finalMessage);
+      setIsChatVisible(true);
+
+      try {
+        posthog.capture("google_cua_submit_message", {
+          message: finalMessage,
+        });
+      } catch (e) {
+        console.error(e);
+      }
+    },
+    []
+  );
+
   useEffect(() => {
     const handleKeyDown = (e: KeyboardEvent) => {
       // Handle CMD+Enter to submit the form when chat is not visible
@@ -84,22 +105,6 @@ export default function Home() {
     return () => window.removeEventListener("keydown", handleKeyDown);
   }, [isChatVisible]);
 
-  const startChat = useCallback(
-    (finalMessage: string) => {
-      setInitialMessage(finalMessage);
-      setIsChatVisible(true);
-
-      try {
-        posthog.capture("google_cua_submit_message", {
-          message: finalMessage,
-        });
-      } catch (e) {
-        console.error(e);
-      }
-    },
-    [setInitialMessage, setIsChatVisible]
-  );
-
   return (
     <AnimatePresence>
       {!isChatVisible ? (
@@ -302,6 +307,7 @@ export default function Home() {
         <ChatFeed
           key={`chat-feed-${initialMessage}`}
           initialMessage={initialMessage}
+          isFromSearchParam={!!chatParam}
           onClose={() => setIsChatVisible(false)}
         />
       )}
diff --git a/app/types/Agent.ts b/app/types/Agent.ts
index f7f1bb9..0975ea3 100644
--- a/app/types/Agent.ts
+++ b/app/types/Agent.ts
@@ -57,6 +57,7 @@ export interface DoneEventData {
 export interface UseAgentStreamProps {
   sessionId: string | null;
   goal: string | null;
+  isFromSearchParam?: boolean;
   onStart?: (data: StartEventData) => void;
   onDone?: (data?: DoneEventData) => void;
   onError?: (error: string) => void;
diff --git a/app/types/ChatFeed.ts b/app/types/ChatFeed.ts
index 0acfbd2..d8c659c 100644
--- a/app/types/ChatFeed.ts
+++ b/app/types/ChatFeed.ts
@@ -1,5 +1,6 @@
 export interface ChatFeedProps {
     initialMessage: string | null;
+    isFromSearchParam?: boolean;
     onClose: () => void;
     url?: string;
   }
diff --git a/package.json b/package.json
index 12b8945..e58f16e 100644
--- a/package.json
+++ b/package.json
@@ -17,6 +17,7 @@
     "clsx": "^2.1.1",
     "framer-motion": "^11.0.3",
     "lucide-react": "^0.479.0",
+    "moment-timezone": "^0.6.0",
     "next": "15.1.6",
     "playwright-core": "^1.55.0",
     "posthog-js": "^1.209.3",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 3768a86..a53d717 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -29,6 +29,9 @@ importers:
       lucide-react:
         specifier: ^0.479.0
         version: 0.479.0(react@19.1.1)
+      moment-timezone:
+        specifier: ^0.6.0
+        version: 0.6.0
       next:
         specifier: 15.1.6
         version: 15.1.6(@opentelemetry/api@1.9.0)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)
@@ -2009,6 +2012,12 @@ packages:
     resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==}
     engines: {node: '>=16 || 14 >=14.17'}
 
+  moment-timezone@0.6.0:
+    resolution: {integrity: sha512-ldA5lRNm3iJCWZcBCab4pnNL3HSZYXVb/3TYr75/1WCTWYuTqYUb5f/S384pncYjJ88lbO8Z4uPDvmoluHJc8Q==}
+
+  moment@2.30.1:
+    resolution: {integrity: sha512-uEmtNhbDOrWPFS+hdjFCBfy9f2YoyzRpwcl+DqpC6taX21FzsTLQVbMV/W7PzNSX6x/bhC1zA3c2UQ5NzH6how==}
+
   motion-dom@11.18.1:
     resolution: {integrity: sha512-g76KvA001z+atjfxczdRtw/RXOM3OMSdd1f4DL77qCTF/+avrRJiawSG4yDibEQ215sr9kpinSlX2pCTJ9zbhw==}
 
@@ -5132,6 +5141,12 @@ snapshots:
 
   minipass@7.1.2: {}
 
+  moment-timezone@0.6.0:
+    dependencies:
+      moment: 2.30.1
+
+  moment@2.30.1: {}
+
   motion-dom@11.18.1:
     dependencies:
       motion-utils: 11.18.1