diff --git a/.env.example b/.env.example
index 247a807..47b0cca 100644
--- a/.env.example
+++ b/.env.example
@@ -1,3 +1,6 @@
 # Google Gemini API Key
 # Get your API key from: https://makersuite.google.com/app/apikey
 GEMINI_API_KEY=your_gemini_api_key_here
+
+# Enable demo image conditioning (loads images from ./demo as context)
+DEMO_ENABLED=false
diff --git a/demo/description.txt b/demo/description.txt
new file mode 100644
index 0000000..b566207
--- /dev/null
+++ b/demo/description.txt
@@ -0,0 +1 @@
+Find funding of a YC 2025 winter startup at https://www.ycombinator.com/companies?batch=Winter%202025.
\ No newline at end of file
diff --git a/demo/prompt.txt b/demo/prompt.txt
new file mode 100644
index 0000000..e13066d
--- /dev/null
+++ b/demo/prompt.txt
@@ -0,0 +1,3 @@
+Find funding of a YC 2025 winter startup at https://www.ycombinator.com/companies?batch=Winter%202025.
+
+Pick 3 startups from the YC 2025 batch, check how much they raised by doing a google search in a separate tab, and add their names and most recent raise to the google docs at https://docs.google.com/document/d/1IzFp0tiDhllwW_mdyCQKkvNY7uKFYNulge1A4gAvCYs/edit?tab=t.0 on a new line.
\ No newline at end of file
diff --git a/demo/step1.png b/demo/step1.png
new file mode 100644
index 0000000..9e730b3
Binary files /dev/null and b/demo/step1.png differ
diff --git a/demo/step2.png b/demo/step2.png
new file mode 100644
index 0000000..5a9b8c5
Binary files /dev/null and b/demo/step2.png differ
diff --git a/demo/step3.png b/demo/step3.png
new file mode 100644
index 0000000..7a2781c
Binary files /dev/null and b/demo/step3.png differ
diff --git a/demo/step4.png b/demo/step4.png
new file mode 100644
index 0000000..a17254a
Binary files /dev/null and b/demo/step4.png differ
diff --git a/demo/step5.png b/demo/step5.png
new file mode 100644
index 0000000..e18f131
Binary files /dev/null and b/demo/step5.png differ
diff --git a/demo/step6.png b/demo/step6.png
new file mode 100644
index 0000000..69b857f
Binary files /dev/null and b/demo/step6.png differ
diff --git a/docker-compose.yml b/docker-compose.yml
index 1f8d966..144c120 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -46,9 +46,11 @@ services:
     volumes:
       - ./screenshots:/tmp/screenshots
       - ./logs:/app/logs
+      - ./demo:/app/demo:ro
     environment:
       - GEMINI_API_KEY=${GEMINI_API_KEY}
       - MCP_SERVER_URL=http://playwright-browser:3001
+      - DEMO_ENABLED=${DEMO_ENABLED:-false}
     depends_on:
       playwright-browser:
         condition: service_healthy
diff --git a/services/nextjs-webapp/.gitignore b/services/nextjs-webapp/.gitignore
new file mode 100644
index 0000000..e985853
--- /dev/null
+++ b/services/nextjs-webapp/.gitignore
@@ -0,0 +1 @@
+.vercel
diff --git a/services/nextjs-webapp/src/components/ChatWindow.tsx b/services/nextjs-webapp/src/components/ChatWindow.tsx
index 06ce033..ad30406 100644
--- a/services/nextjs-webapp/src/components/ChatWindow.tsx
+++ b/services/nextjs-webapp/src/components/ChatWindow.tsx
@@ -5,9 +5,11 @@ import RecordingMetadataModal from './RecordingMetadataModal'
 
 interface Message {
   id: string
-  role: 'user' | 'assistant' | 'system'
+  role: 'user' | 'assistant' | 'system' | 'memory'
   content: string
   timestamp: Date
+  thumbnail?: string
+  imageCount?: number
 }
 
 interface ChatWindowProps {
@@ -67,9 +69,36 @@ export default function ChatWindow({ isRecording = false }: ChatWindowProps) {
             },
           ])
           setIsLoading(false)
+        } else if (data.type === 'memory_injected') {
+          // Memory was injected - show it immediately
+          if (data.metadata) {
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: Date.now().toString() + '-memory',
+                role: 'memory',
+                content: `Memory retrieved: ${data.metadata.description}`,
+                timestamp: new Date(),
+                thumbnail: data.metadata.thumbnail,
+                imageCount: data.metadata.image_count,
+              },
+            ])
+          }
         } else if (data.type === 'status') {
-          // Handle status updates (e.g., "thinking", "executing action")
+          // Handle status updates (e.g., "thinking", "executing action", "interrupt_received")
           console.log('Status:', data.content)
+          if (data.content === 'interrupt_received') {
+            // Show a system message that the interrupt was received
+            setMessages((prev) => [
+              ...prev,
+              {
+                id: Date.now().toString() + '-interrupt',
+                role: 'system',
+                content: 'Interrupt received - will be applied at next iteration',
+                timestamp: new Date(),
+              },
+            ])
+          }
         } else if (data.type === 'recording_status') {
           // Handle recording status updates
           if (data.session_id) {
@@ -158,7 +187,7 @@ export default function ChatWindow({ isRecording = false }: ChatWindowProps) {
   }, [isRecording, isConnected])
 
   const sendMessage = () => {
-    if (!input.trim() || !isConnected || isLoading) return
+    if (!input.trim() || !isConnected) return
 
     const userMessage: Message = {
       id: Date.now().toString(),
@@ -168,14 +197,24 @@ export default function ChatWindow({ isRecording = false }: ChatWindowProps) {
     }
 
     setMessages((prev) => [...prev, userMessage])
-    setIsLoading(true)
 
-    wsRef.current?.send(
-      JSON.stringify({
-        type: 'message',
-        content: input.trim(),
-      })
-    )
+    // If already loading, send as interrupt; otherwise send as new message
+    if (isLoading) {
+      wsRef.current?.send(
+        JSON.stringify({
+          type: 'interrupt',
+          content: input.trim(),
+        })
+      )
+    } else {
+      setIsLoading(true)
+      wsRef.current?.send(
+        JSON.stringify({
+          type: 'message',
+          content: input.trim(),
+        })
+      )
+    }
 
     setInput('')
   }
@@ -279,10 +318,26 @@ export default function ChatWindow({ isRecording = false }: ChatWindowProps) {
                   ? 'bg-blue-600 text-white'
                   : message.role === 'system'
                   ? 'bg-gray-800 text-gray-300 text-sm italic'
+                  : message.role === 'memory'
+                  ? 'bg-purple-900 text-purple-100 border border-purple-700'
                   : 'bg-gray-700 text-white'
               }`}
             >
-              <p className="whitespace-pre-wrap">{message.content}</p>
+              {message.role === 'memory' && message.thumbnail && (
+                <div className="mb-2">
+                  <img
+                    src={message.thumbnail}
+                    alt="Memory thumbnail"
+                    className="w-32 h-auto rounded border border-purple-600"
+                  />
+                  {message.imageCount && (
+                    <span className="text-xs text-purple-300 mt-1 block">
+                      +{message.imageCount - 1} more images
+                    </span>
+                  )}
+                </div>
+              )}
+              <p className="whitespace-pre-wrap break-words">{message.content}</p>
               <span className="text-xs opacity-50 mt-1 block">
                 {message.timestamp.toLocaleTimeString()}
               </span>
@@ -314,16 +369,20 @@ export default function ChatWindow({ isRecording = false }: ChatWindowProps) {
         <div className="flex gap-2">
           <textarea
             value={input}
-            onChange={(e) => setInput(e.target.value)}
+            onChange={(e) => {
+              setInput(e.target.value)
+              e.target.style.height = 'auto'
+              e.target.style.height = Math.min(e.target.scrollHeight, 120) + 'px'
+            }}
             onKeyDown={handleKeyDown}
             placeholder="Ask the agent to do something..."
-            className="flex-1 bg-gray-800 text-white rounded-lg px-4 py-2 resize-none focus:outline-none focus:ring-2 focus:ring-blue-500"
+            className="flex-1 bg-gray-800 text-white rounded-lg px-4 py-2 resize-none focus:outline-none focus:ring-2 focus:ring-blue-500 overflow-x-hidden break-words"
             rows={1}
             disabled={!isConnected}
           />
           <button
             onClick={sendMessage}
-            disabled={!isConnected || !input.trim() || isLoading}
+            disabled={!isConnected || !input.trim()}
             className="bg-blue-600 hover:bg-blue-700 disabled:bg-gray-700 disabled:cursor-not-allowed text-white px-4 py-2 rounded-lg transition-colors"
           >
             Send
diff --git a/services/python-agent/agent.py b/services/python-agent/agent.py
index ad0182c..ff5a3f8 100644
--- a/services/python-agent/agent.py
+++ b/services/python-agent/agent.py
@@ -1,13 +1,17 @@
+import asyncio
+import base64
 import json
 import logging
 import os
 from datetime import datetime
 from pathlib import Path
+from typing import Any
 from uuid import uuid4
 
 import aiohttp
 import google.generativeai as genai
 from google.ai.generativelanguage_v1beta.types.content import Part as GenaiPart
+from google.api_core.exceptions import ResourceExhausted, ServiceUnavailable
 from pydantic import ValidationError
 
 from mcp_client import MCPClient, MCPToolResult
@@ -26,11 +30,23 @@
 MAX_ITERATIONS = 30
 
 # Maximum consecutive failures per step before asking user for guidance
-MAX_RETRIES_PER_STEP = 3
+MAX_RETRIES_PER_STEP = 15
+
+# Retry configuration for API rate limit errors (429)
+MAX_API_RETRIES = 15
+INITIAL_RETRY_DELAY = 1.0  # seconds
+MAX_RETRY_DELAY = 60.0  # seconds
+RETRY_MULTIPLIER = 2.0  # exponential backoff multiplier
 
 # Logs directory for dumping context
 LOGS_DIR = Path("/app/logs")
 
+# Demo directory for image demonstrations
+DEMO_DIR = Path(os.getenv("DEMO_DIR", "/app/demo"))
+
+# Whether to load demo content (disabled by default)
+DEMO_ENABLED = os.getenv("DEMO_ENABLED", "false").lower() in ("true", "1", "yes")
+
 
 class BrowserAgent:
     def __init__(self):
@@ -39,13 +55,17 @@ def __init__(self):
             raise ValueError("GEMINI_API_KEY environment variable is required")
 
         genai.configure(api_key=self.api_key)
-        self.model = genai.GenerativeModel("gemini-2.0-flash")
+        self.model = genai.GenerativeModel("gemini-3-flash-preview")
         self.chat = None
         self.mcp_client: MCPClient | None = None
         self.conversation_history = []
         self.is_recording = False
         self.screenshot_counter = 0
+        self.demo_injected = False
         self.recording_session_id: str | None = None
+        # Interrupt mechanism for injecting context mid-execution
+        self.interrupt_queue: asyncio.Queue[str] = asyncio.Queue()
+        self.is_interrupted = False
 
     async def initialize(self):
         """Initialize the agent and connect to MCP server."""
@@ -58,13 +78,190 @@ async def initialize(self):
             {"role": "user", "parts": [system_prompt]},
             {"role": "model", "parts": ["Understood. I'm ready to help you interact with the browser. What would you like me to do?"]}
         ]
+
         self.chat = self.model.start_chat(history=self.conversation_history)
 
+    def _load_demo_content(self) -> tuple[list | None, dict | None]:
+        """Load demo images and description from the demo folder.
+
+        Returns a tuple of:
+            - list of message parts (text + images) if demo content exists, or None
+            - dict with metadata (description, thumbnail_base64) for UI display, or None
+        """
+        if not DEMO_ENABLED:
+            logger.info("Demo content disabled via DEMO_ENABLED env var")
+            return None, None
+
+        if not DEMO_DIR.exists():
+            logger.info(f"Demo directory not found: {DEMO_DIR}")
+            return None, None
+
+        description_path = DEMO_DIR / "description.txt"
+        if not description_path.exists():
+            logger.info(f"Demo description not found: {description_path}")
+            return None, None
+
+        # Read the description
+        description_text = description_path.read_text().strip()
+
+        # Find all image files, sorted by name (ignore prompt.txt)
+        image_extensions = {".png", ".jpg", ".jpeg", ".gif", ".webp"}
+        image_files = sorted(
+            f for f in DEMO_DIR.iterdir()
+            if f.suffix.lower() in image_extensions
+        )
+
+        if not image_files:
+            logger.info(f"No demo images found in {DEMO_DIR}")
+            return None, None
+
+        # Build the message parts
+        parts: list[str | genai.protos.Part] = []
+
+        # Add introductory text with description
+        intro_text = (
+            "Here is a demonstration of how to complete a similar task. "
+            "Use these images as a reference for how to interact with the browser.\n\n"
+            f"Task description: {description_text}\n\n"
+            "The following images show the step-by-step process:"
+        )
+        parts.append(intro_text)
+
+        # Track first image for thumbnail
+        thumbnail_base64 = None
+
+        # Add each image
+        for i, image_path in enumerate(image_files):
+            try:
+                image_data = image_path.read_bytes()
+                # Determine mime type
+                suffix = image_path.suffix.lower()
+                mime_type = {
+                    ".png": "image/png",
+                    ".jpg": "image/jpeg",
+                    ".jpeg": "image/jpeg",
+                    ".gif": "image/gif",
+                    ".webp": "image/webp",
+                }.get(suffix, "image/png")
+
+                image_part = genai.protos.Part(
+                    inline_data={"mime_type": mime_type, "data": image_data}
+                )
+                parts.append(image_part)
+                logger.info(f"Loaded demo image: {image_path.name} ({len(image_data)} bytes)")
+
+                # Use first image as thumbnail
+                if i == 0:
+                    thumbnail_base64 = f"data:{mime_type};base64,{base64.b64encode(image_data).decode()}"
+            except Exception as e:
+                logger.warning(f"Failed to load demo image {image_path}: {e}")
+
+        logger.info(f"Loaded {len(image_files)} demo images")
+
+        metadata = {
+            "description": description_text,
+            "thumbnail": thumbnail_base64,
+            "image_count": len(image_files),
+        }
+
+        return parts, metadata
+
+    async def inject_demo_content(self) -> dict | None:
+        """Inject demo content into the conversation.
+
+        Should be called before the first user message.
+        Returns metadata for UI display, or None if no demo available.
+        """
+        if self.chat is None:
+            raise RuntimeError("Agent not initialized. Call initialize() first.")
+
+        if self.demo_injected:
+            return None
+
+        self.demo_injected = True
+        demo_parts, metadata = self._load_demo_content()
+
+        if demo_parts:
+            await self._send_message_with_retry(demo_parts)
+            logger.info("Injected demo content into conversation")
+            return metadata
+
+        return None
+
     def _build_system_prompt(self) -> str:
         """Build system prompt with available tools and their parameter schemas."""
         tools = self.mcp_client.get_tools_for_llm() if self.mcp_client else []
         return build_system_prompt(tools)
 
+    async def interrupt(self, context: str | None = None) -> None:
+        """Signal the agent to pause and optionally inject context.
+
+        Args:
+            context: Optional text context to inject into the conversation.
+                    The agent will incorporate this at the next iteration.
+        """
+        self.is_interrupted = True
+        if context:
+            await self.interrupt_queue.put(context)
+        logger.info(f"Interrupt signal received (with context: {context is not None})")
+
+    async def _check_interrupt(self) -> str | None:
+        """Check if interrupted and return any pending context.
+
+        Returns:
+            The interrupt context string if available, None otherwise.
+        """
+        if not self.is_interrupted:
+            return None
+
+        try:
+            context = self.interrupt_queue.get_nowait()
+            return context
+        except asyncio.QueueEmpty:
+            return None
+
+    async def _send_message_with_retry(self, message: Any) -> Any:
+        """Send a message to Gemini with exponential backoff retry on rate limits.
+
+        Handles 429 (ResourceExhausted) and 503 (ServiceUnavailable) errors
+        by retrying with exponential backoff up to MAX_API_RETRIES times.
+
+        Args:
+            message: The message to send (can be string, list of parts, etc.)
+
+        Returns:
+            The response from Gemini API
+
+        Raises:
+            RuntimeError: If chat session is not initialized
+            ResourceExhausted: If max retries exceeded for rate limit errors
+            ServiceUnavailable: If max retries exceeded for service errors
+        """
+        if self.chat is None:
+            raise RuntimeError("Chat session not initialized. Call initialize() first.")
+
+        delay = INITIAL_RETRY_DELAY
+
+        for attempt in range(MAX_API_RETRIES):
+            try:
+                return await self.chat.send_message_async(message)
+            except (ResourceExhausted, ServiceUnavailable) as e:
+                if attempt == MAX_API_RETRIES - 1:
+                    logger.error(
+                        f"Max retries ({MAX_API_RETRIES}) exceeded for API call: {e}"
+                    )
+                    raise
+
+                logger.warning(
+                    f"API rate limited or unavailable, retrying in {delay:.1f}s "
+                    f"(attempt {attempt + 1}/{MAX_API_RETRIES}): {e}"
+                )
+                await asyncio.sleep(delay)
+                delay = min(delay * RETRY_MULTIPLIER, MAX_RETRY_DELAY)
+
+        # This should never be reached due to the raise in the loop
+        raise RuntimeError("Unexpected exit from retry loop")
+
     def set_recording(self, enabled: bool):
         """Enable or disable recording mode."""
         self.is_recording = enabled
@@ -352,7 +549,7 @@ async def process_message(self, user_message: str) -> str:
 
         try:
             # Send initial message to Gemini
-            response = await self.chat.send_message_async(user_message)
+            response = await self._send_message_with_retry(user_message)
             response_text = response.text
 
             # Collect user messages to return at the end
@@ -427,8 +624,15 @@ async def process_message(self, user_message: str) -> str:
                 # Build multimodal message with tool result (includes errors)
                 follow_up_parts = self._build_tool_result_message(tool_name, result)
 
+                # Check for user interrupt with additional context
+                interrupt_context = await self._check_interrupt()
+                if interrupt_context is not None:
+                    logger.info(f"Injecting interrupt context: {interrupt_context[:100]}...")
+                    follow_up_parts.append(f"\n\n[USER INTERRUPT - Additional context from user]: {interrupt_context}")
+                    self.is_interrupted = False  # Reset for next iteration
+
                 # Send result to Gemini and get next response
-                response = await self.chat.send_message_async(follow_up_parts)
+                response = await self._send_message_with_retry(follow_up_parts)
                 response_text = response.text
 
                 # Dump context after each tool execution for debugging
diff --git a/services/python-agent/main.py b/services/python-agent/main.py
index 25f7817..3e15cac 100644
--- a/services/python-agent/main.py
+++ b/services/python-agent/main.py
@@ -71,6 +71,43 @@ async def get_shared_mcp_client() -> MCPClient:
     return shared_mcp_client
 
 
+async def _process_and_respond(
+    agent: BrowserAgent,
+    websocket: WebSocket,
+    user_content: str
+) -> None:
+    """Process a message and send the response. Runs as a background task."""
+    try:
+        # Check if we should inject demo content (first message only)
+        if not agent.demo_injected:
+            demo_metadata = await agent.inject_demo_content()
+            if demo_metadata:
+                await websocket.send_json({
+                    "type": "memory_injected",
+                    "metadata": demo_metadata
+                })
+                logger.info("Sent memory_injected message to client")
+
+        # Send status update
+        await websocket.send_json({
+            "type": "status",
+            "content": "thinking"
+        })
+
+        # Process with agent
+        response = await agent.process_message(user_content)
+        await websocket.send_json({
+            "type": "response",
+            "content": response
+        })
+    except Exception as e:
+        logger.error(f"Agent error: {e}")
+        await websocket.send_json({
+            "type": "response",
+            "content": f"Sorry, I encountered an error: {str(e)}"
+        })
+
+
 @app.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket):
     await websocket.accept()
@@ -90,6 +127,9 @@ async def websocket_endpoint(websocket: WebSocket):
 
     logger.info(f"Client connected: {connection_id}")
 
+    # Track the current processing task
+    processing_task: asyncio.Task | None = None
+
     try:
         while True:
             data = await websocket.receive_text()
@@ -106,35 +146,49 @@ async def websocket_endpoint(websocket: WebSocket):
                     "session_id": agent.recording_session_id
                 })
 
+            elif message.get("type") == "interrupt":
+                # User wants to interrupt with additional context
+                context = message.get("content", "")
+                if processing_task and not processing_task.done():
+                    await agent.interrupt(context)
+                    await websocket.send_json({
+                        "type": "status",
+                        "content": "interrupt_received"
+                    })
+                    logger.info(f"Interrupt queued with context: {context[:50]}...")
+                else:
+                    logger.warning("Interrupt received but no active processing task")
+                    await websocket.send_json({
+                        "type": "status",
+                        "content": "no_active_task"
+                    })
+
             elif message.get("type") == "message":
                 user_content = message.get("content", "")
                 logger.info(f"Received message: {user_content}")
 
-                # Send status update
-                await websocket.send_json({
-                    "type": "status",
-                    "content": "thinking"
-                })
-
-                # Process with agent
-                try:
-                    response = await agent.process_message(user_content)
-                    await websocket.send_json({
-                        "type": "response",
-                        "content": response
-                    })
-                except Exception as e:
-                    logger.error(f"Agent error: {e}")
+                # Check if already processing - treat as interrupt
+                if processing_task and not processing_task.done():
+                    await agent.interrupt(user_content)
                     await websocket.send_json({
-                        "type": "response",
-                        "content": f"Sorry, I encountered an error: {str(e)}"
+                        "type": "status",
+                        "content": "interrupt_received"
                     })
+                    logger.info(f"Message queued as interrupt: {user_content[:50]}...")
+                else:
+                    # Start new processing task
+                    processing_task = asyncio.create_task(
+                        _process_and_respond(agent, websocket, user_content)
+                    )
 
     except WebSocketDisconnect:
         logger.info(f"Client disconnected: {connection_id}")
     except Exception as e:
         logger.error(f"WebSocket error: {e}")
     finally:
+        # Cancel any running task
+        if processing_task and not processing_task.done():
+            processing_task.cancel()
         # Cleanup - don't disconnect shared MCP client
         if connection_id in active_connections:
             del active_connections[connection_id]
diff --git a/services/python-agent/prompts.py b/services/python-agent/prompts.py
index 836cbc6..feb1940 100644
--- a/services/python-agent/prompts.py
+++ b/services/python-agent/prompts.py
@@ -42,10 +42,7 @@ def build_system_prompt(tools: list[dict]) -> str:
     """
     tools_desc = "\n".join(format_tool_schema(t) for t in tools)
 
-    return f"""You are a helpful browser automation assistant. You can control a web browser to help users accomplish tasks.
-
-## Available Tools
-{tools_desc}
+    return f"""You are a helpful browser automation assistant. You can control a web browser to help users accomplish tasks that the user explicitly asks for. When a task is complete, confirm completion with the user before taking further actions.
 
 ## Response Format
 You MUST ALWAYS respond with a JSON object in this exact format:
@@ -80,6 +77,9 @@ def build_system_prompt(tools: list[dict]) -> str:
 4. After 2-3 failed attempts at the same action, explain the issue to the user and ask for guidance
 5. Never repeat the exact same failed action - always try something different
 
+## Available Tools
+{tools_desc}
+
 Be helpful, proactive, and thorough in completing user requests."""