diff --git a/config.template.toml b/config.template.toml
index 15c4809ef..5a8ce3228 100644
--- a/config.template.toml
+++ b/config.template.toml
@@ -271,7 +271,7 @@ classpath = "my_package.my_module.MyCustomAgent"
 #user_id = 1000
 
 # Container image to use for the sandbox
-#base_container_image = "nikolaik/python-nodejs:python3.12-nodejs22"
+#base_container_image = "ubuntu:24.04"
 
 # Use host network
 #use_host_network = false
diff --git a/containers/runtime/README.md b/containers/runtime/README.md
index 9fbed76aa..8b15471b4 100644
--- a/containers/runtime/README.md
+++ b/containers/runtime/README.md
@@ -7,6 +7,6 @@ The following command will generate a `Dockerfile` file for `nikolaik/python-nod
 
 ```bash
 poetry run python3 openhands/runtime/utils/runtime_build.py \
-    --base_image nikolaik/python-nodejs:python3.12-nodejs22 \
+    --base_image ubuntu:24.04 \
     --build_folder containers/runtime
 ```
diff --git a/docs/usage/architecture/runtime.mdx b/docs/usage/architecture/runtime.mdx
index 5ebcf3baf..63bc50b34 100644
--- a/docs/usage/architecture/runtime.mdx
+++ b/docs/usage/architecture/runtime.mdx
@@ -88,7 +88,7 @@ for only the openhands source
 
 This hash is built from the first 16 digits of the MD5 of:
 
-- The name of the base image upon which the image was built (e.g.: `nikolaik/python-nodejs:python3.12-nodejs22`)
+- The name of the base image upon which the image was built (e.g.: `ubuntu:22.04`)
 - The content of the `pyproject.toml` included in the image.
 - The content of the `poetry.lock` included in the image.
 
diff --git a/docs/usage/configuration-options.mdx b/docs/usage/configuration-options.mdx
index 2115a7b50..25cc27b2a 100644
--- a/docs/usage/configuration-options.mdx
+++ b/docs/usage/configuration-options.mdx
@@ -347,7 +347,7 @@ To use these with the docker command, pass in `-e SANDBOX_<option>`. Example: `-
 ### Container Image
 - `base_container_image`
   - Type: `str`
-  - Default: `"nikolaik/python-nodejs:python3.12-nodejs22"`
+  - Default: `"ubuntu:24.04"`
   - Description: Container image to use for the sandbox
 
 ### Networking
diff --git a/docs/usage/how-to/custom-sandbox-guide.mdx b/docs/usage/how-to/custom-sandbox-guide.mdx
index dc32910f3..99b9dca54 100644
--- a/docs/usage/how-to/custom-sandbox-guide.mdx
+++ b/docs/usage/how-to/custom-sandbox-guide.mdx
@@ -24,7 +24,7 @@ To create a custom Docker image, it must be Debian based.
 For example, if you want OpenHands to have `ruby` installed, you could create a `Dockerfile` with the following content:
 
 ```dockerfile
-FROM nikolaik/python-nodejs:python3.12-nodejs22
+FROM ubuntu:24.04
 
 # Install required packages
 RUN apt-get update && apt-get install -y ruby
diff --git a/openhands/agenthub/codeact_agent/codeact_agent.py b/openhands/agenthub/codeact_agent/codeact_agent.py
index ffbb146ab..1b3458163 100644
--- a/openhands/agenthub/codeact_agent/codeact_agent.py
+++ b/openhands/agenthub/codeact_agent/codeact_agent.py
@@ -12,6 +12,7 @@
 import openhands.agenthub.codeact_agent.function_calling as codeact_function_calling
 from openhands.agenthub.codeact_agent.tools.bash import create_cmd_run_tool
 from openhands.agenthub.codeact_agent.tools.browser import BrowserTool
+from openhands.agenthub.codeact_agent.tools.computer_use import ComputerUseTool
 from openhands.agenthub.codeact_agent.tools.finish import FinishTool
 from openhands.agenthub.codeact_agent.tools.ipython import IPythonTool
 from openhands.agenthub.codeact_agent.tools.llm_based_edit import LLMBasedFileEditTool
@@ -132,6 +133,9 @@ def _get_tools(self) -> list['ChatCompletionToolParam']:
                 logger.warning('Windows runtime does not support browsing yet')
             else:
                 tools.append(BrowserTool)
+        # Add computer_use tool for OS-level interactions
+        if sys.platform != 'win32':
+            tools.append(ComputerUseTool)
         if self.config.enable_jupyter:
             tools.append(IPythonTool)
         if self.config.enable_llm_editor:
diff --git a/openhands/agenthub/codeact_agent/function_calling.py b/openhands/agenthub/codeact_agent/function_calling.py
index f4250fc11..87246bedf 100644
--- a/openhands/agenthub/codeact_agent/function_calling.py
+++ b/openhands/agenthub/codeact_agent/function_calling.py
@@ -11,6 +11,7 @@
 
 from openhands.agenthub.codeact_agent.tools import (
     BrowserTool,
+    ComputerUseTool,
     FinishTool,
     IPythonTool,
     LLMBasedFileEditTool,
@@ -34,6 +35,7 @@
     FileReadAction,
     IPythonRunCellAction,
     MessageAction,
+    OSInteractiveAction,
 )
 from openhands.events.action.mcp import MCPAction
 from openhands.events.event import FileEditSource, FileReadSource
@@ -219,6 +221,16 @@ def response_to_actions(
                     )
                 action = BrowseInteractiveAction(browser_actions=arguments['code'])
 
+            # ================================================
+            # ComputerUseTool
+            # ================================================
+            elif tool_call.function.name == ComputerUseTool['function']['name']:
+                if 'code' not in arguments:
+                    raise FunctionCallValidationError(
+                        f'Missing required argument "code" in tool call {tool_call.function.name}'
+                    )
+                action = OSInteractiveAction(os_actions=arguments['code'])
+
             # ================================================
             # MCPAction (MCP)
             # ================================================
diff --git a/openhands/agenthub/codeact_agent/tools/__init__.py b/openhands/agenthub/codeact_agent/tools/__init__.py
index 683533082..c3f852fdb 100644
--- a/openhands/agenthub/codeact_agent/tools/__init__.py
+++ b/openhands/agenthub/codeact_agent/tools/__init__.py
@@ -1,5 +1,6 @@
 from .bash import create_cmd_run_tool
 from .browser import BrowserTool
+from .computer_use import ComputerUseTool
 from .finish import FinishTool
 from .ipython import IPythonTool
 from .llm_based_edit import LLMBasedFileEditTool
@@ -8,6 +9,7 @@
 
 __all__ = [
     'BrowserTool',
+    'ComputerUseTool',
     'create_cmd_run_tool',
     'FinishTool',
     'IPythonTool',
diff --git a/openhands/agenthub/codeact_agent/tools/computer_use.py b/openhands/agenthub/codeact_agent/tools/computer_use.py
new file mode 100644
index 000000000..ded7b22c9
--- /dev/null
+++ b/openhands/agenthub/codeact_agent/tools/computer_use.py
@@ -0,0 +1,239 @@
+from litellm import ChatCompletionToolParam, ChatCompletionToolParamFunctionChunk
+
+from openhands.llm.tool_names import COMPUTER_USE_TOOL_NAME
+
+_COMPUTER_USE_DESCRIPTION = """Interact with the operating system using Python code. Use it when you need to control the mouse, keyboard, or take screenshots.
+
+See the description of "code" parameter for more details.
+
+Multiple actions can be provided at once, but will be executed sequentially without any feedback.
+More than 2-3 actions usually leads to failure or unexpected behavior. Example:
+moveTo(100, 200)
+click()
+typewrite('Hello World')
+press('enter')
+"""
+
+_COMPUTER_USE_TOOL_DESCRIPTION = """
+The following functions are available from pyautogui. Nothing else is supported.
+
+# Mouse Control Functions
+
+moveTo(x: int, y: int, duration: float = 0.0)
+    Description: Move the mouse cursor to the specified (x, y) position on screen.
+    Args:
+        x: X coordinate (0 is left edge)
+        y: Y coordinate (0 is top edge)
+        duration: Time in seconds to move the mouse (default: instant)
+    Examples:
+        moveTo(100, 200)
+        moveTo(500, 500, duration=2.0)
+
+move(xOffset: int, yOffset: int, duration: float = 0.0)
+    Description: Move the mouse cursor relative to its current position.
+    Args:
+        xOffset: Number of pixels to move horizontally (positive = right, negative = left)
+        yOffset: Number of pixels to move vertically (positive = down, negative = up)
+        duration: Time in seconds to move the mouse
+    Examples:
+        move(50, 0)
+        move(-100, -100, duration=1.0)
+
+click(x: int | None = None, y: int | None = None, clicks: int = 1, interval: float = 0.0, button: str = 'left')
+    Description: Click the mouse button at current position or specified position.
+    Args:
+        x: Optional X coordinate to click at
+        y: Optional Y coordinate to click at
+        clicks: Number of clicks (default: 1)
+        interval: Seconds between clicks (default: 0.0)
+        button: Which button to click - 'left', 'middle', or 'right' (default: 'left')
+    Examples:
+        click()
+        click(100, 200)
+        click(clicks=2, interval=0.25)
+        click(button='right')
+
+doubleClick(x: int | None = None, y: int | None = None, interval: float = 0.0, button: str = 'left')
+    Description: Double click the mouse button.
+    Args:
+        x: Optional X coordinate
+        y: Optional Y coordinate
+        interval: Seconds between clicks
+        button: Which button - 'left', 'middle', or 'right'
+    Examples:
+        doubleClick()
+        doubleClick(100, 200)
+
+rightClick(x: int | None = None, y: int | None = None)
+    Description: Right click the mouse.
+    Examples:
+        rightClick()
+        rightClick(500, 300)
+
+drag(x: int, y: int, duration: float = 0.0, button: str = 'left')
+    Description: Drag mouse to a position while holding down button.
+    Args:
+        x: X coordinate to drag to
+        y: Y coordinate to drag to
+        duration: Time in seconds to perform drag
+        button: Which button to hold - 'left', 'middle', or 'right'
+    Examples:
+        drag(100, 200)
+        drag(300, 400, duration=2.0, button='right')
+
+scroll(clicks: int, x: int | None = None, y: int | None = None)
+    Description: Scroll the mouse wheel.
+    Args:
+        clicks: Amount to scroll (positive = up, negative = down)
+        x: Optional X coordinate to scroll at
+        y: Optional Y coordinate to scroll at
+    Examples:
+        scroll(10)
+        scroll(-3)
+        scroll(5, x=500, y=500)
+
+position()
+    Description: Get the current mouse position as a tuple (x, y).
+    Examples:
+        position()
+
+# Keyboard Control Functions
+
+typewrite(message: str, interval: float = 0.0)
+    Description: Type a string of characters.
+    Args:
+        message: The string to type
+        interval: Seconds between each keypress (default: 0.0)
+    Examples:
+        typewrite('Hello World')
+        typewrite('Slow typing', interval=0.1)
+
+write(message: str, interval: float = 0.0)
+    Description: Alias for typewrite. Type a string of characters.
+    Examples:
+        write('Hello World')
+
+press(keys: str | list[str], presses: int = 1, interval: float = 0.0)
+    Description: Press a key or list of keys.
+    Args:
+        keys: Key name or list of key names to press
+        presses: Number of times to press (default: 1)
+        interval: Seconds between presses
+    Valid key names include: 'enter', 'esc', 'tab', 'space', 'backspace', 'delete', 'up', 'down',
+    'left', 'right', 'home', 'end', 'pageup', 'pagedown', 'f1'-'f12', 'shift', 'ctrl', 'alt',
+    'win', 'command', 'option', 'a'-'z', '0'-'9', etc.
+    Examples:
+        press('enter')
+        press(['ctrl', 'c'])
+        press('a', presses=3)
+
+keyDown(key: str)
+    Description: Press and hold a key down.
+    Examples:
+        keyDown('shift')
+        keyDown('ctrl')
+
+keyUp(key: str)
+    Description: Release a key.
+    Examples:
+        keyUp('shift')
+        keyUp('ctrl')
+
+hotkey(*keys: str)
+    Description: Press multiple keys simultaneously (like Ctrl+C).
+    Args:
+        *keys: Variable number of key names
+    Examples:
+        hotkey('ctrl', 'c')
+        hotkey('ctrl', 'alt', 'delete')
+        hotkey('command', 'v')
+
+# Screen Functions
+
+size()
+    Description: Get the screen size as a tuple (width, height).
+    Examples:
+        size()
+
+screenshot(imageFilename: str | None = None, region: tuple[int, int, int, int] | None = None)
+    Description: Take a screenshot and optionally save it.
+    Args:
+        imageFilename: Optional path to save the screenshot
+        region: Optional (left, top, width, height) tuple to capture only part of screen
+    Returns: PIL Image object
+    Examples:
+        screenshot()
+        screenshot('/tmp/screenshot.png')
+        screenshot(region=(0, 0, 300, 400))
+
+locateOnScreen(image: str, confidence: float = 0.9)
+    Description: Locate an image on the screen and return its position.
+    Args:
+        image: Path to the image file to locate
+        confidence: Match confidence (0.0 to 1.0, default: 0.9)
+    Returns: Box object with (left, top, width, height) or None if not found
+    Examples:
+        locateOnScreen('/tmp/button.png')
+        locateOnScreen('/tmp/icon.png', confidence=0.8)
+
+locateCenterOnScreen(image: str, confidence: float = 0.9)
+    Description: Locate an image and return its center coordinates.
+    Args:
+        image: Path to the image file to locate
+        confidence: Match confidence (0.0 to 1.0)
+    Returns: Point object with (x, y) or None if not found
+    Examples:
+        locateCenterOnScreen('/tmp/button.png')
+
+# Alert and Message Box Functions
+
+alert(text: str = '', title: str = '', button: str = 'OK')
+    Description: Display a simple alert box.
+    Examples:
+        alert('Task complete!')
+        alert(text='Warning!', title='Alert', button='OK')
+
+confirm(text: str = '', title: str = '', buttons: list[str] = ['OK', 'Cancel'])
+    Description: Display a confirmation dialog.
+    Returns: The text of the button clicked
+    Examples:
+        confirm('Are you sure?')
+        confirm('Proceed?', title='Confirmation', buttons=['Yes', 'No'])
+
+prompt(text: str = '', title: str = '', default: str = '')
+    Description: Display a text input prompt.
+    Returns: The text entered by the user or None if cancelled
+    Examples:
+        prompt('Enter your name:')
+        prompt('Enter value:', default='100')
+
+# Utility Functions
+
+sleep(seconds: float)
+    Description: Pause execution for a given number of seconds.
+    Examples:
+        sleep(1.0)
+        sleep(0.5)
+"""
+
+ComputerUseTool = ChatCompletionToolParam(
+    type='function',
+    function=ChatCompletionToolParamFunctionChunk(
+        name=COMPUTER_USE_TOOL_NAME,
+        description=_COMPUTER_USE_DESCRIPTION,
+        parameters={
+            'type': 'object',
+            'properties': {
+                'code': {
+                    'type': 'string',
+                    'description': (
+                        'The Python code that interacts with the operating system using pyautogui.\n'
+                        + _COMPUTER_USE_TOOL_DESCRIPTION
+                    ),
+                }
+            },
+            'required': ['code'],
+        },
+    ),
+)
+
diff --git a/openhands/core/config/sandbox_config.py b/openhands/core/config/sandbox_config.py
index 55edb8c09..c3aa6fef2 100644
--- a/openhands/core/config/sandbox_config.py
+++ b/openhands/core/config/sandbox_config.py
@@ -60,7 +60,7 @@ class SandboxConfig(BaseModel):
     rm_all_containers: bool = Field(default=False)
     api_key: str | None = Field(default=None)
     base_container_image: str | None = Field(
-        default='nikolaik/python-nodejs:python3.12-nodejs22'
+        default='ubuntu:24.04'
     )
     runtime_container_image: str | None = Field(default=None)
     user_id: int = Field(default=os.getuid() if hasattr(os, 'getuid') else 1000)
@@ -129,5 +129,5 @@ def from_toml_section(cls, data: dict) -> dict[str, 'SandboxConfig']:
     @model_validator(mode='after')
     def set_default_base_image(self) -> 'SandboxConfig':
         if self.base_container_image is None:
-            self.base_container_image = 'nikolaik/python-nodejs:python3.12-nodejs22'
+            self.base_container_image = 'ubuntu:24.04'
         return self
diff --git a/openhands/core/schema/action.py b/openhands/core/schema/action.py
index 4954aec15..f1d4c6c5f 100644
--- a/openhands/core/schema/action.py
+++ b/openhands/core/schema/action.py
@@ -42,6 +42,10 @@ class ActionType(str, Enum):
     """Interact with the browser instance.
     """
 
+    OS_INTERACTIVE = 'os_interactive'
+    """Interact with the operating system using pyautogui.
+    """
+
     MCP = 'call_tool_mcp'
     """Interact with the MCP server.
     """
diff --git a/openhands/events/action/__init__.py b/openhands/events/action/__init__.py
index a30a5545a..3cd20ac0e 100644
--- a/openhands/events/action/__init__.py
+++ b/openhands/events/action/__init__.py
@@ -17,6 +17,7 @@
 )
 from openhands.events.action.mcp import MCPAction
 from openhands.events.action.message import MessageAction, SystemMessageAction
+from openhands.events.action.os import OSInteractiveAction
 
 __all__ = [
     'Action',
@@ -24,6 +25,7 @@
     'CmdRunAction',
     'BrowseURLAction',
     'BrowseInteractiveAction',
+    'OSInteractiveAction',
     'FileReadAction',
     'FileWriteAction',
     'FileEditAction',
diff --git a/openhands/events/action/os.py b/openhands/events/action/os.py
new file mode 100644
index 000000000..703db7024
--- /dev/null
+++ b/openhands/events/action/os.py
@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+from typing import ClassVar
+
+from openhands.core.schema import ActionType
+from openhands.events.action.action import Action, ActionSecurityRisk
+
+
+@dataclass
+class OSInteractiveAction(Action):
+    os_actions: str
+    thought: str = ''
+    action: str = ActionType.OS_INTERACTIVE
+    runnable: ClassVar[bool] = True
+    security_risk: ActionSecurityRisk | None = None
+
+    @property
+    def message(self) -> str:
+        return f'I am interacting with the operating system:\n```\n{self.os_actions}\n```'
+
+    def __str__(self) -> str:
+        ret = '**OSInteractiveAction**\n'
+        if self.thought:
+            ret += f'THOUGHT: {self.thought}\n'
+        ret += f'OS_ACTIONS: {self.os_actions}'
+        return ret
+
diff --git a/openhands/events/serialization/action.py b/openhands/events/serialization/action.py
index 3d2debbef..a07d917bf 100644
--- a/openhands/events/serialization/action.py
+++ b/openhands/events/serialization/action.py
@@ -1,6 +1,7 @@
 from typing import Any
 
 from openhands.core.exceptions import LLMMalformedActionError
+from openhands.events.action import OSInteractiveAction
 from openhands.events.action.action import Action
 from openhands.events.action.agent import (
     AgentDelegateAction,
@@ -44,6 +45,7 @@
     SystemMessageAction,
     CondensationAction,
     MCPAction,
+    OSInteractiveAction,
 )
 
 ACTION_TYPE_TO_CLASS = {action_class.action: action_class for action_class in actions}  # type: ignore[attr-defined]
diff --git a/openhands/llm/tool_names.py b/openhands/llm/tool_names.py
index b61c8198e..eee86c7a4 100644
--- a/openhands/llm/tool_names.py
+++ b/openhands/llm/tool_names.py
@@ -3,4 +3,5 @@
 EXECUTE_BASH_TOOL_NAME = 'execute_bash'
 STR_REPLACE_EDITOR_TOOL_NAME = 'str_replace_editor'
 BROWSER_TOOL_NAME = 'browser'
+COMPUTER_USE_TOOL_NAME = 'computer_use'
 FINISH_TOOL_NAME = 'finish'
diff --git a/openhands/nvidia/stem_agent/stem_handler.py b/openhands/nvidia/stem_agent/stem_handler.py
index 74eb6c3a6..f69375d80 100644
--- a/openhands/nvidia/stem_agent/stem_handler.py
+++ b/openhands/nvidia/stem_agent/stem_handler.py
@@ -82,4 +82,4 @@ def eval_exception(self, job_details: JobDetails, exception: Exception) -> dict[
 
     def final_result(self, job_details: JobDetails) -> dict[str, Any]:
         """Process final results using utils functions."""
-        return utils_final_result(job_details)
\ No newline at end of file
+        return utils_final_result(job_details)
diff --git a/openhands/nvidia/stem_agent/stem_utils.py b/openhands/nvidia/stem_agent/stem_utils.py
index 8535dfeac..97953f0be 100644
--- a/openhands/nvidia/stem_agent/stem_utils.py
+++ b/openhands/nvidia/stem_agent/stem_utils.py
@@ -36,6 +36,7 @@
 import os
 from pathlib import Path
 
+
 def get_config(
     instance: dict,
     metadata: EvalMetadata,
@@ -129,7 +130,7 @@ def obtain_problem_statement(instance: dict) -> str:
         if " Let's think step by step and output the final answer within \\boxed{}." in problem_statement:
             problem_statement = problem_statement.replace(" Let's think step by step and output the final answer within \\boxed{}.", "")
         return problem_statement
-        
+
     instruction = f"""
 Your task is to solve challenging STEM problems by using appropriate tools, such as web search, extraction, or crawling functions provided in the system instruction. These tools allow you to access and analyze real-time web content, structured data, and raw HTML. You are allowed and expected to use these tools to explore, reason, and verify your answers.
 
@@ -185,7 +186,7 @@ async def initialize_agents(
         details=None,
         condenser_config=NoOpCondenserConfig(),
     )
-    
+
     config = get_config(instance, metadata, agent_config)
     runtime = create_runtime(config, sid=sid)
 
@@ -293,4 +294,4 @@ async def evaluate_agent(reward: Reward, run_results: dict, instance: dict):
         eval_results =  await reward.get_reward(instance, response)
         return eval_results
     except:
-        return {'resolved': False, 'reward': 0}
\ No newline at end of file
+        return {'resolved': False, 'reward': 0}
diff --git a/openhands/runtime/action_execution_server.py b/openhands/runtime/action_execution_server.py
index 2834f40f5..3e05606bd 100644
--- a/openhands/runtime/action_execution_server.py
+++ b/openhands/runtime/action_execution_server.py
@@ -12,6 +12,7 @@
 import mimetypes
 import os
 import shutil
+import subprocess
 import sys
 import tempfile
 import time
@@ -54,6 +55,7 @@
     FileReadAction,
     FileWriteAction,
     IPythonRunCellAction,
+    OSInteractiveAction,
 )
 from openhands.events.event import FileEditSource, FileReadSource
 from openhands.events.observation import (
@@ -206,6 +208,11 @@ def __init__(
         self.browser_init_task: asyncio.Task | None = None
         self.browsergym_eval_env = browsergym_eval_env
 
+        # Xvfb for computer_use tool
+        self.xvfb_process: subprocess.Popen | None = None
+        self.xfce4_process: subprocess.Popen | None = None
+        self.xvfb_initialized = False
+
         self.start_time = time.time()
         self.last_execution_time = self.start_time
         self._initialized = False
@@ -636,12 +643,199 @@ async def browse_interactive(self, action: BrowseInteractiveAction) -> Observati
         await self._ensure_browser_ready()
         return await browse(action, self.browser, self.initial_cwd)
 
+    def _ensure_xvfb_ready(self):
+        """Ensure Xvfb is running for computer_use tool."""
+        if sys.platform == 'win32':
+            logger.warning('Xvfb not supported on Windows')
+            return False
+
+        if self.xvfb_initialized:
+            return True
+
+        # Create .Xauthority file if it doesn't exist
+        xauthority_path = Path.home() / '.Xauthority'
+        try:
+            xauthority_path.touch(exist_ok=True)
+            logger.debug(f'Ensured .Xauthority exists at {xauthority_path}')
+        except Exception as e:
+            logger.warning(f'Failed to create .Xauthority: {e}')
+
+        # Setup XDG_RUNTIME_DIR for D-Bus and xfce4
+        user_runtime_dir = f'/run/user/{os.getuid()}'
+        try:
+            if not os.path.exists(user_runtime_dir):
+                os.makedirs(user_runtime_dir, mode=0o700, exist_ok=True)
+                logger.info(f'Created XDG_RUNTIME_DIR at {user_runtime_dir}')
+            os.environ['XDG_RUNTIME_DIR'] = user_runtime_dir
+        except Exception as e:
+            logger.warning(f'Failed to create XDG_RUNTIME_DIR: {e}')
+
+        # Get screen number from environment variable
+        screen_number = os.environ.get('SCREEN_NUMBER', '99')
+        display = f':{screen_number}'
+
+        try:
+            xvfb_was_running = False
+            if xvfb_was_running:
+                # Xvfb is already running
+                logger.info(f'Xvfb already running on display {display}')
+            else:
+                # Start Xvfb
+                logger.info(f'Starting Xvfb on display {display}')
+                xvfb_cmd = [
+                    'Xvfb',
+                    display,
+                    '-screen',
+                    '0',
+                    '1024x768x24',
+                ]
+                self.xvfb_process = subprocess.Popen(
+                    xvfb_cmd,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+                # Give Xvfb time to start
+                time.sleep(1)
+                logger.info(f'Xvfb started on display {display}')
+
+            # Set the DISPLAY environment variable globally
+            os.environ['DISPLAY'] = display
+            # Start xfce4-session
+            logger.info('Starting xfce4-session')
+            try:
+                self.xfce4_process = subprocess.Popen(
+                    ['xfce4-session'],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    env=os.environ.copy(),
+                )
+                # Give xfce4 time to start
+                time.sleep(2)
+                logger.info('xfce4-session started')
+            except Exception as e:
+                logger.warning(
+                    f'Failed to start xfce4-session: {e}. Continuing without desktop environment.'
+                )
+
+            self.xvfb_initialized = True
+            return True
+
+        except Exception as e:
+            logger.error(f'Failed to initialize Xvfb: {e}')
+            return False
+
+    async def os_interactive(self, action: OSInteractiveAction) -> Observation:
+        """Handle OS interactive actions using pyautogui."""
+        if sys.platform == 'win32':
+            return ErrorObservation('OS interactive actions not supported on Windows.')
+
+        # Ensure Xvfb is ready
+        if not self._ensure_xvfb_ready():
+            return ErrorObservation('Failed to initialize virtual display (Xvfb).')
+
+        try:
+            # Import pyautogui here to avoid import errors if not installed
+            import pyautogui
+
+            # Disable the failsafe feature to prevent corner-triggered failures
+            pyautogui.FAILSAFE = False
+
+            # Wrapper for screenshot that creates parent directories
+            def screenshot_with_mkdir(imageFilename=None, region=None):
+                """Wrapper for pyautogui.screenshot that creates parent directories."""
+                if imageFilename:
+                    # Create parent directories if they don't exist
+                    parent_dir = os.path.dirname(imageFilename)
+                    if parent_dir:
+                        os.makedirs(parent_dir, exist_ok=True)
+                return pyautogui.screenshot(imageFilename=imageFilename, region=region)
+
+            # Create a restricted namespace for pyautogui execution
+            namespace = {
+                'moveTo': pyautogui.moveTo,
+                'move': pyautogui.move,
+                'click': pyautogui.click,
+                'doubleClick': pyautogui.doubleClick,
+                'rightClick': pyautogui.rightClick,
+                'drag': pyautogui.drag,
+                'scroll': pyautogui.scroll,
+                'position': pyautogui.position,
+                'typewrite': pyautogui.typewrite,
+                'write': pyautogui.write,
+                'press': pyautogui.press,
+                'keyDown': pyautogui.keyDown,
+                'keyUp': pyautogui.keyUp,
+                'hotkey': pyautogui.hotkey,
+                'size': pyautogui.size,
+                'screenshot': screenshot_with_mkdir,
+                'locateOnScreen': pyautogui.locateOnScreen,
+                'locateCenterOnScreen': pyautogui.locateCenterOnScreen,
+                'alert': pyautogui.alert,
+                'confirm': pyautogui.confirm,
+                'prompt': pyautogui.prompt,
+                'sleep': time.sleep,
+            }
+
+            # Execute the OS actions
+            output_lines = []
+            for line in action.os_actions.strip().split('\n'):
+                line = line.strip()
+                if not line or line.startswith('#'):
+                    continue
+
+                try:
+                    # Execute the line and capture any return value
+                    result = eval(line, {'__builtins__': {}}, namespace)
+                    if result is not None:
+                        output_lines.append(f'{line} -> {result}')
+                    else:
+                        output_lines.append(f'{line}')
+                except Exception as e:
+                    error_msg = f'Error executing "{line}": {str(e)}'
+                    logger.error(error_msg)
+                    output_lines.append(error_msg)
+
+            output = (
+                '\n'.join(output_lines)
+                if output_lines
+                else 'OS actions executed successfully'
+            )
+
+            # Return a CmdOutputObservation since we don't have a specific OS observation
+            return CmdOutputObservation(
+                content=output,
+                command=action.os_actions,
+                exit_code=0,
+            )
+
+        except ImportError:
+            return ErrorObservation(
+                'pyautogui is not installed. Please install it with: pip install pyautogui'
+            )
+        except Exception as e:
+            logger.error(f'Error executing OS actions: {e}')
+            return ErrorObservation(f'Error executing OS actions: {str(e)}')
+
     def close(self):
         self.memory_monitor.stop_monitoring()
         if self.bash_session is not None:
             self.bash_session.close()
         if self.browser is not None:
             self.browser.close()
+        if self.xfce4_process is not None:
+            try:
+                self.xfce4_process.terminate()
+                self.xfce4_process.wait(timeout=5)
+                logger.info('xfce4 process terminated')
+            except Exception as e:
+                logger.warning(f'Failed to terminate xfce4 process: {e}')
+        if self.xvfb_process is not None:
+            try:
+                self.xvfb_process.terminate()
+                self.xvfb_process.wait(timeout=5)
+                logger.info('Xvfb process terminated')
+            except Exception as e:
+                logger.warning(f'Failed to terminate Xvfb process: {e}')
 
 
 if __name__ == '__main__':
@@ -1227,6 +1421,13 @@ async def list_files(request: Request):
 
     logger.info(f'Starting action execution API on UDS socket: {socket_path}')
 
+    # import debugpy
+    # debugpy.listen(5678)
+    # logger.info('Waiting for debugger attach')
+    # debugpy.wait_for_client()
+    # logger.info('Debugger attached')
+    # debugpy.breakpoint()
+
     # Run with UDS socket instead of TCP
     config = Config(app=app, uds=socket_path, log_level='error')
     server = Server(config)
diff --git a/openhands/runtime/impl/action_execution/action_execution_client.py b/openhands/runtime/impl/action_execution/action_execution_client.py
index 2c7fca6f7..cd3c6f800 100644
--- a/openhands/runtime/impl/action_execution/action_execution_client.py
+++ b/openhands/runtime/impl/action_execution/action_execution_client.py
@@ -29,6 +29,7 @@
     FileReadAction,
     FileWriteAction,
     IPythonRunCellAction,
+    OSInteractiveAction,
 )
 from openhands.events.action.action import Action
 from openhands.events.action.files import FileEditSource
@@ -363,6 +364,9 @@ def browse(self, action: BrowseURLAction) -> Observation:
     def browse_interactive(self, action: BrowseInteractiveAction) -> Observation:
         return self.send_action_for_execution(action)
 
+    def os_interactive(self, action: OSInteractiveAction) -> Observation:
+        return self.send_action_for_execution(action)
+
     def get_mcp_config(
         self, extra_stdio_servers: list[MCPStdioServerConfig] | None = None
     ) -> MCPConfig:
diff --git a/openhands/runtime/impl/docker/docker_runtime.py b/openhands/runtime/impl/docker/docker_runtime.py
index 01e511a9a..3f31d853a 100644
--- a/openhands/runtime/impl/docker/docker_runtime.py
+++ b/openhands/runtime/impl/docker/docker_runtime.py
@@ -22,7 +22,7 @@
 )
 from openhands.runtime.impl.docker.containers import stop_all_containers
 from openhands.runtime.plugins import PluginRequirement
-from openhands.runtime.utils import find_available_tcp_port
+from openhands.runtime.utils import find_available_display_number, find_available_tcp_port
 from openhands.runtime.utils.command import (
     DEFAULT_MAIN_MODULE,
     get_action_execution_server_startup_command,
@@ -39,6 +39,7 @@
 VSCODE_PORT_RANGE = (40000, 49999)
 APP_PORT_RANGE_1 = (50000, 54999)
 APP_PORT_RANGE_2 = (55000, 59999)
+SCREEN_NUMBER_RANGE = (10, 999)
 
 
 def _is_retryablewait_until_alive_error(exception):
@@ -278,6 +279,7 @@ def init_container(self):
             self._find_available_port(APP_PORT_RANGE_1),
             self._find_available_port(APP_PORT_RANGE_2),
         ]
+        self._screen_number = find_available_display_number(SCREEN_NUMBER_RANGE[0], SCREEN_NUMBER_RANGE[1])
         self.api_url = f'{self.config.sandbox.local_runtime_url}:{self._container_port}'
 
         use_host_network = self.config.sandbox.use_host_network
@@ -324,6 +326,7 @@ def init_container(self):
             'VSCODE_PORT': str(self._vscode_port),
             'APP_PORT_1': self._app_ports[0],
             'APP_PORT_2': self._app_ports[1],
+            'SCREEN_NUMBER': str(self._screen_number),
             'PIP_BREAK_SYSTEM_PACKAGES': '1',
         }
         if self.config.debug or DEBUG:
diff --git a/openhands/runtime/impl/enroot/enroot_runtime.py b/openhands/runtime/impl/enroot/enroot_runtime.py
index 20b7b4960..9dbbcd472 100644
--- a/openhands/runtime/impl/enroot/enroot_runtime.py
+++ b/openhands/runtime/impl/enroot/enroot_runtime.py
@@ -23,7 +23,7 @@
     ActionExecutionClient,
 )
 from openhands.runtime.plugins import PluginRequirement
-from openhands.runtime.utils import find_available_tcp_port
+from openhands.runtime.utils import find_available_display_number, find_available_tcp_port
 from openhands.runtime.utils.command import (
     DEFAULT_MAIN_MODULE,
     get_action_execution_server_startup_command,
@@ -38,6 +38,7 @@
 VSCODE_PORT_RANGE = (40000, 49999)
 APP_PORT_RANGE_1 = (50000, 54999)
 APP_PORT_RANGE_2 = (55000, 59999)
+SCREEN_NUMBER_RANGE = (10, 999)
 
 
 def kill_process_tree(pid):
@@ -361,6 +362,7 @@ def init_container(self):
             self._find_available_port(APP_PORT_RANGE_1),
             self._find_available_port(APP_PORT_RANGE_2),
         ]
+        self._screen_number = find_available_display_number(SCREEN_NUMBER_RANGE[0], SCREEN_NUMBER_RANGE[1])
         self.api_url = f'{self.config.sandbox.local_runtime_url}:{self._container_port}'
 
         # Prepare environment variables
@@ -370,6 +372,7 @@ def init_container(self):
             'VSCODE_PORT': str(self._vscode_port),
             'APP_PORT_1': str(self._app_ports[0]),
             'APP_PORT_2': str(self._app_ports[1]),
+            'SCREEN_NUMBER': str(self._screen_number),
             'PIP_BREAK_SYSTEM_PACKAGES': '1',
         }
         if self.config.debug or DEBUG:
diff --git a/openhands/runtime/impl/singularity/singularity_runtime.py b/openhands/runtime/impl/singularity/singularity_runtime.py
index 9aa8cdc81..ef0577bcd 100644
--- a/openhands/runtime/impl/singularity/singularity_runtime.py
+++ b/openhands/runtime/impl/singularity/singularity_runtime.py
@@ -25,7 +25,7 @@
     ActionExecutionClient,
 )
 from openhands.runtime.plugins import PluginRequirement
-from openhands.runtime.utils import find_available_tcp_port
+from openhands.runtime.utils import find_available_display_number, find_available_tcp_port
 from openhands.runtime.utils.loopback_ip_allocator import (
     allocate_loopback_ip,
     release_loopback_ip,
@@ -51,6 +51,7 @@
 APP_PORT_RANGE_1 = (50000, 54999)
 APP_PORT_RANGE_2 = (55000, 59999)
 MCP_HTTP_PORT_RANGE = (60000, 64999)
+SCREEN_NUMBER_RANGE = (10, 999)
 
 
 def kill_process_tree(pid):
@@ -492,6 +493,7 @@ def init_container(self):
             self._find_available_port(APP_PORT_RANGE_2),
         ]
         self._mcp_http_port = self._find_available_port(MCP_HTTP_PORT_RANGE)
+        self._screen_number = find_available_display_number(SCREEN_NUMBER_RANGE[0], SCREEN_NUMBER_RANGE[1])
 
         # Prepare environment variables
         env_vars = {
@@ -502,6 +504,7 @@ def init_container(self):
             'APP_PORT_1': str(self._app_ports[0]),
             'APP_PORT_2': str(self._app_ports[1]),
             'MCP_HTTP_PORT': str(self._mcp_http_port),
+            'SCREEN_NUMBER': str(self._screen_number),
             'PIP_BREAK_SYSTEM_PACKAGES': '1',
             'OPENHANDS_SESSION_ID': self.sid,
             'OMP_NUM_THREADS': '4', # Limit threads at container startup
diff --git a/openhands/runtime/utils/__init__.py b/openhands/runtime/utils/__init__.py
index 622a0b609..f14fc1fc3 100644
--- a/openhands/runtime/utils/__init__.py
+++ b/openhands/runtime/utils/__init__.py
@@ -1,6 +1,7 @@
 from openhands.runtime.utils.system import (
     display_number_matrix,
+    find_available_display_number,
     find_available_tcp_port,
 )
 
-__all__ = ['display_number_matrix', 'find_available_tcp_port']
+__all__ = ['display_number_matrix', 'find_available_display_number', 'find_available_tcp_port']
diff --git a/openhands/runtime/utils/runtime_build.py b/openhands/runtime/utils/runtime_build.py
index ff85c7d68..63a74834c 100644
--- a/openhands/runtime/utils/runtime_build.py
+++ b/openhands/runtime/utils/runtime_build.py
@@ -373,7 +373,7 @@ def _build_sandbox_image(
 if __name__ == '__main__':
     parser = argparse.ArgumentParser()
     parser.add_argument(
-        '--base_image', type=str, default='nikolaik/python-nodejs:python3.12-nodejs22'
+        '--base_image', type=str, default='ubuntu:24.04'
     )
     parser.add_argument('--build_folder', type=str, default=None)
     parser.add_argument('--force_rebuild', action='store_true', default=False)
diff --git a/openhands/runtime/utils/runtime_templates/singularity.j2 b/openhands/runtime/utils/runtime_templates/singularity.j2
index 6c38988cd..140ec3985 100644
--- a/openhands/runtime/utils/runtime_templates/singularity.j2
+++ b/openhands/runtime/utils/runtime_templates/singularity.j2
@@ -46,14 +46,15 @@ From: {{ base_image }}
 
 {% macro setup_base_system() %}
     # Install base system dependencies
-    apt-get install -y --no-install-recommends \
+    apt-get install -y --no-install-recommends -o APT::Sandbox::User=root \
         wget curl ca-certificates sudo apt-utils git jq tmux build-essential ripgrep \
         {%- if 'ubuntu' in base_image and (base_image.endswith(':latest') or base_image.endswith(':24.04') or base_image.endswith('24.04.sif')) -%}
         libgl1 \
         {%- else %}
         libgl1-mesa-glx \
         {% endif -%}
-        libasound2-plugins libatomic1
+        libasound2-plugins libatomic1 \
+        xvfb xfce4 xfce4-goodies dbus-x11 x11-utils gnome-screenshot
 
     {% if 'ubuntu' in base_image %}
     # Install Node.js
@@ -67,7 +68,7 @@ From: {{ base_image }}
     # fi
 
     TZ=Etc/UTC DEBIAN_FRONTEND=noninteractive \
-        apt-get install -y --no-install-recommends nodejs
+        apt-get install -y --no-install-recommends -o APT::Sandbox::User=root nodejs
 
     corepack enable yarn
     {% endif -%}
@@ -170,6 +171,9 @@ From: {{ base_image }}
     /openhands/micromamba/bin/micromamba run -n openhands poetry config virtualenvs.path /openhands/poetry
     /openhands/micromamba/bin/micromamba run -n openhands poetry env use python3.12
 
+    # Regenerate lock file if pyproject.toml has changed
+    /openhands/micromamba/bin/micromamba run -n openhands poetry lock
+
     # Install project dependencies in smaller chunks
     /openhands/micromamba/bin/micromamba run -n openhands poetry install --only main --no-interaction --no-root
     /openhands/micromamba/bin/micromamba run -n openhands poetry install --only runtime --no-interaction --no-root
@@ -179,6 +183,9 @@ From: {{ base_image }}
     /openhands/micromamba/bin/micromamba run -n openhands poetry run pip install playwright
     /openhands/micromamba/bin/micromamba run -n openhands poetry run playwright install --with-deps chromium
 
+    # Install pyautogui and pillow for GUI automation
+    /openhands/micromamba/bin/micromamba run -n openhands poetry run pip install pyautogui pillow
+
     # Set environment variables and permissions
     /openhands/micromamba/bin/micromamba run -n openhands poetry run python -c "import sys; print('OH_INTERPRETER_PATH=' + sys.executable)" >> /etc/environment
     chmod -R g+rws /openhands/poetry
diff --git a/openhands/runtime/utils/system.py b/openhands/runtime/utils/system.py
index 61cc95b4d..49c46cca6 100644
--- a/openhands/runtime/utils/system.py
+++ b/openhands/runtime/utils/system.py
@@ -1,3 +1,4 @@
+import os
 import random
 import socket
 import time
@@ -38,6 +39,45 @@ def find_available_tcp_port(
     return -1
 
 
+def find_available_display_number(
+    min_display: int = 10, max_display: int = 999, max_attempts: int = 50
+) -> int:
+    """Find an available X display number.
+
+    This checks if an X server is running on a display by looking for the X11 socket file.
+
+    Args:
+        min_display (int): The lower bound of the display range (default: 10)
+        max_display (int): The upper bound of the display range (default: 999)
+        max_attempts (int): Maximum number of attempts to find an available display (default: 50)
+
+    Returns:
+        int: An available display number, or the first display in range if none found
+    """
+    rng = random.SystemRandom()
+    displays = list(range(min_display, max_display + 1))
+    rng.shuffle(displays)
+
+    # Check for available displays
+    for display_num in displays[:max_attempts]:
+        # Check if X11 socket exists for this display
+        socket_path = f'/tmp/.X11-unix/X{display_num}'
+        lock_path = f'/tmp/.X{display_num}-lock'
+
+        # Display is available if neither socket nor lock file exists
+        if not os.path.exists(socket_path) and not os.path.exists(lock_path):
+            logger.debug(f'Found available display number: {display_num}')
+            return display_num
+
+    # If we couldn't find an available display, return the first one in range
+    # Xvfb will handle the conflict if it exists
+    logger.warning(
+        f'Could not find definitively available display after {max_attempts} attempts, '
+        f'returning {min_display}'
+    )
+    return min_display
+
+
 def display_number_matrix(number: int) -> str | None:
     if not 0 <= number <= 999:
         return None
diff --git a/openhands/utils/prompt.py b/openhands/utils/prompt.py
index acd145381..8bda260e6 100644
--- a/openhands/utils/prompt.py
+++ b/openhands/utils/prompt.py
@@ -57,7 +57,7 @@ def __init__(
     ):
         self.prompt_dir: str = prompt_dir
         if system_prompt_template is None:
-            self.system_template: Template = self._load_template('system_prompt')
+            self.system_template = self._load_template('system_prompt')
         else:
             self.system_template = self._load_template(system_prompt_template)
         self.user_template: Template = self._load_template('user_prompt')
diff --git a/tests/nvidia/test_computer_use_tool.py b/tests/nvidia/test_computer_use_tool.py
new file mode 100644
index 000000000..db02f143e
--- /dev/null
+++ b/tests/nvidia/test_computer_use_tool.py
@@ -0,0 +1,429 @@
+#!/usr/bin/env python3
+import os
+import shutil
+import tempfile
+import time
+
+from openhands.core.config import OpenHandsConfig, SandboxConfig
+from openhands.events.action import OSInteractiveAction
+from openhands.events.observation import CmdOutputObservation
+from openhands.events.stream import EventStream
+from openhands.runtime.impl.singularity.singularity_runtime import SingularityRuntime
+from openhands.storage import get_file_store
+
+try:
+    from PIL import Image
+except Exception:
+    Image = None
+
+
+def demonstrate_computer_use_tool(
+    runtime: SingularityRuntime, tool_name: str, action_command: str, description: str
+):
+    """Demonstrate a single computer_use tool with detailed input/output."""
+    print(f'\n{"=" * 60}')
+    print(f'🧪 TESTING: {tool_name}')
+    print(f'📝 Description: {description}')
+    print(f'{"=" * 60}')
+
+    # Create action
+    action = OSInteractiveAction(
+        os_actions=action_command, thought=f'Testing {tool_name}: {description}'
+    )
+
+    # Show input
+    print('📥 INPUT:')
+    print('   Action Type: OSInteractiveAction')
+    print(f'   OS Actions: {action.os_actions}')
+    print(f'   Thought: {action.thought}')
+
+    # Execute action
+    print('\n⚡ EXECUTING...')
+    action.set_hard_timeout(30000)
+    obs = runtime.run_action(action)
+
+    # Show output
+    print('\n📤 OUTPUT:')
+    assert isinstance(obs, CmdOutputObservation)
+
+    print(f'   Success: {"✅ Yes" if obs.exit_code == 0 else "❌ No"}')
+    print(f'   Exit Code: {obs.exit_code}')
+    print(f'   Content:\n{obs.content}')
+    print(f'   Command: {obs.command}')
+
+    return obs
+
+
+def _cleanup_old_workspaces(prefix: str, keep_path: str | None) -> None:
+    """
+    Remove old temporary workspaces under /tmp matching the given prefix,
+    except for 'keep_path' if provided.
+    """
+    try:
+        tmp_dir = '/tmp'
+        for name in os.listdir(tmp_dir):
+            if not name.startswith(prefix):
+                continue
+            full = os.path.join(tmp_dir, name)
+            if keep_path and os.path.abspath(full) == os.path.abspath(keep_path):
+                continue
+            if os.path.isdir(full):
+                try:
+                    shutil.rmtree(full, ignore_errors=True)
+                except Exception:
+                    pass
+    except Exception:
+        pass
+
+
+def _save_screenshots_gif(
+    workspace_dir: str,
+    output_dir: str,
+    gif_name: str = 'computer_use_run.gif',
+    duration_ms: int = 1000,
+    image_prefix: str = 'computer_screenshot_',
+) -> str | None:
+    """Create a GIF from screenshots taken during computer_use tests."""
+    try:
+        screenshots_dir = os.path.join(workspace_dir, '.computer_screenshots')
+        if not os.path.isdir(screenshots_dir):
+            return None
+
+        # Filter files by prefix and image extensions
+        all_files = [
+            f
+            for f in os.listdir(screenshots_dir)
+            if f.lower().endswith(('.png', '.jpg', '.jpeg'))
+        ]
+        files = [f for f in all_files if f.startswith(image_prefix)]
+
+        if not files:
+            return None
+        files.sort()  # filenames contain timestamps; lexicographic order works
+
+        os.makedirs(output_dir, exist_ok=True)
+        output_path = os.path.join(output_dir, gif_name)
+
+        if Image is None:
+            # PIL not available; skip silently
+            return None
+
+        frames = []
+        for fname in files:
+            p = os.path.join(screenshots_dir, fname)
+            try:
+                img = Image.open(p).convert('RGB')
+                frames.append(img)
+            except Exception:
+                continue
+        if not frames:
+            return None
+
+        frames[0].save(
+            output_path,
+            save_all=True,
+            append_images=frames[1:],
+            duration=duration_ms,
+            loop=0,
+            optimize=True,
+            quality=85,
+            format='GIF',
+        )
+        return output_path
+    except Exception:
+        return None
+
+
+def main():
+    """Main demonstration function."""
+    print('🚀 Computer Use Tools Demonstration with Singularity Environment')
+    print('=' * 60)
+
+    # Setup workspace (clean up old runs first)
+    workspace_dir = tempfile.mkdtemp(prefix='computer_use_demo_')
+    singularity_image_path = '/root/singularity_images/oh_v0.40.0_ubuntu_t_24.04.sif'
+
+    print(f'📁 Workspace: {workspace_dir}')
+    print(f'🖼️ Singularity Image: {singularity_image_path}')
+
+    # Setup Singularity runtime
+    sandbox_config = SandboxConfig(
+        runtime_container_image=singularity_image_path,
+        browsergym_eval_env=None,
+        timeout=30,
+        use_host_network=True,
+    )
+    sandbox_config.volumes = '/work/Projects/ProRL-Agent-Server/:/openhands/code:ro'
+
+    config = OpenHandsConfig(
+        default_agent='CodeActAgent',
+        runtime='singularity',
+        sandbox=sandbox_config,
+        workspace_base=workspace_dir,
+        workspace_mount_path=workspace_dir,
+        run_as_openhands=False,  # This prevents the UID 0 conflict
+    )
+
+    # Setup event stream (required for SingularityRuntime)
+    file_store = get_file_store('local', workspace_dir)
+    event_stream = EventStream('computer_use_test_session', file_store)
+
+    runtime = SingularityRuntime(
+        config=config,
+        event_stream=event_stream,
+        sid='computer_use_test_session',
+        plugins=[],
+        headless_mode=True,
+    )
+
+    try:
+        print('\n🔌 Connecting to runtime...')
+        # Connect to the runtime (this starts the Singularity container and action server)
+        import asyncio
+
+        # Check if Singularity image exists
+        if not os.path.exists(singularity_image_path):
+            raise FileNotFoundError(
+                f'Singularity image not found: {singularity_image_path}'
+            )
+
+        asyncio.run(runtime.connect())
+        print('✅ Runtime connected successfully')
+        print('🖥️ Xvfb and xfce4 will be started on first computer_use action')
+
+        # Create screenshots directory
+        screenshots_dir = os.path.join(workspace_dir, '.computer_screenshots')
+        os.makedirs(screenshots_dir, exist_ok=True)
+
+        # Test 1: Get screen size
+        demonstrate_computer_use_tool(
+            runtime,
+            'size()',
+            'size()',
+            'Get the screen dimensions',
+        )
+
+        # Test 2: Get mouse position
+        demonstrate_computer_use_tool(
+            runtime,
+            'position()',
+            'position()',
+            'Get current mouse cursor position',
+        )
+
+        # Test 3: Move mouse to specific position
+        demonstrate_computer_use_tool(
+            runtime,
+            'moveTo(x, y)',
+            'moveTo(200, 200)',
+            'Move mouse cursor to absolute position (200, 200)',
+        )
+
+        # Test 4: Move mouse relative to current position
+        demonstrate_computer_use_tool(
+            runtime,
+            'move(xOffset, yOffset)',
+            'move(100, 50)',
+            'Move mouse cursor relative by (100, 50) pixels',
+        )
+
+        # Test 5: Click at current position
+        demonstrate_computer_use_tool(
+            runtime,
+            'click()',
+            'click()',
+            'Click left mouse button at current position',
+        )
+
+        # Test 6: Click at specific position
+        demonstrate_computer_use_tool(
+            runtime,
+            'click(x, y)',
+            'click(400, 300)',
+            'Click left mouse button at position (400, 300)',
+        )
+
+        # Test 7: Right click
+        demonstrate_computer_use_tool(
+            runtime,
+            'rightClick()',
+            'rightClick()',
+            'Right click at current position',
+        )
+
+        # Test 8: Double click
+        demonstrate_computer_use_tool(
+            runtime,
+            'doubleClick()',
+            'doubleClick(500, 400)',
+            'Double click at position (500, 400)',
+        )
+
+        # Test 9: Take a screenshot
+        screenshot_path = os.path.join(
+            screenshots_dir, f'computer_screenshot_{int(time.time())}_01.png'
+        )
+        demonstrate_computer_use_tool(
+            runtime,
+            'screenshot(path)',
+            f'screenshot("{screenshot_path}")',
+            'Capture a screenshot of the desktop',
+        )
+
+        # Test 10: Keyboard - type text
+        demonstrate_computer_use_tool(
+            runtime,
+            'typewrite(message)',
+            'typewrite("Hello from PyAutoGUI!")',
+            'Type text using keyboard',
+        )
+
+        # Test 11: Press Enter key
+        demonstrate_computer_use_tool(
+            runtime,
+            'press(key)',
+            'press("enter")',
+            'Press the Enter key',
+        )
+
+        # Test 12: Press multiple keys (hotkey)
+        demonstrate_computer_use_tool(
+            runtime,
+            'hotkey(*keys)',
+            'hotkey("ctrl", "a")',
+            'Press Ctrl+A hotkey combination',
+        )
+
+        # Test 13: Scroll up
+        demonstrate_computer_use_tool(
+            runtime,
+            'scroll(clicks)',
+            'scroll(5)',
+            'Scroll mouse wheel up (positive value)',
+        )
+
+        # Test 14: Scroll down
+        demonstrate_computer_use_tool(
+            runtime,
+            'scroll(clicks)',
+            'scroll(-3)',
+            'Scroll mouse wheel down (negative value)',
+        )
+
+        # Test 15: Complex multi-line action
+        screenshot_path_2 = os.path.join(
+            screenshots_dir, f'computer_screenshot_{int(time.time())}_02.png'
+        )
+        multi_action = f"""moveTo(100, 100)
+click()
+typewrite("Multi-line test")
+press("enter")
+screenshot("{screenshot_path_2}")"""
+
+        demonstrate_computer_use_tool(
+            runtime,
+            'Multi-Action Sequence',
+            multi_action,
+            'Execute multiple PyAutoGUI actions in sequence',
+        )
+
+        # Test 16: Test with wait/sleep
+        screenshot_path_3 = os.path.join(
+            screenshots_dir, f'computer_screenshot_{int(time.time())}_03.png'
+        )
+        timed_action = f"""moveTo(600, 400)
+sleep(0.5)
+click()
+sleep(0.3)
+screenshot("{screenshot_path_3}")"""
+
+        demonstrate_computer_use_tool(
+            runtime,
+            'Timed Actions',
+            timed_action,
+            'Execute actions with sleep delays between them',
+        )
+
+        # Test 17: Drag operation
+        demonstrate_computer_use_tool(
+            runtime,
+            'drag(x, y, duration)',
+            'drag(700, 500, duration=1.0)',
+            'Drag mouse from current position to (700, 500) over 1 second',
+        )
+
+        # Test 18: Key press and release
+        key_action = """keyDown("shift")
+typewrite("hello world")
+keyUp("shift")"""
+
+        demonstrate_computer_use_tool(
+            runtime,
+            'Key Down/Up',
+            key_action,
+            'Hold Shift key down, type, then release',
+        )
+
+        # Test 19: Final screenshot
+        screenshot_path_4 = os.path.join(
+            screenshots_dir, f'computer_screenshot_{int(time.time())}_04.png'
+        )
+        demonstrate_computer_use_tool(
+            runtime,
+            'screenshot(path)',
+            f'screenshot("{screenshot_path_4}")',
+            'Capture final screenshot',
+        )
+
+        print('\n🎉 Computer Use Tools Demonstration Completed!')
+        print(
+            '📊 Demonstrated 19 different computer_use operations with detailed input/output'
+        )
+        print(f'📁 Test files available in: {workspace_dir}')
+        print(f'📸 Screenshots saved in: {screenshots_dir}')
+
+        # Save run GIF into logs directory
+        logs_dir = '/lustre/fsw/portfolios/llmservice/users/shaokunz/project/OpenHands_internal/logs'
+
+        # Create GIF from screenshots
+        gif_path = _save_screenshots_gif(
+            workspace_dir,
+            logs_dir,
+            gif_name='computer_use_run.gif',
+            duration_ms=1000,
+            image_prefix='computer_screenshot_',
+        )
+        if gif_path:
+            print(f'🎞️ Saved Computer Use Screenshots GIF: {gif_path}')
+        else:
+            print('⚠️ No screenshots GIF saved (no screenshots or PIL not available)')
+
+        # List all screenshots created
+        if os.path.isdir(screenshots_dir):
+            screenshot_files = [
+                f
+                for f in os.listdir(screenshots_dir)
+                if f.startswith('computer_screenshot_')
+            ]
+            if screenshot_files:
+                print(f'\n📸 Screenshots created ({len(screenshot_files)}):')
+                for f in sorted(screenshot_files):
+                    full_path = os.path.join(screenshots_dir, f)
+                    size = os.path.getsize(full_path)
+                    print(f'   - {f} ({size:,} bytes)')
+
+    except Exception as e:
+        print(f'\n❌ Demonstration failed: {str(e)}')
+        import traceback
+
+        traceback.print_exc()
+
+    finally:
+        # Cleanup
+        print('\n🧹 Cleanup completed')
+        print(f'📁 Workspace directory: {workspace_dir}')
+        print('   (Not deleted for inspection - remove manually if needed)')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tests/runtime/conftest.py b/tests/runtime/conftest.py
index cacce2dda..51178d61e 100644
--- a/tests/runtime/conftest.py
+++ b/tests/runtime/conftest.py
@@ -208,7 +208,7 @@ def base_container_image(request):
                 request.param = None
         if request.param is None:
             request.param = pytest.param(
-                'nikolaik/python-nodejs:python3.12-nodejs22',
+                'ubuntu:24.04',
                 'golang:1.23-bookworm',
             )
     print(f'Container image: {request.param}')
diff --git a/tests/unit/test_config.py b/tests/unit/test_config.py
index c927e5fc6..9a15580e5 100644
--- a/tests/unit/test_config.py
+++ b/tests/unit/test_config.py
@@ -428,7 +428,7 @@ def test_defaults_dict_after_updates(default_config):
     assert defaults_after_updates['sandbox']['timeout']['default'] == 120
     assert (
         defaults_after_updates['sandbox']['base_container_image']['default']
-        == 'nikolaik/python-nodejs:python3.12-nodejs22'
+        == 'ubuntu:24.04'
     )
     assert defaults_after_updates == initial_defaults
 
diff --git a/tests/unit/test_runtime_build.py b/tests/unit/test_runtime_build.py
index ae04f499e..e8c850705 100644
--- a/tests/unit/test_runtime_build.py
+++ b/tests/unit/test_runtime_build.py
@@ -28,7 +28,7 @@
 )
 
 OH_VERSION = f'oh_v{oh_version}'
-DEFAULT_BASE_IMAGE = 'nikolaik/python-nodejs:python3.12-nodejs22'
+DEFAULT_BASE_IMAGE = 'ubuntu:24.04'
 
 
 @pytest.fixture
diff --git a/tests/unit/test_singularity_runtime_build.py b/tests/unit/test_singularity_runtime_build.py
index a0d66a7a0..997b5603f 100644
--- a/tests/unit/test_singularity_runtime_build.py
+++ b/tests/unit/test_singularity_runtime_build.py
@@ -171,7 +171,7 @@ def test_get_runtime_image_path_and_tag():
     assert img_dir == get_runtime_image_repo()
     assert img_tag == f'{OH_VERSION}_image_ubuntu_tag_22.04'
 
-    base_image = 'nikolaik/python-nodejs:python3.12-nodejs22'
+    base_image = 'ubuntu:24.04'
     img_dir, img_tag = get_runtime_image_path_and_tag(base_image)
     assert img_dir == get_runtime_image_repo()
     assert (