diff --git a/th_cli/commands/run_tests.py b/th_cli/commands/run_tests.py
index 1ba7405..6b7532a 100644
--- a/th_cli/commands/run_tests.py
+++ b/th_cli/commands/run_tests.py
@@ -97,6 +97,11 @@
     is_flag=True,
     help=colorize_help("Disable colored output for test execution status."),
 )
+@click.option(
+    "--no-streaming",
+    is_flag=True,
+    help=colorize_help("Disable real-time log streaming via web browser (enabled by default)."),
+)
 @async_cmd
 @click.pass_context
 async def run_tests(
@@ -107,6 +112,7 @@ async def run_tests(
     pics_config_folder: str | None = None,
     project_id: int | None = None,
     no_color: bool = False,
+    no_streaming: bool = False,
 ) -> None:
     """Execute a CLI test run from selected test cases.
 
@@ -147,8 +153,9 @@ async def run_tests(
         async_apis = AsyncApis(client)
         test_collections_api = async_apis.test_collections_api
 
-        # Configure new log output for test.
-        log_path = test_logging.configure_logger_for_run(title=title)
+        # Configure new log output for test with real-time streaming (enabled by default)
+        enable_streaming = not no_streaming
+        log_path = test_logging.configure_logger_for_run(title=title, enable_log_streaming=enable_streaming)
 
         # Retrieve CLI project
         cli_project = await _get_cli_project(async_apis, project_id)
@@ -195,6 +202,20 @@ async def run_tests(
 
         click.echo(colorize_key_value("Selected tests", json.dumps(selected_tests_dict, indent=JSON_INDENT)))
 
+        # Display log streaming URL if available
+        log_stream_url = test_logging.get_log_stream_url()
+        if log_stream_url:
+            border = click.style("═" * 60, fg="cyan", bold=True)
+            click.echo("")
+            click.echo(border)
+            click.echo(click.style("  📋 Real-Time Log Viewer Available", fg="cyan", bold=True))
+            click.echo(border)
+            click.echo(click.style("  View logs in real-time at:", fg="bright_white", bold=True))
+            click.echo("  " + click.style(f"{log_stream_url}", fg="cyan", bold=True, underline=True))
+            click.echo(click.style("  Logs will stream automatically as tests execute", fg="bright_white"))
+            click.echo(border)
+            click.echo("")
+
         new_test_run = await _create_new_test_run_cli(
             async_apis,
             selected_tests=selected_tests_dict,
@@ -220,6 +241,9 @@ async def run_tests(
     except Exception as e:
         raise CLIError(f"Unexpected error during test execution: {e}")
     finally:
+        # Stop log streaming
+        test_logging.stop_log_streaming()
+        
         if client:
             await client.aclose()
         if _webrtc_handler:
diff --git a/th_cli/test_run/log_stream_handler.py b/th_cli/test_run/log_stream_handler.py
new file mode 100644
index 0000000..0c56aca
--- /dev/null
+++ b/th_cli/test_run/log_stream_handler.py
@@ -0,0 +1,160 @@
+#
+# Copyright (c) 2026 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import datetime
+import queue
+import socket
+from typing import Optional
+
+from loguru import logger
+
+from .logs_http_server import LogsHTTPServer
+
+
+class LogStreamHandler:
+    """Main coordinator for real-time log streaming functionality."""
+
+    def __init__(self, port: int = 8998):
+        """Initialize the log stream handler.
+        
+        Args:
+            port: Port number for the HTTP server (default: 8998)
+        """
+        self.port = port
+        self.http_server = LogsHTTPServer(port=port)
+        self.log_queue: queue.Queue = queue.Queue(maxsize=1000)
+        self.is_running = False
+        self.log_file_path: Optional[str] = None
+        
+    def start(self, test_run_title: str = "Test Execution", log_file_path: Optional[str] = None) -> str:
+        """Start the log streaming HTTP server.
+        
+        Args:
+            test_run_title: Title of the test run for display
+            log_file_path: Path to the log file for download functionality
+            
+        Returns:
+            URL where logs can be viewed
+        """
+        if self.is_running:
+            logger.warning("Log stream handler already running")
+            return self._get_log_viewer_url()
+        
+        try:
+            # Store log file path for download functionality
+            self.log_file_path = log_file_path
+            
+            # Get local IP address
+            local_ip = self._get_local_ip()
+            
+            # Start HTTP server
+            self.http_server.start(
+                log_queue=self.log_queue,
+                test_run_title=test_run_title,
+                local_ip=local_ip,
+                log_file_path=log_file_path,
+            )
+            
+            self.is_running = True
+            
+            viewer_url = f"http://{local_ip}:{self.port}"
+            logger.info(f"Log stream viewer started: {viewer_url}")
+            
+            return viewer_url
+            
+        except Exception as e:
+            logger.error(f"Failed to start log stream handler: {e}")
+            raise
+    
+    def stop(self):
+        """Stop the log streaming HTTP server."""
+        if not self.is_running:
+            return
+        
+        try:
+            # Signal end of stream
+            if not self.log_queue.full():
+                try:
+                    self.log_queue.put_nowait(None)
+                except queue.Full:
+                    pass
+            
+            # Stop HTTP server
+            self.http_server.stop()
+            
+            self.is_running = False
+            logger.info("Log stream handler stopped")
+            
+        except Exception as e:
+            logger.error(f"Error stopping log stream handler: {e}")
+    
+    def add_log_entry(
+        self,
+        message: str,
+        level: str = "INFO",
+        timestamp: Optional[str] = None
+    ):
+        """Add a log entry to the stream.
+        
+        Args:
+            message: Log message text
+            level: Log level (INFO, WARNING, ERROR, DEBUG, etc.)
+            timestamp: ISO format timestamp (auto-generated if not provided)
+        """
+        if not self.is_running:
+            return
+        
+        if timestamp is None:
+            timestamp = datetime.datetime.now().isoformat()
+        
+        log_entry = {
+            "message": message,
+            "level": level.upper(),
+            "timestamp": timestamp,
+        }
+        
+        try:
+            # Try to add to queue without blocking
+            self.log_queue.put_nowait(log_entry)
+        except queue.Full:
+            # Queue is full, skip this entry silently to avoid blocking
+            # This is acceptable for real-time streaming when no browser is connected
+            pass
+    
+    def _get_local_ip(self) -> str:
+        """Get the local IP address of the machine.
+        
+        Returns:
+            Local IP address as string, or 'localhost' if unable to determine
+        """
+        try:
+            # Create a socket connection to determine local IP
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            # Connect to an external host (doesn't actually send data)
+            s.connect(("8.8.8.8", 80))
+            local_ip = s.getsockname()[0]
+            s.close()
+            return local_ip
+        except Exception:
+            return "localhost"
+    
+    def _get_log_viewer_url(self) -> str:
+        """Get the URL for the log viewer.
+        
+        Returns:
+            Log viewer URL
+        """
+        local_ip = self._get_local_ip()
+        return f"http://{local_ip}:{self.port}"
diff --git a/th_cli/test_run/log_viewer.html b/th_cli/test_run/log_viewer.html
new file mode 100644
index 0000000..4e38ca6
--- /dev/null
+++ b/th_cli/test_run/log_viewer.html
@@ -0,0 +1,827 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Real-Time Log Viewer</title>
+    <style>
+        body {{
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: #f5f5f5;
+            margin: 0;
+            padding: 0;
+            display: flex;
+            flex-direction: column;
+            min-height: 100vh;
+        }}
+
+        .matter-header {{
+            background: white;
+            border-bottom: 1px solid #e0e0e0;
+            padding: 12px 20px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }}
+
+        .header-start {{
+            display: flex;
+            align-items: center;
+            gap: 15px;
+        }}
+
+        .header-title {{
+            font-size: 18px;
+            font-weight: 600;
+            color: #333;
+            margin: 0;
+        }}
+
+        .header-end {{
+            display: flex;
+            align-items: center;
+            gap: 15px;
+        }}
+
+        .cli-indicator {{
+            background: #2196F3;
+            color: white;
+            padding: 4px 8px;
+            border-radius: 12px;
+            font-size: 11px;
+            font-weight: 500;
+        }}
+
+        .version-info {{
+            font-size: 12px;
+            color: #666;
+            text-align: right;
+        }}
+
+        .status-indicator {{
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            padding: 4px 10px;
+            border-radius: 12px;
+            font-size: 11px;
+            font-weight: 500;
+        }}
+
+        .status-indicator.connected {{
+            background: #e8f5e9;
+            color: #2e7d32;
+            border: 1px solid #4caf50;
+        }}
+
+        .status-indicator.disconnected {{
+            background: #ffebee;
+            color: #c62828;
+            border: 1px solid #f44336;
+        }}
+
+        .status-dot {{
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            animation: pulse 2s infinite;
+        }}
+
+        .status-indicator.connected .status-dot {{
+            background: #4caf50;
+        }}
+
+        .status-indicator.disconnected .status-dot {{
+            background: #f44336;
+        }}
+
+        @keyframes pulse {{
+            0%, 100% {{ opacity: 1; }}
+            50% {{ opacity: 0.5; }}
+        }}
+
+        .main-content {{
+            flex: 1;
+            padding: 20px;
+            display: flex;
+            justify-content: center;
+            align-items: flex-start;
+            overflow: hidden;
+        }}
+
+        .p-dialog {{
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 4px 20px rgba(0,0,0,0.15);
+            width: 95%;
+            max-width: 1400px;
+            margin: 20px;
+            display: flex;
+            flex-direction: column;
+            max-height: calc(100vh - 120px);
+        }}
+
+        .p-dialog-header {{
+            padding: 16px 20px;
+            border-bottom: 1px solid #e0e0e0;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            background: #fafafa;
+            border-radius: 8px 8px 0 0;
+            flex-shrink: 0;
+        }}
+
+        .p-dialog-title {{
+            font-size: 18px;
+            font-weight: 600;
+            color: #333;
+        }}
+
+        .p-dialog-content {{
+            padding: 20px;
+            flex: 1;
+            overflow: hidden;
+            display: flex;
+            flex-direction: column;
+        }}
+
+        .subheader {{
+            font-size: 16px;
+            color: #555;
+            margin-bottom: 15px;
+            font-weight: 500;
+        }}
+
+        .controls {{
+            background: #fafafa;
+            border: 1px solid #e0e0e0;
+            border-radius: 4px;
+            padding: 12px;
+            margin-bottom: 15px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            flex-wrap: wrap;
+            gap: 10px;
+            flex-shrink: 0;
+        }}
+
+        .control-group {{
+            display: flex;
+            gap: 10px;
+            align-items: center;
+            flex-wrap: wrap;
+        }}
+
+        .btn {{
+            background: white;
+            color: #333;
+            border: 1px solid #ccc;
+            padding: 6px 14px;
+            border-radius: 4px;
+            font-size: 13px;
+            cursor: pointer;
+            transition: all 0.2s;
+            font-weight: 500;
+        }}
+
+        .btn:hover {{
+            background: #f0f0f0;
+            border-color: #999;
+        }}
+
+        .btn.active {{
+            background: #2196F3;
+            border-color: #2196F3;
+            color: white;
+        }}
+
+        .btn.download {{
+            background: #4caf50;
+            border-color: #4caf50;
+            color: white;
+        }}
+
+        .btn.download:hover {{
+            background: #45a049;
+        }}
+
+        .log-count {{
+            font-size: 12px;
+            color: #666;
+            padding: 0 10px;
+        }}
+
+        .filter-group {{
+            display: flex;
+            gap: 6px;
+            flex-wrap: wrap;
+        }}
+
+        .filter-btn {{
+            padding: 4px 10px;
+            font-size: 11px;
+            border-radius: 4px;
+            border: 1px solid #ddd;
+            cursor: pointer;
+            transition: all 0.2s;
+            font-weight: 500;
+        }}
+
+        .filter-btn.level-info {{
+            background: #e3f2fd;
+            color: #1976d2;
+            border-color: #90caf9;
+        }}
+
+        .filter-btn.level-warning {{
+            background: #fff3e0;
+            color: #f57c00;
+            border-color: #ffb74d;
+        }}
+
+        .filter-btn.level-error {{
+            background: #ffebee;
+            color: #c62828;
+            border-color: #ef5350;
+        }}
+
+        .filter-btn.level-debug {{
+            background: #fafafa;
+            color: #757575;
+            border-color: #e0e0e0;
+        }}
+
+        .filter-btn.level-chiptool {{
+            background: #e0f2f1;
+            color: #00796b;
+            border-color: #4db6ac;
+        }}
+
+        .filter-btn.level-python {{
+            background: #f3e5f5;
+            color: #6a1b9a;
+            border-color: #ba68c8;
+        }}
+
+        .filter-btn.active {{
+            opacity: 1;
+            font-weight: 600;
+            border-width: 2px;
+        }}
+
+        .filter-btn:not(.active) {{
+            opacity: 0.4;
+        }}
+
+        .filter-btn:hover {{
+            opacity: 1;
+        }}
+
+        .log-container {{
+            flex: 1;
+            overflow-y: auto;
+            font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
+            font-size: 13px;
+            line-height: 1.5;
+            background: #fafafa;
+            border: 1px solid #e0e0e0;
+            border-radius: 4px;
+            padding: 10px;
+        }}
+
+        .log-entry {{
+            padding: 4px 8px;
+            margin: 2px 0;
+            border-left: 3px solid transparent;
+            word-wrap: break-word;
+            white-space: pre-wrap;
+            transition: background 0.1s;
+            background: white;
+            border-radius: 2px;
+        }}
+
+        .log-entry:hover {{
+            background: #f5f5f5;
+        }}
+
+        .log-entry.level-info {{
+            border-left-color: #2196F3;
+        }}
+
+        .log-entry.level-warning {{
+            border-left-color: #ff9800;
+            background: #fff8e1;
+        }}
+
+        .log-entry.level-error {{
+            border-left-color: #f44336;
+            background: #ffebee;
+        }}
+
+        .log-entry.level-debug {{
+            border-left-color: #9e9e9e;
+            background: #fafafa;
+        }}
+
+        .log-entry.level-success {{
+            border-left-color: #4caf50;
+            background: #e8f5e9;
+        }}
+
+        .log-entry.level-chiptool {{
+            border-left-color: #009688;
+            background: #e0f2f1;
+        }}
+
+        .log-entry.level-python_test {{
+            border-left-color: #9c27b0;
+            background: #f3e5f5;
+        }}
+
+        .log-timestamp {{
+            color: #666;
+            font-weight: 500;
+            margin-right: 10px;
+        }}
+
+        .log-level {{
+            font-weight: 700;
+            margin-right: 10px;
+            padding: 2px 6px;
+            border-radius: 3px;
+            font-size: 10px;
+            display: inline-block;
+            min-width: 50px;
+            text-align: center;
+        }}
+
+        .log-level.INFO {{
+            background: #2196F3;
+            color: white;
+        }}
+
+        .log-level.WARNING {{
+            background: #ff9800;
+            color: white;
+        }}
+
+        .log-level.ERROR {{
+            background: #f44336;
+            color: white;
+        }}
+
+        .log-level.DEBUG {{
+            background: #9e9e9e;
+            color: white;
+        }}
+
+        .log-level.SUCCESS {{
+            background: #4caf50;
+            color: white;
+        }}
+
+        .log-level.CHIPTOOL {{
+            background: #009688;
+            color: white;
+        }}
+
+        .log-level.PYTHON_TEST {{
+            background: #9c27b0;
+            color: white;
+        }}
+
+        .log-message {{
+            color: #333;
+        }}
+
+        .empty-state {{
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            height: 100%;
+            color: #999;
+            font-size: 14px;
+        }}
+
+        .empty-state-icon {{
+            font-size: 48px;
+            margin-bottom: 16px;
+            opacity: 0.5;
+        }}
+
+        .log-container::-webkit-scrollbar {{
+            width: 10px;
+        }}
+
+        .log-container::-webkit-scrollbar-track {{
+            background: #f1f1f1;
+        }}
+
+        .log-container::-webkit-scrollbar-thumb {{
+            background: #ccc;
+            border-radius: 5px;
+        }}
+
+        .log-container::-webkit-scrollbar-thumb:hover {{
+            background: #999;
+        }}
+
+        .search-box {{
+            padding: 6px 10px;
+            background: white;
+            border: 1px solid #ccc;
+            border-radius: 4px;
+            color: #333;
+            font-size: 13px;
+            font-family: inherit;
+            width: 200px;
+        }}
+
+        .search-box:focus {{
+            outline: none;
+            border-color: #2196F3;
+        }}
+
+        .highlight {{
+            background: #ffeb3b;
+            color: #000;
+            padding: 0 2px;
+            border-radius: 2px;
+        }}
+
+        .status-info {{
+            background: #e8f5e9;
+            border: 1px solid #4caf50;
+            padding: 10px;
+            border-radius: 4px;
+            margin-bottom: 15px;
+            font-size: 13px;
+            color: #2e7d32;
+        }}
+    </style>
+</head>
+<body>
+    <div class="matter-header">
+        <div class="header-start">
+            <div class="header-title">Matter Certification Tool</div>
+        </div>
+        <div class="header-end">
+            <div id="statusIndicator" class="status-indicator disconnected">
+                <span class="status-dot"></span>
+                <span id="statusText">Connecting...</span>
+            </div>
+            <div class="cli-indicator">CLI</div>
+            <div class="version-info">
+                <div>Log Viewer</div>
+                <div style="font-size: 10px; color: #999;">Real-Time Stream</div>
+            </div>
+        </div>
+    </div>
+
+    <div class="main-content">
+        <div class="p-dialog" role="dialog">
+            <div class="p-dialog-header">
+                <span class="p-dialog-title">📋 Real-Time Log Viewer - {test_run_title}</span>
+            </div>
+
+            <div class="p-dialog-content">
+                <div class="status-info">
+                    &#128268; Live logs streaming in real-time from test execution
+                </div>
+
+                <div class="controls">
+                    <div class="control-group">
+                        <button id="clearBtn" class="btn" onclick="clearLogs()">Clear</button>
+                        <button id="autoScrollBtn" class="btn active" onclick="toggleAutoScroll()">Auto-scroll</button>
+                        <button id="downloadBtn" class="btn download" onclick="downloadLogs()">Download Logs</button>
+                        <input type="text" id="searchBox" class="search-box" placeholder="Search logs..." oninput="filterLogs()">
+                        <span class="log-count">Logs: <span id="logCount">0</span></span>
+                    </div>
+                    <div class="filter-group">
+                        <button class="filter-btn level-info active" onclick="toggleFilter('INFO')">INFO</button>
+                        <button class="filter-btn level-warning active" onclick="toggleFilter('WARNING')">WARN</button>
+                        <button class="filter-btn level-error active" onclick="toggleFilter('ERROR')">ERROR</button>
+                        <button class="filter-btn level-debug" onclick="toggleFilter('DEBUG')">DEBUG</button>
+                        <button class="filter-btn level-chiptool active" onclick="toggleFilter('CHIPTOOL')">CHIP</button>
+                        <button class="filter-btn level-python active" onclick="toggleFilter('PYTHON_TEST')">PYTHON</button>
+                    </div>
+                </div>
+
+                <div class="log-container" id="logContainer">
+                    <div class="empty-state">
+                        <div class="empty-state-icon">📡</div>
+                        <div>Waiting for logs...</div>
+                        <div style="font-size: 12px; margin-top: 8px; color: #bbb;">Logs will appear here in real-time as tests execute</div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let eventSource = null;
+        let autoScroll = true;
+        let logCount = 0;
+        let activeFilters = new Set(['INFO', 'WARNING', 'ERROR', 'CHIPTOOL', 'PYTHON_TEST', 'SUCCESS']);
+        let allLogs = [];
+        let logBatchQueue = [];
+        let batchProcessing = false;
+        let lastBatchTime = 0;
+        const BATCH_INTERVAL_MS = 50;
+        const MAX_BATCH_SIZE = 50;
+
+        function connectToLogStream() {{
+            const statusIndicator = document.getElementById('statusIndicator');
+            const statusText = document.getElementById('statusText');
+            
+            eventSource = new EventSource('/api/logs/stream');
+            
+            eventSource.addEventListener('connected', function(e) {{
+                console.log('Connected to log stream');
+                statusIndicator.className = 'status-indicator connected';
+                statusText.textContent = 'Connected';
+            }});
+            
+            eventSource.addEventListener('log', function(e) {{
+                const logEntry = JSON.parse(e.data);
+                logBatchQueue.push(logEntry);
+                scheduleBatchProcessing();
+            }});
+            
+            eventSource.addEventListener('keepalive', function(e) {{
+                // Silent keepalive
+            }});
+            
+            eventSource.addEventListener('end', function(e) {{
+                console.log('Log stream ended');
+                statusIndicator.className = 'status-indicator disconnected';
+                statusText.textContent = 'Stream Ended';
+                eventSource.close();
+                processBatchImmediately();
+            }});
+            
+            eventSource.onerror = function(e) {{
+                console.error('EventSource error:', e);
+                statusIndicator.className = 'status-indicator disconnected';
+                statusText.textContent = 'Disconnected';
+                
+                processBatchImmediately();
+                
+                setTimeout(() => {{
+                    if (eventSource.readyState === EventSource.CLOSED) {{
+                        console.log('Attempting to reconnect...');
+                        statusText.textContent = 'Reconnecting...';
+                        connectToLogStream();
+                    }}
+                }}, 3000);
+            }};
+        }}
+
+        function scheduleBatchProcessing() {{
+            if (batchProcessing) return;
+            
+            const now = Date.now();
+            const timeSinceLastBatch = now - lastBatchTime;
+            
+            if (timeSinceLastBatch >= BATCH_INTERVAL_MS || logBatchQueue.length >= MAX_BATCH_SIZE) {{
+                processBatch();
+            }} else {{
+                batchProcessing = true;
+                setTimeout(processBatch, BATCH_INTERVAL_MS - timeSinceLastBatch);
+            }}
+        }}
+
+        function processBatchImmediately() {{
+            if (logBatchQueue.length > 0) {{
+                processBatch();
+            }}
+        }}
+
+        function processBatch() {{
+            if (logBatchQueue.length === 0) {{
+                batchProcessing = false;
+                return;
+            }}
+            
+            const container = document.getElementById('logContainer');
+            const emptyState = container.querySelector('.empty-state');
+            
+            if (emptyState) {{
+                container.innerHTML = '';
+            }}
+            
+            const fragment = document.createDocumentFragment();
+            const batchSize = Math.min(logBatchQueue.length, MAX_BATCH_SIZE);
+            const batch = logBatchQueue.splice(0, batchSize);
+            
+            batch.forEach(entry => {{
+                allLogs.push(entry);
+                logCount++;
+                
+                const logDiv = createLogElement(entry);
+                fragment.appendChild(logDiv);
+            }});
+            
+            container.appendChild(fragment);
+            
+            document.getElementById('logCount').textContent = logCount;
+            
+            if (autoScroll) {{
+                container.scrollTop = container.scrollHeight;
+            }}
+            
+            lastBatchTime = Date.now();
+            batchProcessing = false;
+            
+            if (logBatchQueue.length > 0) {{
+                scheduleBatchProcessing();
+            }}
+        }}
+
+        function createLogElement(entry) {{
+            const logDiv = document.createElement('div');
+            const level = entry.level || 'INFO';
+            logDiv.className = `log-entry level-${{level.toLowerCase()}}`;
+            logDiv.dataset.level = level;
+            logDiv.dataset.message = entry.message || '';
+            
+            const timestamp = entry.timestamp || new Date().toISOString();
+            const timeStr = new Date(timestamp).toLocaleTimeString('en-US', {{ hour12: false }});
+            
+            logDiv.innerHTML = `<span class="log-timestamp">${{timeStr}}</span><span class="log-level ${{level}}">${{level}}</span><span class="log-message">${{escapeHtml(entry.message || '')}}</span>`;
+            
+            if (!activeFilters.has(level)) {{
+                logDiv.style.display = 'none';
+            }}
+            
+            return logDiv;
+        }}
+
+        function addLogEntry(entry) {{
+            logBatchQueue.push(entry);
+            scheduleBatchProcessing();
+        }}
+
+        function clearLogs() {{
+            const container = document.getElementById('logContainer');
+            container.innerHTML = `
+                <div class="empty-state">
+                    <div class="empty-state-icon">📋</div>
+                    <div>Logs cleared</div>
+                </div>
+            `;
+            allLogs = [];
+            logCount = 0;
+            document.getElementById('logCount').textContent = '0';
+        }}
+
+        function toggleAutoScroll() {{
+            autoScroll = !autoScroll;
+            const btn = document.getElementById('autoScrollBtn');
+            btn.classList.toggle('active', autoScroll);
+            
+            if (autoScroll) {{
+                const container = document.getElementById('logContainer');
+                container.scrollTop = container.scrollHeight;
+            }}
+        }}
+
+        function toggleFilter(level) {{
+            if (activeFilters.has(level)) {{
+                activeFilters.delete(level);
+            }} else {{
+                activeFilters.add(level);
+            }}
+            
+            const btn = event.target;
+            btn.classList.toggle('active');
+            
+            filterLogs();
+        }}
+
+        function filterLogs() {{
+            const searchText = document.getElementById('searchBox').value.toLowerCase();
+            const logEntries = document.querySelectorAll('.log-entry');
+            
+            logEntries.forEach(entry => {{
+                const level = entry.dataset.level;
+                const message = entry.dataset.message.toLowerCase();
+                
+                const levelMatch = activeFilters.has(level);
+                const searchMatch = !searchText || message.includes(searchText);
+                
+                entry.style.display = (levelMatch && searchMatch) ? 'block' : 'none';
+                
+                if (searchText && searchMatch) {{
+                    const messageEl = entry.querySelector('.log-message');
+                    const originalText = entry.dataset.message;
+                    const regex = new RegExp(`(${{escapeRegex(searchText)}})`, 'gi');
+                    messageEl.innerHTML = escapeHtml(originalText).replace(regex, '<span class="highlight">$1</span>');
+                }} else {{
+                    const messageEl = entry.querySelector('.log-message');
+                    messageEl.textContent = entry.dataset.message;
+                }}
+            }});
+        }}
+
+        function downloadLogs() {{
+            // First try server download (if server is still running)
+            fetch('/download_logs')
+                .then(response => {{
+                    if (response.ok) {{
+                        return response.blob();
+                    }}
+                    throw new Error('Server not available');
+                }})
+                .then(blob => {{
+                    // Server download successful
+                    const url = window.URL.createObjectURL(blob);
+                    const a = document.createElement('a');
+                    a.href = url;
+                    a.download = 'test_run_logs.log';
+                    document.body.appendChild(a);
+                    a.click();
+                    window.URL.revokeObjectURL(url);
+                    document.body.removeChild(a);
+                }})
+                .catch(error => {{
+                    // Server not available, use client-side download
+                    console.log('Server unavailable, using client-side download');
+                    downloadLogsClientSide();
+                }});
+        }}
+
+        function downloadLogsClientSide() {{
+            // Build log content from stored logs
+            let logContent = '';
+            allLogs.forEach(entry => {{
+                const timestamp = entry.timestamp || new Date().toISOString();
+                const level = entry.level || 'INFO';
+                const message = entry.message || '';
+                // Replace literal \n strings with actual newlines, then add entry
+                const cleanMessage = message.replace(/\\n/g, '\n');
+                logContent += `${{timestamp}} [${{level}}] ${{cleanMessage}}\n`;
+            }});
+
+            if (logContent === '') {{
+                alert('No logs to download');
+                return;
+            }}
+
+            // Create blob and download
+            const blob = new Blob([logContent], {{ type: 'text/plain;charset=utf-8' }});
+            const url = window.URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            
+            // Generate filename with current timestamp
+            const now = new Date();
+            const dateStr = now.toISOString().slice(0,19).replace(/[T:]/g, '-');
+            a.download = `test_run_logs_${{dateStr}}.log`;
+            
+            document.body.appendChild(a);
+            a.click();
+            window.URL.revokeObjectURL(url);
+            document.body.removeChild(a);
+            
+            console.log(`Downloaded ${{allLogs.length}} log entries client-side`);
+        }}
+
+        function escapeHtml(text) {{
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML;
+        }}
+
+        function escapeRegex(text) {{
+            return text.replace(/[.*+?^${{}}()|[\\]\\\\]/g, '\\\\$&');
+        }}
+
+        document.getElementById('logContainer').addEventListener('scroll', function() {{
+            const container = this;
+            const isNearBottom = container.scrollHeight - container.scrollTop - container.clientHeight < 100;
+            
+            if (!isNearBottom && autoScroll) {{
+                autoScroll = false;
+                document.getElementById('autoScrollBtn').classList.remove('active');
+            }} else if (isNearBottom && !autoScroll) {{
+                autoScroll = true;
+                document.getElementById('autoScrollBtn').classList.add('active');
+            }}
+        }});
+
+        window.addEventListener('load', function() {{
+            connectToLogStream();
+        }});
+
+        window.addEventListener('beforeunload', function() {{
+            if (eventSource) {{
+                eventSource.close();
+            }}
+        }});
+    </script>
+</body>
+</html>
diff --git a/th_cli/test_run/logging.py b/th_cli/test_run/logging.py
index 0ad6e64..46ae036 100644
--- a/th_cli/test_run/logging.py
+++ b/th_cli/test_run/logging.py
@@ -14,6 +14,7 @@
 # limitations under the License.
 #
 import os
+from typing import Optional
 
 from loguru import logger
 
@@ -27,13 +28,82 @@
 PYTHON_TEST_LEVEL = "PYTHON_TEST"
 logger.level(PYTHON_TEST_LEVEL, no=22, icon="🐍", color="<cyan>")
 
+# Global reference to log stream handler (if enabled)
+_log_stream_handler: Optional["LogStreamHandler"] = None
 
-def configure_logger_for_run(title: str) -> str:
+
+def configure_logger_for_run(title: str, enable_log_streaming: bool = False) -> str:
+    """Configure logger for a test run.
+    
+    Args:
+        title: Title of the test run
+        enable_log_streaming: Whether to enable real-time log streaming
+        
+    Returns:
+        Path to the log file
+    """
+    global _log_stream_handler
+    
     # Reset (Remove all sinks from logger)
     logger.remove()
 
     log_path = os.path.join(config.log_config.output_log_path, f"test_run_{title}.log")
 
     logger.add(log_path, enqueue=True, format=config.log_config.format)
+    
+    # Add streaming sink if enabled
+    if enable_log_streaming:
+        try:
+            from th_cli.test_run.log_stream_handler import LogStreamHandler
+            
+            _log_stream_handler = LogStreamHandler(port=8998)
+            viewer_url = _log_stream_handler.start(test_run_title=title, log_file_path=log_path)
+            
+            # Add custom sink that forwards logs to the stream handler
+            def stream_sink(message):
+                """Custom sink that forwards logs to the HTTP stream."""
+                try:
+                    record = message.record
+                    _log_stream_handler.add_log_entry(
+                        message=record["message"],
+                        level=record["level"].name,
+                        timestamp=record["time"].isoformat()
+                    )
+                except Exception:
+                    # Silently fail to avoid disrupting logging
+                    pass
+            
+            # Add sink with enqueue=True to prevent re-entrancy and catch=True to suppress errors
+            logger.add(stream_sink, format="{message}", catch=True)
+            logger.info(f"Real-time log streaming enabled: {viewer_url}")
+            
+        except Exception as e:
+            logger.warning(f"Failed to enable log streaming: {e}")
+            _log_stream_handler = None
 
     return log_path
+
+
+def stop_log_streaming():
+    """Stop the log streaming server if it's running."""
+    global _log_stream_handler
+    
+    if _log_stream_handler:
+        try:
+            _log_stream_handler.stop()
+            logger.info("Log streaming stopped")
+        except Exception as e:
+            logger.warning(f"Error stopping log streaming: {e}")
+        finally:
+            _log_stream_handler = None
+
+
+def get_log_stream_url() -> Optional[str]:
+    """Get the URL for the log viewer if streaming is enabled.
+    
+    Returns:
+        URL string or None if streaming is not enabled
+    """
+    if _log_stream_handler and _log_stream_handler.is_running:
+        return _log_stream_handler._get_log_viewer_url()
+    return None
diff --git a/th_cli/test_run/logs_http_server.py b/th_cli/test_run/logs_http_server.py
new file mode 100644
index 0000000..3a14027
--- /dev/null
+++ b/th_cli/test_run/logs_http_server.py
@@ -0,0 +1,282 @@
+#
+# Copyright (c) 2026 Project CHIP Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import html
+import json
+import queue
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Optional
+
+from loguru import logger
+
+# HTTP Endpoints
+ENDPOINT_ROOT = "/"
+ENDPOINT_LOGS_STREAM = "/api/logs/stream"
+ENDPOINT_DOWNLOAD_LOGS = "/download_logs"
+
+
+class LogStreamingHandler(BaseHTTPRequestHandler):
+    """HTTP handler for streaming log data in real-time."""
+
+    def do_GET(self):
+        """Handle GET requests for log streaming."""
+        if self.path == ENDPOINT_ROOT:
+            self.serve_log_viewer()
+        elif self.path == ENDPOINT_LOGS_STREAM:
+            self.stream_logs()
+        elif self.path == ENDPOINT_DOWNLOAD_LOGS:
+            self.download_logs()
+        else:
+            logger.warning(f"404 for GET {self.path}")
+            self.send_error(404)
+    
+    def download_logs(self):
+        """Serve the log file for download using chunked streaming."""
+        log_file_path = getattr(self.server, "log_file_path", None)
+        
+        if not log_file_path or not Path(log_file_path).exists():
+            self.send_error(404, "Log file not found")
+            return
+        
+        try:
+            file_path = Path(log_file_path)
+            filename = file_path.name
+            file_size = file_path.stat().st_size
+            
+            # Send headers
+            self.send_response(200)
+            self.send_header("Content-Type", "text/plain; charset=utf-8")
+            self.send_header("Content-Disposition", f'attachment; filename="{filename}"')
+            self.send_header("Content-Length", str(file_size))
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.end_headers()
+            
+            # Stream file in chunks to avoid loading entire file into memory
+            CHUNK_SIZE = 65536  # 64KB chunks
+            bytes_sent = 0
+
+            with open(log_file_path, 'rb') as f:
+                while chunk := f.read(CHUNK_SIZE):
+                    self.wfile.write(chunk)
+                    bytes_sent += len(chunk)
+
+            logger.info(f"Log file downloaded: {filename} ({bytes_sent} bytes)")
+            
+        except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):
+            # Client disconnected during download - normal, not an error
+            logger.debug("Client disconnected during log file download")
+        except Exception as e:
+            logger.error(f"Error serving log file: {e}")
+            # Note: Can't send error response because headers were already sent
+
+    def stream_logs(self):
+        """Stream logs using Server-Sent Events (SSE)."""
+        logger.info("Client connected for log stream")
+        
+        # Send SSE headers
+        self.send_response(200)
+        self.send_header("Content-Type", "text/event-stream")
+        self.send_header("Cache-Control", "no-cache")
+        self.send_header("Connection", "keep-alive")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.end_headers()
+
+        # Get the log queue from the server
+        log_queue = getattr(self.server, "log_queue", None)
+        if not log_queue:
+            logger.error("No log queue found on server for streaming")
+            return
+
+        logger.info("Starting to stream logs to client via SSE")
+        sent_count = 0
+        client_disconnected = False
+        
+        try:
+            # Send initial connection message
+            if not self._send_sse_event("connected", {"message": "Log stream connected"}):
+                logger.debug("Client disconnected during initial connection")
+                return
+            
+            while not client_disconnected:
+                try:
+                    # Get log entry from queue with timeout
+                    log_entry = log_queue.get(timeout=1.0)
+                    
+                    if log_entry is None:  # Signal to stop
+                        logger.info("Received end-of-stream signal for logs")
+                        self._send_sse_event("end", {"message": "Log stream ended"})
+                        break
+
+                    # Send log entry as SSE event
+                    if not self._send_sse_event("log", log_entry):
+                        logger.debug("Client disconnected while streaming")
+                        client_disconnected = True
+                        break
+                        
+                    sent_count += 1
+                    
+                    if sent_count % 100 == 0:
+                        logger.debug(f"Sent {sent_count} log entries to client")
+
+                except queue.Empty:
+                    # Send keepalive to prevent connection timeout
+                    if not self._send_sse_event("keepalive", {"timestamp": time.time()}):
+                        logger.debug("Client disconnected during keepalive")
+                        client_disconnected = True
+                        break
+                    continue
+                except Exception as e:
+                    logger.debug(f"Error streaming log: {e}")
+                    break
+
+        except BrokenPipeError:
+            logger.debug("Client disconnected (broken pipe)")
+        except Exception as e:
+            logger.debug(f"Log streaming error: {e}")
+
+        logger.info(f"Log stream ended, total entries sent: {sent_count}")
+
+    def _send_sse_event(self, event_type: str, data: dict) -> bool:
+        """Send a Server-Sent Event.
+        
+        Returns:
+            True if event was sent successfully, False if client disconnected
+        """
+        try:
+            event_data = f"event: {event_type}\ndata: {json.dumps(data)}\n\n"
+            self.wfile.write(event_data.encode('utf-8'))
+            self.wfile.flush()
+            return True
+        except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):
+            # Client disconnected - this is normal, not an error
+            return False
+        except Exception as e:
+            logger.debug(f"Error sending SSE event: {e}")
+            return False
+
+    def serve_log_viewer(self):
+        """Serve the log viewer HTML page."""
+        # Get configuration from server
+        test_run_title = getattr(self.server, "test_run_title", "Test Execution")
+        
+        # Read HTML template from file
+        try:
+            template_path = Path(__file__).parent / "log_viewer.html"
+            with open(template_path, "r", encoding="utf-8") as f:
+                html_template = f.read()
+
+            # Replace placeholders
+            html_content = html_template.format(
+                test_run_title=html.escape(test_run_title)
+            )
+        except Exception as e:
+            logger.error(f"Failed to load HTML template: {e}")
+            # Fallback to simple HTML
+            html_content = f"""
+            <html>
+            <head><title>Log Viewer Error</title></head>
+            <body>
+                <h1>Error loading log viewer interface</h1>
+                <p>Template error: {html.escape(str(e))}</p>
+                <p>Test Run: {html.escape(test_run_title)}</p>
+            </body>
+            </html>
+            """
+
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        # Prevent caching
+        self.send_header("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0")
+        self.send_header("Pragma", "no-cache")
+        self.send_header("Expires", "0")
+        self.send_header("ETag", f'"{int(time.time())}"')
+        self.end_headers()
+        self.wfile.write(html_content.encode("utf-8"))
+
+    def log_message(self, format, *args):
+        """Suppress HTTP access logs to avoid clutter."""
+        pass
+
+
+class LogsHTTPServer:
+    """Manages HTTP server for real-time log streaming."""
+
+    def __init__(self, port: int = 8998):
+        """Initialize the logs HTTP server.
+        
+        Args:
+            port: Port number for the HTTP server (default: 8998)
+        """
+        self.port = port
+        self.server: Optional[ThreadingHTTPServer] = None
+        self.server_thread: Optional[threading.Thread] = None
+
+    def start(
+        self,
+        log_queue: queue.Queue,
+        test_run_title: str = "Test Execution",
+        local_ip: Optional[str] = None,
+        log_file_path: Optional[str] = None,
+    ):
+        """Start HTTP server for log streaming.
+        
+        Args:
+            log_queue: Queue containing log entries to stream
+            test_run_title: Title of the test run for display
+            local_ip: Local IP address for display (defaults to localhost)
+            log_file_path: Path to log file for download functionality
+        """
+        try:
+            # Use ThreadingHTTPServer for better concurrency
+            self.server = ThreadingHTTPServer(("0.0.0.0", self.port), LogStreamingHandler)
+            self.server.allow_reuse_address = True
+
+            # Set required attributes on the server
+            self.server.log_queue = log_queue
+            self.server.test_run_title = test_run_title
+            self.server.local_ip = local_ip or "localhost"
+            self.server.log_file_path = log_file_path
+
+            logger.info(f"Logs HTTP server configured for test run: {test_run_title}")
+
+            def run_server():
+                logger.info(f"Starting logs HTTP server on port {self.port}")
+                try:
+                    self.server.serve_forever()
+                except Exception as e:
+                    logger.error(f"Logs HTTP server error: {e}")
+
+            self.server_thread = threading.Thread(target=run_server, daemon=True)
+            self.server_thread.start()
+            logger.info(f"Logs HTTP server thread started on port {self.port}")
+
+        except Exception as e:
+            logger.error(f"Failed to start logs HTTP server: {e}")
+            raise
+
+    def stop(self):
+        """Stop HTTP server."""
+        if self.server:
+            try:
+                self.server.shutdown()
+                logger.info("Logs HTTP server stopped")
+            except Exception as e:
+                logger.debug(f"Error stopping logs HTTP server: {e}")
+            finally:
+                self.server = None
+                self.server_thread = None