diff --git a/MCPForUnity/Editor/Constants/EditorPrefKeys.cs b/MCPForUnity/Editor/Constants/EditorPrefKeys.cs
index 5f99d3e5a..54a5fd006 100644
--- a/MCPForUnity/Editor/Constants/EditorPrefKeys.cs
+++ b/MCPForUnity/Editor/Constants/EditorPrefKeys.cs
@@ -63,5 +63,6 @@ internal static class EditorPrefKeys
         internal const string CustomerUuid = "MCPForUnity.CustomerUUID";
 
         internal const string ApiKey = "MCPForUnity.ApiKey";
+        internal const string KeepServerRunning = "MCPForUnity.KeepServerRunning";
     }
 }
diff --git a/MCPForUnity/Editor/Services/McpEditorShutdownCleanup.cs b/MCPForUnity/Editor/Services/McpEditorShutdownCleanup.cs
index 9b4bd6143..de3683777 100644
--- a/MCPForUnity/Editor/Services/McpEditorShutdownCleanup.cs
+++ b/MCPForUnity/Editor/Services/McpEditorShutdownCleanup.cs
@@ -41,8 +41,17 @@ private static void OnEditorQuitting()
             }
 
             // 2) Stop local HTTP server if it was Unity-managed (best-effort).
+            // Skip shutdown if Keep Server Running is enabled - server should persist for reconnection.
             try
             {
+                bool keepServerRunning = EditorPrefs.GetBool(EditorPrefKeys.KeepServerRunning, false);
+
+                if (keepServerRunning)
+                {
+                    McpLog.Info("Keep Server Running is enabled - leaving MCP server running after Unity quits");
+                    return;
+                }
+
                 bool useHttp = EditorConfigurationCache.Instance.UseHttpTransport;
                 string scope = string.Empty;
                 try { scope = EditorPrefs.GetString(EditorPrefKeys.HttpTransportScope, string.Empty); } catch { }
diff --git a/MCPForUnity/Editor/Services/Transport/Transports/WebSocketTransportClient.cs b/MCPForUnity/Editor/Services/Transport/Transports/WebSocketTransportClient.cs
index b94c0836f..c16605495 100644
--- a/MCPForUnity/Editor/Services/Transport/Transports/WebSocketTransportClient.cs
+++ b/MCPForUnity/Editor/Services/Transport/Transports/WebSocketTransportClient.cs
@@ -58,6 +58,7 @@ public class WebSocketTransportClient : IMcpTransportClient, IDisposable
         private int _isReconnectingFlag;
         private TransportState _state = TransportState.Disconnected(TransportDisplayName, "Transport not started");
         private string _apiKey;
+        private bool _keepServerRunning;
         private bool _disposed;
 
         public WebSocketTransportClient(IToolDiscoveryService toolDiscoveryService = null)
@@ -85,6 +86,7 @@ public async Task<bool> StartAsync()
             _apiKey = HttpEndpointUtility.IsRemoteScope()
                 ? EditorPrefs.GetString(EditorPrefKeys.ApiKey, string.Empty)
                 : string.Empty;
+            _keepServerRunning = EditorPrefs.GetBool(EditorPrefKeys.KeepServerRunning, false);
 
             // Get project root path (strip /Assets from dataPath) for focus nudging
             string dataPath = Application.dataPath;
@@ -608,7 +610,8 @@ private async Task SendRegisterAsync(CancellationToken token)
                 ["project_name"] = _projectName,
                 ["project_hash"] = _projectHash,
                 ["unity_version"] = _unityVersion,
-                ["project_path"] = _projectPath
+                ["project_path"] = _projectPath,
+                ["keep_server_running"] = _keepServerRunning
             };
 
             await SendJsonAsync(registerPayload, token).ConfigureAwait(false);
diff --git a/MCPForUnity/Editor/Windows/Components/Advanced/McpAdvancedSection.cs b/MCPForUnity/Editor/Windows/Components/Advanced/McpAdvancedSection.cs
index 4957e7da8..7ef801f1d 100644
--- a/MCPForUnity/Editor/Windows/Components/Advanced/McpAdvancedSection.cs
+++ b/MCPForUnity/Editor/Windows/Components/Advanced/McpAdvancedSection.cs
@@ -38,12 +38,14 @@ public class McpAdvancedSection
         private VisualElement healthIndicator;
         private Label healthStatus;
         private Button testConnectionButton;
+        private Toggle keepServerRunningToggle;
 
         // Events
         public event Action OnGitUrlChanged;
         public event Action OnHttpServerCommandUpdateRequested;
         public event Action OnTestConnectionRequested;
         public event Action<bool> OnBetaModeChanged;
+        public event Action<bool> OnKeepServerRunningChanged;
 
         public VisualElement Root { get; private set; }
 
@@ -77,6 +79,7 @@ private void CacheUIElements()
             deployStatusLabel = Root.Q<Label>("deploy-status-label");
             healthIndicator = Root.Q<VisualElement>("health-indicator");
             healthStatus = Root.Q<Label>("health-status");
+            keepServerRunningToggle = Root.Q<Toggle>("keep-server-running-toggle");
             testConnectionButton = Root.Q<Button>("test-connection-button");
         }
 
@@ -108,6 +111,26 @@ private void InitializeUI()
                 if (betaServerLabel != null)
                     betaServerLabel.tooltip = useBetaServerToggle.tooltip;
             }
+            if (keepServerRunningToggle != null)
+            {
+                // When enabled, server stays running after Unity disconnects (for auto-reconnect)
+                keepServerRunningToggle.tooltip = "When enabled, MCP server will stay running even when Unity disconnects. "
+                    + "Useful during development to avoid manual server restart after Domain Reload, test runs, or entering Play Mode. "
+                    + "Only works with HTTP transport mode.";
+                var keepRunningLabel = keepServerRunningToggle?.parent?.Q<Label>();
+                if (keepRunningLabel != null)
+                {
+                    keepRunningLabel.tooltip = keepServerRunningToggle.tooltip;
+                }
+                // Load current value and register callback
+                keepServerRunningToggle.value = EditorPrefs.GetBool(EditorPrefKeys.KeepServerRunning, false);
+                keepServerRunningToggle.RegisterValueChangedCallback(evt =>
+                {
+                    EditorPrefs.SetBool(EditorPrefKeys.KeepServerRunning, evt.newValue);
+                    OnKeepServerRunningChanged?.Invoke(evt.newValue);
+                    OnHttpServerCommandUpdateRequested?.Invoke();
+                });
+            }
             if (testConnectionButton != null)
                 testConnectionButton.tooltip = "Test the connection between Unity and the MCP server.";
             if (deploySourcePath != null)
diff --git a/MCPForUnity/Editor/Windows/Components/Advanced/McpAdvancedSection.uxml b/MCPForUnity/Editor/Windows/Components/Advanced/McpAdvancedSection.uxml
index ea5358aab..858609d04 100644
--- a/MCPForUnity/Editor/Windows/Components/Advanced/McpAdvancedSection.uxml
+++ b/MCPForUnity/Editor/Windows/Components/Advanced/McpAdvancedSection.uxml
@@ -12,7 +12,6 @@
                 <ui:Button name="browse-uv-button" text="Browse" class="icon-button" />
                 <ui:Button name="clear-uv-button" text="Clear" class="icon-button" />
             </ui:VisualElement>
-
             <ui:VisualElement class="override-row" style="margin-top: 8px;">
                 <ui:Label text="Server Source:" class="override-label" />
             </ui:VisualElement>
@@ -21,12 +20,10 @@
                 <ui:Button name="browse-git-url-button" text="Select" class="icon-button" />
                 <ui:Button name="clear-git-url-button" text="Clear" class="icon-button" />
             </ui:VisualElement>
-
             <ui:VisualElement class="setting-row" style="margin-top: 8px;">
                 <ui:Label text="Debug Logging:" class="setting-label" />
                 <ui:Toggle name="debug-logs-toggle" class="setting-toggle" />
             </ui:VisualElement>
-
             <ui:VisualElement class="setting-row">
                 <ui:Label text="Server Health:" class="setting-label" />
                 <ui:VisualElement class="status-container">
@@ -35,17 +32,18 @@
                 </ui:VisualElement>
                 <ui:Button name="test-connection-button" text="Test" class="action-button" />
             </ui:VisualElement>
-
             <ui:VisualElement class="setting-row">
                 <ui:Label text="Force Fresh Install:" class="setting-label" />
                 <ui:Toggle name="dev-mode-force-refresh-toggle" class="setting-toggle" />
             </ui:VisualElement>
-
             <ui:VisualElement class="setting-row">
                 <ui:Label text="Use Beta Server:" class="setting-label" />
                 <ui:Toggle name="use-beta-server-toggle" class="setting-toggle" />
             </ui:VisualElement>
-
+            <ui:VisualElement class="setting-row" style="margin-top: 4px;">
+                <ui:Label text="Keep Server Running:" class="setting-label" />
+                <ui:Toggle name="keep-server-running-toggle" class="setting-toggle" />
+            </ui:VisualElement>
             <ui:VisualElement class="override-row" style="margin-top: 8px;">
                 <ui:Label text="Package Source:" class="override-label" />
             </ui:VisualElement>
@@ -63,4 +61,4 @@
             <ui:Label name="deploy-status-label" class="help-text" />
         </ui:VisualElement>
     </ui:VisualElement>
-</ui:UXML>
+</ui:UXML>
\ No newline at end of file
diff --git a/Server/src/main.py b/Server/src/main.py
index 59855f29d..44bfe529f 100644
--- a/Server/src/main.py
+++ b/Server/src/main.py
@@ -133,11 +133,15 @@ def doRollover(self):
 # In-memory custom tool service initialized after MCP construction
 custom_tool_service: CustomToolService | None = None
 
+# Per-session keep_server_running flag, indexed by session_id
+# Set by middleware when Unity registers with the flag enabled
+keep_server_running: dict[str, bool] = {}
+
 
 @asynccontextmanager
 async def server_lifespan(server: FastMCP) -> AsyncIterator[dict[str, Any]]:
     """Handle server startup and shutdown."""
-    global _unity_connection_pool, _server_version
+    global _unity_connection_pool, _server_version, keep_server_running
     _server_version = get_package_version()
     logger.info(f"MCP for Unity Server v{_server_version} starting up")
 
@@ -183,9 +187,17 @@ def _emit_startup():
             logger.info(
                 "Skipping Unity connection on startup (UNITY_MCP_SKIP_STARTUP_CONNECT=1)")
         else:
-            # Initialize connection pool and discover instances
-            _unity_connection_pool = get_unity_connection_pool()
-            instances = _unity_connection_pool.discover_all_instances()
+            # Initialize connection pool and discover instances (stdio mode only)
+            # In HTTP mode, PluginHub handles connections directly
+            instances = []  # Initialize to avoid UnboundLocalError in HTTP mode
+            if enable_http_server:
+                _unity_connection_pool = None  # No legacy pool in HTTP mode
+                logger.info("HTTP mode enabled - PluginHub will manage Unity connections")
+                # Skip stdio-specific connection logic in HTTP mode.
+                # Lifespan must still continue to reach the context yield.
+            else:
+                _unity_connection_pool = get_unity_connection_pool()
+                instances = _unity_connection_pool.discover_all_instances()
 
             if instances:
                 logger.info(
@@ -244,9 +256,23 @@ def _emit_startup():
             "plugin_registry": _plugin_registry,
         }
     finally:
-        if _unity_connection_pool:
+        # In HTTP mode, PluginHub manages connections independently.
+        # Only disconnect legacy pool if it was initialized (stdio mode).
+        # Check if any session has keep_server_running enabled.
+        has_keep_running = any(keep_server_running.values()) if keep_server_running else False
+
+        if _unity_connection_pool and not has_keep_running:
             _unity_connection_pool.disconnect_all()
-        logger.info("MCP for Unity Server shut down")
+
+        shutdown_msg = "MCP for Unity Server shut down"
+        if has_keep_running:
+            shutdown_msg += " (Keep-Running mode: maintaining server for Unity reconnection)"
+        logger.info(shutdown_msg)
+
+        # Note: keep_server_running state is per-session, not server-global.
+        # Cleared when sessions expire, used by middleware to pass state.
+        keep_server_running.clear()
+
 
 
 def _build_instructions(project_scoped_tools: bool) -> str:
diff --git a/Server/src/transport/models.py b/Server/src/transport/models.py
index 802951a24..0e3206e9c 100644
--- a/Server/src/transport/models.py
+++ b/Server/src/transport/models.py
@@ -37,6 +37,7 @@ class RegisterMessage(BaseModel):
     project_hash: str
     unity_version: str = "Unknown"
     project_path: str | None = None  # Full path to project root (for focus nudging)
+    keep_server_running: bool = False  # When True, server stays running after Unity disconnects
 
 
 class RegisterToolsMessage(BaseModel):
diff --git a/Server/src/transport/plugin_hub.py b/Server/src/transport/plugin_hub.py
index 1058c4136..8ddeee176 100644
--- a/Server/src/transport/plugin_hub.py
+++ b/Server/src/transport/plugin_hub.py
@@ -191,6 +191,13 @@ async def on_disconnect(self, websocket: WebSocket, close_code: int) -> None:
                     ping_task.cancel()
                 # Clean up last pong tracking
                 cls._last_pong.pop(session_id, None)
+                # Clean up keep_server_running flag to avoid stale entries
+                try:
+                    import main as main_module
+                    main_module.keep_server_running.pop(session_id, None)
+                except (ImportError, AttributeError, KeyError):
+                    # main module not yet imported or key already removed
+                    pass
                 # Fail-fast any in-flight commands for this session to avoid waiting for COMMAND_TIMEOUT.
                 pending_ids = [
                     command_id
@@ -364,6 +371,7 @@ async def _handle_register(self, websocket: WebSocket, payload: RegisterMessage)
         project_hash = payload.project_hash
         unity_version = payload.unity_version
         project_path = payload.project_path
+        keep_server_running = getattr(payload, 'keep_server_running', False)
 
         if not project_hash:
             await websocket.close(code=4400)
@@ -378,7 +386,15 @@ async def _handle_register(self, websocket: WebSocket, payload: RegisterMessage)
         response = RegisteredMessage(session_id=session_id)
         await websocket.send_json(response.model_dump())
 
-        session = await registry.register(session_id, project_name, project_hash, unity_version, project_path, user_id=user_id)
+        session = await registry.register(
+            session_id, project_name, project_hash, unity_version, project_path,
+            user_id=user_id, keep_server_running=keep_server_running
+        )
+
+        # Store keep_server_running flag in global dict for shutdown logic.
+        # Import here to avoid circular dependency at module import time.
+        import main as main_module
+        main_module.keep_server_running[session.session_id] = keep_server_running
         async with lock:
             cls._connections[session.session_id] = websocket
             # Initialize last pong time and start ping loop for this session
diff --git a/Server/src/transport/plugin_registry.py b/Server/src/transport/plugin_registry.py
index 5f8f75b29..541d10a34 100644
--- a/Server/src/transport/plugin_registry.py
+++ b/Server/src/transport/plugin_registry.py
@@ -19,13 +19,14 @@ class PluginSession:
     project_name: str
     project_hash: str
     unity_version: str
-    registered_at: datetime
-    connected_at: datetime
+    registered_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    connected_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
     tools: dict[str, ToolDefinitionModel] = field(default_factory=dict)
     project_id: str | None = None
     # Full path to project root (for focus nudging)
     project_path: str | None = None
     user_id: str | None = None  # Associated user id (None for local mode)
+    keep_server_running: bool = False  # When True, server stays running after Unity disconnects
 
 
 class PluginRegistry:
@@ -55,6 +56,7 @@ async def register(
         unity_version: str,
         project_path: str | None = None,
         user_id: str | None = None,
+        keep_server_running: bool = False,
     ) -> PluginSession:
         """Register (or replace) a plugin session.
 
@@ -76,6 +78,7 @@ async def register(
                 connected_at=now,
                 project_path=project_path,
                 user_id=user_id,
+                keep_server_running=keep_server_running,
             )
 
             # Remove old mapping for this hash if it existed under a different session
diff --git a/Server/tests/integration/test_plugin_hub_websocket_auth.py b/Server/tests/integration/test_plugin_hub_websocket_auth.py
index 3d3041203..3def2205f 100644
--- a/Server/tests/integration/test_plugin_hub_websocket_auth.py
+++ b/Server/tests/integration/test_plugin_hub_websocket_auth.py
@@ -181,3 +181,39 @@ async def test_user_id_passed_to_registry_on_register(self, monkeypatch):
         assert session.user_id == "user-99"
         assert session.project_name == "TestProject"
         assert session.project_hash == "abc123"
+
+    @pytest.mark.asyncio
+    async def test_register_tracks_connection_and_keep_running_state(self, monkeypatch):
+        """Register should store the websocket connection and keep-running flag."""
+        monkeypatch.setattr(config, "http_remote_hosted", False)
+
+        registry = PluginRegistry()
+        loop = asyncio.get_running_loop()
+        PluginHub.configure(registry, loop)
+
+        ws = _make_mock_websocket(headers={})
+        hub = _make_hub()
+
+        import main as main_module
+        main_module.keep_server_running.clear()
+
+        await hub.on_connect(ws)
+        await hub.on_receive(
+            ws,
+            {
+                "type": "register",
+                "project_name": "KeepAliveProject",
+                "project_hash": "keep-alive-hash",
+                "unity_version": "2022.3",
+                "keep_server_running": True,
+            },
+        )
+
+        sessions = await registry.list_sessions()
+        assert len(sessions) == 1
+        session_id = next(iter(sessions.keys()))
+
+        assert session_id in PluginHub._connections
+        assert main_module.keep_server_running.get(session_id) is True
+
+        main_module.keep_server_running.clear()
diff --git a/Server/tests/test_keep_running_mode.py b/Server/tests/test_keep_running_mode.py
new file mode 100644
index 000000000..7485bca52
--- /dev/null
+++ b/Server/tests/test_keep_running_mode.py
@@ -0,0 +1,126 @@
+"""Tests for Keep Server Running feature (Issue #672).
+
+This feature allows the MCP server to stay running even when Unity disconnects,
+enabling automatic reconnection when Unity comes back.
+"""
+
+import asyncio
+import pytest
+from unittest.mock import MagicMock
+
+from transport.plugin_registry import PluginSession
+
+
+class TestKeepServerRunningMode:
+    """Tests for keep_server_running functionality."""
+
+    def test_keep_running_message_format(self):
+        """Verify keep_server_running field in RegisterMessage."""
+        # Test that RegisterMessage can be created with keep_server_running=True
+        msg_true = {
+            "project_name": "TestProject",
+            "project_hash": "hash123",
+            "unity_version": "2022.3.0f0",
+            "project_path": "/Test/Path",
+            "keep_server_running": True
+        }
+
+        # Test that RegisterMessage can be created with keep_server_running=False
+        msg_false = {
+            "project_name": "TestProject",
+            "project_hash": "hash456",
+            "unity_version": "2022.3.0f0",
+            "project_path": "/Test/Path",
+            "keep_server_running": False
+        }
+
+        # Verify the field name and values are correct
+        assert "keep_server_running" in msg_true
+        assert msg_true["keep_server_running"] is True
+        assert "keep_server_running" in msg_false
+        assert msg_false["keep_server_running"] is False
+
+    def test_plugin_session_has_keep_running_field(self):
+        """Verify PluginSession dataclass has keep_server_running field."""
+        # Create a session with keep_server_running=True
+        session = PluginSession(
+            session_id="test-session-123",
+            project_name="TestProject",
+            project_hash="abc123",
+            unity_version="2022.3.0f0",
+            project_path="/path/to/project",
+            keep_server_running=True
+        )
+        assert session.keep_server_running is True
+
+        # Create a session with keep_server_running=False (default)
+        session_default = PluginSession(
+            session_id="test-session-456",
+            project_name="TestProject",
+            project_hash="def456",
+            unity_version="2023.2.0f1",
+            project_path="/another/path"
+        )
+        assert session_default.keep_server_running is False
+
+    @pytest.mark.asyncio
+    async def test_server_lifespan_yields_in_http_mode(self, monkeypatch):
+        """HTTP mode should still enter lifespan context and yield shared state."""
+        import main as main_module
+
+        class _NoOpTimer:
+            def __init__(self, *_args, **_kwargs):
+                pass
+
+            def start(self):
+                return None
+
+        old_pool = main_module._unity_connection_pool
+        old_registry = main_module._plugin_registry
+        old_keep_running = dict(main_module.keep_server_running)
+
+        monkeypatch.setenv("UNITY_MCP_ENABLE_HTTP_SERVER", "1")
+        monkeypatch.delenv("UNITY_MCP_SKIP_STARTUP_CONNECT", raising=False)
+        monkeypatch.setattr(main_module.threading, "Timer", _NoOpTimer)
+
+        try:
+            main_module._unity_connection_pool = None
+            main_module._plugin_registry = None
+            main_module.keep_server_running.clear()
+
+            async with main_module.server_lifespan(MagicMock()) as state:
+                assert state["pool"] is None
+                assert state["plugin_registry"] is not None
+        finally:
+            main_module._unity_connection_pool = old_pool
+            main_module._plugin_registry = old_registry
+            main_module.keep_server_running.clear()
+            main_module.keep_server_running.update(old_keep_running)
+
+    @pytest.mark.asyncio
+    async def test_keep_running_flag_cleared_on_disconnect(self, monkeypatch):
+        """Verify keep_server_running entry is removed when session disconnects."""
+        import main as main_module
+        from transport.plugin_hub import PluginHub
+        from transport.plugin_registry import PluginRegistry
+
+        # Clear any existing state
+        main_module.keep_server_running.clear()
+
+        registry = PluginRegistry()
+        loop = asyncio.get_running_loop()
+        PluginHub.configure(registry, loop)
+
+        # Simulate session registration with keep_server_running=True
+        session_id = "test-disconnect-session"
+        main_module.keep_server_running[session_id] = True
+
+        # Verify entry exists
+        assert session_id in main_module.keep_server_running
+        assert main_module.keep_server_running[session_id] is True
+
+        # Simulate disconnection cleanup (as happens in on_disconnect)
+        main_module.keep_server_running.pop(session_id, None)
+
+        # Verify entry is removed
+        assert session_id not in main_module.keep_server_running