diff --git a/README.md b/README.md
index 7315d562..29ed1f8d 100644
--- a/README.md
+++ b/README.md
@@ -68,6 +68,23 @@ In XTMF2, open **Settings**, open **RunServers**, and add a remote endpoint. Ent
 
 The GUI pins the server certificate to this fingerprint and authenticates with the token before creating the RunServer bus. A mismatched certificate or token is rejected. Do not expose the TCP port to untrusted networks; use firewall rules or a private network as appropriate.
 
+## Distributed estimation
+
+Estimation runs can evaluate candidate parameter vectors concurrently across multiple connected RunServers. Normal model runs and calibration runs continue to use one RunServer.
+
+To start a distributed estimation run:
+
+1. Connect the required RunServers from **Settings** > **RunServers**.
+2. Open the model system and choose **Run Estimation**.
+3. Select two or more RunServers in the run configuration dialog and choose the orchestrator RunServer. The other selected servers are workers.
+4. If the model has an estimation `InputDirectory`, review its worker-local value for each selected worker. These values are saved in the GUI settings by model node ID and are reused on later estimation runs.
+
+The orchestrator RunServer owns the estimation algorithm and connects directly to the workers. Each worker constructs and validates its own local copy of the model. Input-directory overrides are applied only to that worker's copy; the saved model system is not modified. The orchestrator must be able to reach every worker's configured TCP endpoint.
+
+After submission, the GUI is not required for the optimization to continue. The orchestrator persists `estimation-completion.json` in the run directory when the job finishes, including the best parameter values and completion status.
+
+RunServers that receive path overrides must be running the current shared-estimation worker build. Runs without path overrides retain the version-1 shared-estimation protocol and remain compatible with workers that support the original distributed-estimation protocol.
+
 ## Main Branches
 
 There are 4 major branches for XTMF 2 intended for different purposes:
diff --git a/XTMF2.sln b/XTMF2.sln
index 3e9aa680..7dabf2f5 100644
--- a/XTMF2.sln
+++ b/XTMF2.sln
@@ -33,6 +33,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "XTMF2.Run", "src\XTMF2.Run\
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XTMF2.GUI", "src\XTMF2.GUI\XTMF2.GUI.csproj", "{A16D11CD-0D70-4558-8CEA-52F0601C215A}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XTMF2.RunServer.Updater", "src\XTMF2.RunServer.Updater\XTMF2.RunServer.Updater.csproj", "{E3239050-BF93-44A7-BC91-6F865087EBB7}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -139,6 +141,18 @@ Global
 		{A16D11CD-0D70-4558-8CEA-52F0601C215A}.Release|x64.Build.0 = Release|Any CPU
 		{A16D11CD-0D70-4558-8CEA-52F0601C215A}.Release|x86.ActiveCfg = Release|Any CPU
 		{A16D11CD-0D70-4558-8CEA-52F0601C215A}.Release|x86.Build.0 = Release|Any CPU
+		{E3239050-BF93-44A7-BC91-6F865087EBB7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E3239050-BF93-44A7-BC91-6F865087EBB7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E3239050-BF93-44A7-BC91-6F865087EBB7}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{E3239050-BF93-44A7-BC91-6F865087EBB7}.Debug|x64.Build.0 = Debug|Any CPU
+		{E3239050-BF93-44A7-BC91-6F865087EBB7}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{E3239050-BF93-44A7-BC91-6F865087EBB7}.Debug|x86.Build.0 = Debug|Any CPU
+		{E3239050-BF93-44A7-BC91-6F865087EBB7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E3239050-BF93-44A7-BC91-6F865087EBB7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E3239050-BF93-44A7-BC91-6F865087EBB7}.Release|x64.ActiveCfg = Release|Any CPU
+		{E3239050-BF93-44A7-BC91-6F865087EBB7}.Release|x64.Build.0 = Release|Any CPU
+		{E3239050-BF93-44A7-BC91-6F865087EBB7}.Release|x86.ActiveCfg = Release|Any CPU
+		{E3239050-BF93-44A7-BC91-6F865087EBB7}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -152,6 +166,7 @@ Global
 		{A1B2C3D4-E5F6-7890-ABCD-EF1234567890} = {77789778-93F5-46A6-9114-CCE855E5919C}
 		{F6999FCE-4C4F-4CF6-9B70-0DEA31FB5E6D} = {9040CC77-712E-414D-8453-391F9F348218}
 		{A16D11CD-0D70-4558-8CEA-52F0601C215A} = {9040CC77-712E-414D-8453-391F9F348218}
+		{E3239050-BF93-44A7-BC91-6F865087EBB7} = {9040CC77-712E-414D-8453-391F9F348218}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {15025AE3-C5AA-4CD4-BC38-D1C1BA8904AF}
diff --git a/src/XTMF2.Bus/CreateStreams.cs b/src/XTMF2.Bus/CreateStreams.cs
new file mode 100644
index 00000000..e69de29b
diff --git a/src/XTMF2.Client/Program.cs b/src/XTMF2.Client/Program.cs
index ac9ec8c5..10da6f74 100644
--- a/src/XTMF2.Client/Program.cs
+++ b/src/XTMF2.Client/Program.cs
@@ -19,6 +19,7 @@ You should have received a copy of the GNU General Public License
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -27,15 +28,22 @@ You should have received a copy of the GNU General Public License
 using System.Security.Cryptography;
 using System.Security.Cryptography.X509Certificates;
 using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
 using XTMF2.Configuration;
 
 namespace XTMF2.Client
 {
     public class Program
     {
+        private static string[] _originalArguments = Array.Empty<string>();
+        private static readonly Stopwatch StartupStopwatch = Stopwatch.StartNew();
+
         [MTAThread]
         static void Main(string[] args)
         {
+            _originalArguments = args;
+            LogStartup("Process started; parsing command-line arguments.");
+            LogDeploymentStartupSummary();
             if (args.Length == 0)
             {
                 Console.WriteLine("Usage: XTMF.Run [-setup-security DIRECTORY] [-loadDLL dllPath] [-tcp ADDRESS PORT -security DIRECTORY] [-namedPipe PIPE_NAME]");
@@ -150,14 +158,18 @@ private static bool IsLoopbackAddress(string address)
 
         private static void RunTcpServer(string address, int port, string? securityDirectory, List<string> extraDlls)
         {
+            LogStartup($"Initializing TCP server on {address}:{port}.");
             X509Certificate2? certificate = null;
             string? token = null;
             if (securityDirectory is not null)
             {
+                var securityStopwatch = Stopwatch.StartNew();
+                LogStartup("Loading TCP server security credentials.");
                 try
                 {
                     certificate = RunServerSecurity.LoadCertificate(securityDirectory);
                     token = RunServerSecurity.LoadToken(securityDirectory);
+                    LogStartup($"TCP server security credentials loaded in {securityStopwatch.ElapsedMilliseconds} ms.");
                 }
                 catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or CryptographicException)
                 {
@@ -166,6 +178,8 @@ private static void RunTcpServer(string address, int port, string? securityDirec
                 }
             }
 
+            var listenerStopwatch = Stopwatch.StartNew();
+            LogStartup("Binding the TCP listener.");
             if (!CreateStreams.CreateTcpListener(address, port, out var listener, out var boundPort, out var error))
             {
                 Console.WriteLine("Error creating TCP RunServer listener\r\n" + error);
@@ -177,8 +191,12 @@ private static void RunTcpServer(string address, int port, string? securityDirec
             if (certificate is not null)
                 Console.WriteLine($"Certificate fingerprint: {RunServerSecurity.GetFingerprint(certificate)}");
             Console.Out.Flush();
+            LogStartup($"TCP listener bound in {listenerStopwatch.ElapsedMilliseconds} ms on {address}:{boundPort}.");
+            SignalDeploymentReady();
             using (tcpListener)
             using (var shutdown = new CancellationTokenSource())
+            using (var remoteEstimationRegistry = new RemoteSharedEstimationRegistry())
+            using (var remoteRunRegistry = new RemoteRunRegistry())
             {
                 Console.CancelKeyPress += (_, eventArgs) =>
                 {
@@ -187,6 +205,7 @@ private static void RunTcpServer(string address, int port, string? securityDirec
                     tcpListener.Stop();
                 };
 
+                LogStartup($"READY: accepting TCP connections on {address}:{boundPort}.");
                 while (!shutdown.IsCancellationRequested)
                 {
                     TcpClient? client = null;
@@ -212,13 +231,16 @@ private static void RunTcpServer(string address, int port, string? securityDirec
                     Console.Out.Flush();
                     var acceptedClient = client;
                     _ = securityDirectory is null
-                        ? Task.Run(() => RunTcpClientUnsecured(acceptedClient, extraDlls))
-                        : Task.Run(() => RunTcpClient(acceptedClient, certificate!, token!, extraDlls));
+                        ? Task.Run(() => RunTcpClientUnsecured(acceptedClient, extraDlls,
+                            remoteEstimationRegistry, remoteRunRegistry))
+                        : Task.Run(() => RunTcpClient(acceptedClient, certificate!, token!, extraDlls,
+                            remoteEstimationRegistry, remoteRunRegistry));
                 }
             }
         }
 
-        private static void RunTcpClientUnsecured(TcpClient client, List<string> extraDlls)
+        private static void RunTcpClientUnsecured(TcpClient client, List<string> extraDlls,
+            RemoteSharedEstimationRegistry remoteEstimationRegistry, RemoteRunRegistry remoteRunRegistry)
         {
             var remoteEndpoint = client.Client.RemoteEndPoint?.ToString() ?? "unknown endpoint";
             Console.WriteLine($"Local RunServer connection accepted from {remoteEndpoint}");
@@ -228,7 +250,10 @@ private static void RunTcpClientUnsecured(TcpClient client, List<string> extraDl
             {
                 try
                 {
-                    RunClient(stream, extraDlls, usePrivateWorkspace: true);
+                    RunClient(stream, extraDlls, usePrivateWorkspace: true,
+                        allowDeployment: false,
+                        remoteEstimationRegistry: remoteEstimationRegistry,
+                        remoteRunRegistry: remoteRunRegistry);
                 }
                 catch (Exception ex)
                 {
@@ -238,14 +263,16 @@ private static void RunTcpClientUnsecured(TcpClient client, List<string> extraDl
             }
         }
 
-        private static void RunTcpClient(TcpClient client, X509Certificate2 certificate, string token, List<string> extraDlls)
+        private static void RunTcpClient(TcpClient client, X509Certificate2 certificate, string token, List<string> extraDlls,
+            RemoteSharedEstimationRegistry remoteEstimationRegistry, RemoteRunRegistry remoteRunRegistry)
         {
             var remoteEndpoint = client.Client.RemoteEndPoint?.ToString() ?? "unknown endpoint";
+            var authenticationStopwatch = Stopwatch.StartNew();
             using (client)
             {
                 if (!CreateStreams.AuthenticateSecureTcpClient(client, certificate, token, out var stream, out var error))
                 {
-                    Console.WriteLine($"RunServer security validation failed for {remoteEndpoint}: {error}");
+                    Console.WriteLine($"RunServer TLS/token authentication failed for {remoteEndpoint} after {authenticationStopwatch.ElapsedMilliseconds} ms: {error}");
                     Console.Out.Flush();
                     return;
                 }
@@ -255,7 +282,10 @@ private static void RunTcpClient(TcpClient client, X509Certificate2 certificate,
                 {
                     try
                     {
-                        RunClient(stream, extraDlls, usePrivateWorkspace: true);
+                        RunClient(stream, extraDlls, usePrivateWorkspace: true,
+                            allowDeployment: true,
+                            remoteEstimationRegistry: remoteEstimationRegistry,
+                            remoteRunRegistry: remoteRunRegistry);
                     }
                     catch (Exception ex)
                     {
@@ -268,16 +298,191 @@ private static void RunTcpClient(TcpClient client, X509Certificate2 certificate,
             }
         }
 
-        private static void RunClient(Stream serverStream, List<string> extraDlls, SystemConfiguration? config = null, bool usePrivateWorkspace = false)
+        private static void RunClient(Stream serverStream, List<string> extraDlls, SystemConfiguration? config = null,
+            bool usePrivateWorkspace = false, RemoteSharedEstimationRegistry? remoteEstimationRegistry = null,
+            RemoteRunRegistry? remoteRunRegistry = null, bool allowDeployment = false)
         {
+            var runtimeStopwatch = Stopwatch.StartNew();
+            LogStartup("Initializing the XTMF runtime for a client connection.");
             var runtime = XTMFRuntime.CreateRuntime(config);
+            LogStartup($"XTMF runtime initialized in {runtimeStopwatch.ElapsedMilliseconds} ms.");
             var loadedConfig = runtime.SystemConfiguration;
             foreach (var dll in extraDlls)
             {
+                var assemblyStopwatch = Stopwatch.StartNew();
+                LogStartup($"Loading additional assembly '{Path.GetFileName(dll)}'.");
                 loadedConfig.LoadAssembly(dll);
+                LogStartup($"Additional assembly loaded in {assemblyStopwatch.ElapsedMilliseconds} ms.");
+            }
+            using var ownedRemoteEstimationRegistry = remoteEstimationRegistry is null
+                ? new RemoteSharedEstimationRegistry()
+                : null;
+            var registry = remoteEstimationRegistry ?? ownedRemoteEstimationRegistry!;
+            using var clientBus = new RunServerBus(serverStream, true, runtime, extraDlls,
+                System.Diagnostics.Debugger.IsAttached, usePrivateWorkspace, remoteRunRegistry, allowDeployment);
+            using var sharedEstimationWorker = clientBus.AttachSharedEstimationWorker();
+            using var remoteCoordinator = new RemoteSharedEstimationCoordinatorSession(clientBus, registry);
+            clientBus.SetDeploymentGate(
+                () =>
+                {
+                    remoteRunRegistry?.BeginDrain();
+                    registry.BeginDrain();
+                },
+                () =>
+                {
+                    remoteRunRegistry?.EndDrain();
+                    registry.EndDrain();
+                },
+                () =>
+                    (remoteRunRegistry?.IsIdle ?? true) && registry.IsIdle,
+                RestartWithOriginalArguments);
+            clientBus.SetSharedActivityProviders(registry.GetActiveActivities,
+                sharedEstimationWorker.GetActiveActivities);
+            try
+            {
+                clientBus.ProcessRequests();
+            }
+            finally
+            {
+                remoteRunRegistry?.Detach(clientBus);
+            }
+        }
+
+        private static void LogStartup(string message)
+        {
+            Console.Error.WriteLine($"[RunServer +{StartupStopwatch.ElapsedMilliseconds} ms] {message}");
+            Console.Error.Flush();
+        }
+
+        private static bool RestartWithOriginalArguments(string stagingRoot)
+        {
+            if (!Directory.Exists(stagingRoot) || !File.Exists(Path.Combine(stagingRoot, "deployment.zip")))
+                return false;
+
+            var processPath = Environment.ProcessPath;
+            if (string.IsNullOrWhiteSpace(processPath))
+                return false;
+
+            string? deploymentDirectory = null;
+            try
+            {
+                var processDirectory = GetInstallationDirectory(processPath);
+                if (string.IsNullOrWhiteSpace(processDirectory))
+                    return false;
+
+                deploymentDirectory = Path.Combine(processDirectory, ".deployments",
+                    DateTime.UtcNow.ToString("yyyyMMddHHmmssfff") + "-" + Guid.NewGuid().ToString("N"));
+                Directory.CreateDirectory(deploymentDirectory);
+                var archivePath = Path.Combine(deploymentDirectory, "deployment.zip");
+                File.Copy(Path.Combine(stagingRoot, "deployment.zip"), archivePath);
+
+                var updaterPath = Path.Combine(processDirectory,
+                    OperatingSystem.IsWindows() ? "XTMF2.RunServer.Updater.exe" : "XTMF2.RunServer.Updater");
+                if (!File.Exists(updaterPath))
+                    throw new FileNotFoundException("The RunServer updater executable is missing.", updaterPath);
+
+                var updaterInfo = new ProcessStartInfo(updaterPath)
+                {
+                    UseShellExecute = false,
+                    WorkingDirectory = processDirectory
+                };
+                updaterInfo.ArgumentList.Add("--old-pid");
+                updaterInfo.ArgumentList.Add(Environment.ProcessId.ToString());
+                updaterInfo.ArgumentList.Add("--install-dir");
+                updaterInfo.ArgumentList.Add(processDirectory);
+                updaterInfo.ArgumentList.Add("--server-path");
+                updaterInfo.ArgumentList.Add(processPath);
+                updaterInfo.ArgumentList.Add("--server-assembly");
+                updaterInfo.ArgumentList.Add(typeof(Program).Assembly.Location);
+                updaterInfo.ArgumentList.Add("--deployment-dir");
+                updaterInfo.ArgumentList.Add(deploymentDirectory);
+                updaterInfo.ArgumentList.Add("--staging-root");
+                updaterInfo.ArgumentList.Add(stagingRoot);
+                foreach (var argument in _originalArguments)
+                {
+                    updaterInfo.ArgumentList.Add("--server-arg");
+                    updaterInfo.ArgumentList.Add(argument);
+                }
+                if (System.Diagnostics.Process.Start(updaterInfo) is null)
+                    throw new InvalidOperationException("Unable to start the RunServer updater.");
+                Environment.Exit(0);
+                return true;
+            }
+            catch (Exception exception) when (exception is IOException or InvalidDataException or UnauthorizedAccessException or
+                InvalidOperationException or System.ComponentModel.Win32Exception or ArgumentException)
+            {
+                Console.Error.WriteLine($"Unable to restart RunServer: {exception.Message}");
+                if (deploymentDirectory is not null)
+                {
+                    try
+                    {
+                        Directory.Delete(deploymentDirectory, recursive: true);
+                    }
+                    catch (Exception cleanupException) when (cleanupException is IOException or UnauthorizedAccessException)
+                    {
+                        Console.Error.WriteLine($"Unable to clean up failed deployment: {cleanupException.Message}");
+                    }
+                }
+                return false;
+            }
+        }
+
+        private static void SignalDeploymentReady()
+        {
+            var readyFile = Environment.GetEnvironmentVariable("XTMF2_DEPLOYMENT_READY_FILE");
+            if (!string.IsNullOrWhiteSpace(readyFile))
+            {
+                try
+                {
+                    File.WriteAllText(readyFile, "ready");
+                }
+                catch (IOException exception)
+                {
+                    Console.Error.WriteLine($"Unable to signal RunServer readiness: {exception.Message}");
+                }
+            }
+            Environment.SetEnvironmentVariable("XTMF2_DEPLOYMENT_READY_FILE", null);
+        }
+
+        private static bool IsDotnetHost(string processPath)
+        {
+            var fileName = Path.GetFileNameWithoutExtension(processPath);
+            return string.Equals(fileName, "dotnet", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static string GetInstallationDirectory(string processPath)
+        {
+            if (IsDotnetHost(processPath))
+                return Path.GetDirectoryName(typeof(Program).Assembly.Location) ?? Environment.CurrentDirectory;
+            return Path.GetDirectoryName(processPath) ?? Environment.CurrentDirectory;
+        }
+
+        private static void LogDeploymentStartupSummary()
+        {
+            var manifestPath = Environment.GetEnvironmentVariable("XTMF2_DEPLOYMENT_MANIFEST");
+            if (string.IsNullOrWhiteSpace(manifestPath) || !File.Exists(manifestPath))
+                return;
+
+            try
+            {
+                var modules = File.ReadAllLines(manifestPath)
+                    .Where(module => module.Length <= 256 &&
+                        !module.Any(char.IsControl) &&
+                        (module.Equals("XTMF2.dll", StringComparison.Ordinal) ||
+                         module.StartsWith("Modules/", StringComparison.Ordinal)))
+                    .Take(4096)
+                    .ToArray();
+                Console.WriteLine($"RunServer restarted with deployment containing {modules.Length} module file(s):");
+                foreach (var module in modules)
+                    Console.WriteLine($"  {module}");
+                Console.Out.Flush();
+                Environment.SetEnvironmentVariable("XTMF2_DEPLOYMENT_MANIFEST", null);
+            }
+            catch (IOException exception)
+            {
+                Console.WriteLine($"RunServer restarted, but deployment overview could not be read: {exception.Message}");
+                Console.Out.Flush();
             }
-            using var clientBus = new RunServerBus(serverStream, true, runtime, extraDlls, System.Diagnostics.Debugger.IsAttached, usePrivateWorkspace);
-            clientBus.ProcessRequests();
         }
     }
 }
\ No newline at end of file
diff --git a/src/XTMF2.Client/Properties/launchSettings.json b/src/XTMF2.Client/Properties/launchSettings.json
index fccb7da5..8d3b4bac 100644
--- a/src/XTMF2.Client/Properties/launchSettings.json
+++ b/src/XTMF2.Client/Properties/launchSettings.json
@@ -3,6 +3,10 @@
     "XTMF.Run": {
       "commandName": "Project",
       "commandLineArgs": "-loadDLL \"../../../../../tests/XTMF2.UnitTests/bin/Debug/netcoreapp3.1/XTMF2.UnitTests.dll\" -namedPipe 123"
+    },
+    "XTMF.RunServer": {
+      "commandName": "Project",
+      "commandLineArgs": "-tcp 0.0.0.0 1447 -security .\\runserver-security\\"
     }
   }
 }
\ No newline at end of file
diff --git a/src/XTMF2.Client/XTMF2.RunServer.csproj b/src/XTMF2.Client/XTMF2.RunServer.csproj
index dccff50c..7754176b 100644
--- a/src/XTMF2.Client/XTMF2.RunServer.csproj
+++ b/src/XTMF2.Client/XTMF2.RunServer.csproj
@@ -26,6 +26,7 @@
     <ProjectReference Include="..\XTMF2.Run\XTMF2.Run.csproj" />
     <ProjectReference Include="..\XTMF2\XTMF2.csproj" />
     <ProjectReference Include="..\XTMF2.Interfaces\XTMF2.Interfaces.csproj" />
+    <ProjectReference Include="..\XTMF2.RunServer.Updater\XTMF2.RunServer.Updater.csproj" ReferenceOutputAssembly="false" />
   </ItemGroup>
 
 </Project>
diff --git a/src/XTMF2.GUI/App.axaml b/src/XTMF2.GUI/App.axaml
index fe3db5ba..71d38d79 100644
--- a/src/XTMF2.GUI/App.axaml
+++ b/src/XTMF2.GUI/App.axaml
@@ -332,6 +332,12 @@
         <Style Selector="Window.neon-dialog TextBlock">
             <Setter Property="Foreground" Value="{DynamicResource DlgFg}"/>
         </Style>
+        <Style Selector="Window.neon-dialog Grid.activity-row">
+            <Setter Property="Background" Value="Transparent"/>
+        </Style>
+        <Style Selector="Window.neon-dialog Grid.activity-row:pointerover">
+            <Setter Property="Background" Value="{DynamicResource DlgSelected}"/>
+        </Style>
         <Style Selector="Window.neon-dialog TextBox">
             <Setter Property="Background" Value="{DynamicResource DlgInputBg}"/>
             <Setter Property="Foreground" Value="{DynamicResource DlgFg}"/>
diff --git a/src/XTMF2.GUI/MainWindow.axaml b/src/XTMF2.GUI/MainWindow.axaml
index abca904b..5ff63d38 100644
--- a/src/XTMF2.GUI/MainWindow.axaml
+++ b/src/XTMF2.GUI/MainWindow.axaml
@@ -39,6 +39,7 @@
                           InputGesture="Ctrl+B"/>
             </MenuItem>
             <MenuItem Header="{res:Localize MainWindow_MenuTools}">
+                <MenuItem Header="RunServer Activity" Click="RunServerActivity_Click"/>
                 <MenuItem Header="{res:Localize MainWindow_MenuSettings}" Click="Settings_Click"/>
             </MenuItem>
             <MenuItem Header="{res:Localize MainWindow_MenuHelp}">
diff --git a/src/XTMF2.GUI/MainWindow.axaml.cs b/src/XTMF2.GUI/MainWindow.axaml.cs
index 72129a32..ebac183f 100644
--- a/src/XTMF2.GUI/MainWindow.axaml.cs
+++ b/src/XTMF2.GUI/MainWindow.axaml.cs
@@ -38,12 +38,15 @@ You should have received a copy of the GNU General Public License
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.ComponentModel;
+using System.IO;
 using System.Linq;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using XTMF2;
 using XTMF2.AI;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
 using XTMF2.Editing;
 using XTMF2.GUI.AI;
 using XTMF2.GUI.Controls;
@@ -63,6 +66,7 @@ public partial class MainWindow : Window
     private bool _documentCloseInProgress;
     private SettingsWindow? _settingsWindow;
     private RunServersWindow? _runServersWindow;
+    private RunServerActivityWindow? _runServerActivityWindow;
     private readonly HttpClient _aiHttpClient = new();
     private readonly AiProviderRegistry _aiProviders = new();
 
@@ -312,7 +316,10 @@ public void InitializeWithRuntime(XTMFRuntime runtime, RunController? runControl
 
         // Add the Runs tab so it is always visible.
         if (_runController is not null)
+        {
             Documents.Add(_runController.RunsViewModel);
+            _runController.EnableAutomaticRecoveredRunBinding(user);
+        }
 
         // Add the Projects tab as the permanent first document
         Documents.Add(new ProjectsViewModel(runtime, user));
@@ -421,6 +428,43 @@ public void FocusEditorTab(ModelSystemEditorViewModel editorVm)
         ActivateDocument(editorVm);
     }
 
+    public bool BindRecoveredRunToActiveModelSystem(string runId, out string? error)
+    {
+        if (_activeEditorVm is null || _currentUser is null || _runController is null)
+        {
+            error = "This run could not be matched automatically. Open its model system, make it active, and bind it manually.";
+            return false;
+        }
+        return _runController.BindRecoveredRemoteRun(runId, _activeEditorVm.Session,
+            _activeEditorVm.User, out error);
+    }
+
+    public bool RetryRemoteRunReceipt(string runId, out string? error)
+    {
+        if (_runController is null)
+        {
+            error = "The run controller is unavailable.";
+            return false;
+        }
+        return _runController.RetryRemoteRunReceipt(runId, out error);
+    }
+
+    public bool RequestRemoteRunOutputTransfer(string runId, out string? error)
+    {
+        if (_runController is null)
+        {
+            error = "The run controller is unavailable.";
+            return false;
+        }
+        return _runController.RequestRemoteRunOutputTransfer(runId, out error);
+    }
+
+    public Task<RemoteRunDeletionResponse> DeleteRemoteRunAsync(string runId)
+        => _runController is null
+            ? Task.FromResult(new RemoteRunDeletionResponse(string.Empty, runId, false,
+                "The run controller is unavailable."))
+            : _runController.DeleteRemoteRunAsync(runId);
+
     /// <summary>
     /// Switches the active document to the Runs tab.
     /// </summary>
@@ -479,6 +523,19 @@ private void Settings_Click(object? sender, RoutedEventArgs e)
         }
     }
 
+    private void RunServerActivity_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_runServerActivityWindow is not null && _runServerActivityWindow.IsVisible)
+        {
+            _runServerActivityWindow.Activate();
+            return;
+        }
+
+        _runServerActivityWindow = new RunServerActivityWindow(_runController);
+        _runServerActivityWindow.Closed += (_, _) => _runServerActivityWindow = null;
+        _runServerActivityWindow.Show(this);
+    }
+
     private void ShowRunServersWindow()
     {
         var settingsOwner = _settingsWindow;
@@ -643,6 +700,43 @@ protected override async void OnClosing(WindowClosingEventArgs e)
                     return;
             }
 
+            if (_runController is not null)
+            {
+                IReadOnlyList<RunServerActivity> localActivities;
+                try
+                {
+                    localActivities = await _runController.QueryLocalRunServerActivityAsync();
+                }
+                catch (Exception exception) when (exception is IOException or OperationCanceledException or
+                    ObjectDisposedException or InvalidOperationException)
+                {
+                    var confirmation = new ConfirmDialog("Local RunServer Status Unavailable",
+                        $"The local RunServer's workload could not be checked ({exception.Message}). " +
+                        "Closing may terminate a running model system. Close the program anyway?");
+                    await confirmation.ShowDialog(this);
+                    if (!confirmation.Result)
+                        return;
+                    localActivities = Array.Empty<RunServerActivity>();
+                }
+
+                if (localActivities.Count > 0)
+                {
+                    var runningCount = localActivities.Count(activity => activity.State == RunServerActivityState.Running);
+                    var queuedCount = localActivities.Count(activity => activity.State == RunServerActivityState.Queued);
+                    var workload = new List<string>();
+                    if (runningCount > 0)
+                        workload.Add($"{runningCount} running");
+                    if (queuedCount > 0)
+                        workload.Add($"{queuedCount} queued");
+                    var confirmation = new ConfirmDialog("Local RunServer Is Busy",
+                        $"The local RunServer has {string.Join(" and ", workload)} model system(s). " +
+                        "Closing the program will stop the Local RunServer and terminate this work. Close anyway?");
+                    await confirmation.ShowDialog(this);
+                    if (!confirmation.Result)
+                        return;
+                }
+            }
+
             _allowDocumentClose = true;
             _allowClose = true;
             Close();
diff --git a/src/XTMF2.GUI/Properties/RunServerEndpoint.cs b/src/XTMF2.GUI/Properties/RunServerEndpoint.cs
index 58fc97c6..b965d523 100644
--- a/src/XTMF2.GUI/Properties/RunServerEndpoint.cs
+++ b/src/XTMF2.GUI/Properties/RunServerEndpoint.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 
 namespace XTMF2.GUI.Properties;
 
@@ -15,6 +16,7 @@ public sealed class RunServerEndpoint
     public bool IsLocal { get; set; }
     public string Token { get; set; } = string.Empty;
     public string CertificateFingerprint { get; set; } = string.Empty;
+    public Dictionary<string, string> BasicParameterOverrides { get; set; } = new(StringComparer.OrdinalIgnoreCase);
 
     public static RunServerEndpoint CreateLocal()
         => new()
@@ -26,7 +28,8 @@ public static RunServerEndpoint CreateLocal()
             Port = 0,
             IsLocal = true,
             Token = string.Empty,
-            CertificateFingerprint = string.Empty
+            CertificateFingerprint = string.Empty,
+            BasicParameterOverrides = new(StringComparer.OrdinalIgnoreCase)
         };
 
     public RunServerEndpoint Clone()
@@ -39,6 +42,8 @@ public RunServerEndpoint Clone()
             Port = Port,
             IsLocal = IsLocal,
             Token = Token,
-            CertificateFingerprint = CertificateFingerprint
+            CertificateFingerprint = CertificateFingerprint,
+            BasicParameterOverrides = new Dictionary<string, string>(BasicParameterOverrides ?? new Dictionary<string, string>(),
+                StringComparer.OrdinalIgnoreCase)
         };
 }
diff --git a/src/XTMF2.GUI/Properties/Settings.cs b/src/XTMF2.GUI/Properties/Settings.cs
index 9dac72fa..b046fb41 100644
--- a/src/XTMF2.GUI/Properties/Settings.cs
+++ b/src/XTMF2.GUI/Properties/Settings.cs
@@ -149,6 +149,8 @@ private static List<RunServerEndpoint> NormalizeRunServers(IEnumerable<RunServer
                 if (endpoint is null || string.IsNullOrWhiteSpace(endpoint.Address) || endpoint.Port is < 0 or > 65535)
                     continue;
 
+                endpoint.BasicParameterOverrides ??= new(StringComparer.OrdinalIgnoreCase);
+
                 if (normalized.Any(existing => existing.Id == endpoint.Id))
                     continue;
 
diff --git a/src/XTMF2.GUI/RemoteRunOutputPaths.cs b/src/XTMF2.GUI/RemoteRunOutputPaths.cs
new file mode 100644
index 00000000..f84fae78
--- /dev/null
+++ b/src/XTMF2.GUI/RemoteRunOutputPaths.cs
@@ -0,0 +1,16 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace XTMF2.GUI;
+
+internal static class RemoteRunOutputPaths
+{
+    public static string GetLocalDirectory(string runId)
+    {
+        var key = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(runId)));
+        return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+            "XTMF2", "GUI", "RemoteRunOutputs", key);
+    }
+}
\ No newline at end of file
diff --git a/src/XTMF2.GUI/RunController.cs b/src/XTMF2.GUI/RunController.cs
index ad9a3c61..7ffedc28 100644
--- a/src/XTMF2.GUI/RunController.cs
+++ b/src/XTMF2.GUI/RunController.cs
@@ -22,17 +22,27 @@ You should have received a copy of the GNU General Public License
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.IO.Compression;
+using System.Security.Cryptography;
 using System.Threading;
 using System.Threading.Tasks;
 using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
+using XTMF2.Controllers;
 using XTMF2.Editing;
 using XTMF2.GUI.ViewModels;
 using XTMF2.GUI.Properties;
+using XTMF2.ModelSystemConstruct;
 using System.Linq;
 
 
 namespace XTMF2.GUI;
 
+public sealed record RunServerActivityServerSnapshot(
+    RunServerEndpoint Endpoint,
+    RunServerConnectionState ConnectionState,
+    string? Error,
+    IReadOnlyList<RunServerActivity> Activities);
+
 /// <summary>
 /// Used to control XTMF from the GUI. This is a separate class from XTMFRuntime 
 /// to avoid circular dependencies between the GUI and the core runtime.
@@ -67,6 +77,18 @@ public class RunController : IDisposable
     private readonly Dictionary<string, (ModelSystemSession Session, User User)> _sessionsByRunId = new();
     private readonly Dictionary<string, HostBus> _hostBusesByRunId = new();
     private readonly Dictionary<string, string> _runDirectoriesByRunId = new();
+    private readonly Dictionary<string, IReadOnlyList<(int nodeIndex, string name, double min, double max)>>
+        _remoteEstimationMetadata = new();
+    private readonly Dictionary<string, IReadOnlyDictionary<string, SharedEstimationWorkerEndpoint>>
+        _remoteWorkerEndpointsByRunId = new();
+    private readonly HashSet<string> _disconnectedRunServerIds = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, RemoteRunSnapshot> _recoveredRemoteRuns = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, SharedEstimationJobSnapshot> _recoveredSharedEstimationRuns = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, HostBus> _remoteRunBusesByRunId = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, (HostBus HostBus, string TargetDirectory)> _pendingRemoteReceipts = new(StringComparer.Ordinal);
+    private readonly SharedEstimationCompletionGate _remoteCompletionGate = new();
+    private readonly HashSet<string> _automaticBindingAttempts = new(StringComparer.Ordinal);
+    private User? _recoveryUser;
 
     /// <summary>
     /// Fires when an estimation or calibration run completes and has results ready to be
@@ -149,7 +171,13 @@ private static bool InitializeInSeparateProcess(XTMFRuntime runtime, out RunCont
                 RedirectStandardError = true
             };
             client = new() { StartInfo = startInfo, EnableRaisingEvents = true };
+            client.ErrorDataReceived += (_, eventArgs) =>
+            {
+                if (eventArgs.Data is not null)
+                    Debug.WriteLine($"[Local RunServer] {eventArgs.Data}");
+            };
             client.Start();
+            client.BeginErrorReadLine();
             var listenLine = client.StandardOutput.ReadLine();
             if (!TryParseListeningPort(listenLine, out var hostPort))
             {
@@ -193,8 +221,23 @@ private void OnClientFinishedModelSystem(object? sender, string runID)
     private void OnClientRunArtifactsReceived(object? sender, HostBus.RunArtifactsReceivedEventArgs args)
     {
         string? targetDirectory;
+        var hostBus = sender as HostBus;
         lock (_sessionsByRunId)
+        {
             _runDirectoriesByRunId.TryGetValue(args.RunId, out targetDirectory);
+            if (targetDirectory is null && hostBus is not null &&
+                _remoteRunBusesByRunId.TryGetValue(args.RunId, out var remoteRunBus) &&
+                ReferenceEquals(remoteRunBus, hostBus))
+            {
+                targetDirectory = RemoteRunOutputPaths.GetLocalDirectory(args.RunId);
+            }
+        }
+
+        if (targetDirectory is null && hostBus is not null &&
+            _connections.TryGetEndpoint(hostBus, out var endpoint) && endpoint is { IsLocal: false })
+        {
+            targetDirectory = RemoteRunOutputPaths.GetLocalDirectory(args.RunId);
+        }
 
         if (targetDirectory is null)
         {
@@ -241,10 +284,66 @@ private void OnClientReportedStatus(object sender, string runID, string status)
     }
 
     private void OnClientIterationProgressAvailable(
-        object sender, string runID, int iteration, double fitness,
+        object sender, string runID, int iteration, double fitness, int fitnessTestsThisIteration,
         IReadOnlyList<(int nodeIndex, double value)> values)
     {
-        RunsViewModel.NotifyIterationProgress(runID, iteration, fitness, values);
+        RunsViewModel.NotifyIterationProgress(runID, iteration, fitness, fitnessTestsThisIteration, values);
+    }
+
+    private void OnSharedEstimationProgress(object? sender, SharedEstimationProgress progress)
+    {
+        RunsViewModel.NotifySharedEstimationProgress(progress);
+    }
+
+    private void OnSharedEstimationStatus(object? sender, SharedEstimationStatus status)
+    {
+        RunsViewModel.NotifyStatus(status.RunId, status.Message);
+    }
+
+    private void OnSharedEstimationWorkerControlAcknowledged(
+        object? sender, SharedEstimationWorkerControlAcknowledgement acknowledgement)
+    {
+        RunsViewModel.NotifyRemoteWorkerAcknowledgement(acknowledgement);
+    }
+
+    private void OnSharedEstimationCompleted(object? sender, SharedEstimationCompletion completion)
+    {
+        RunsViewModel.NotifyRecoveredSharedEstimationCompletion(completion);
+        ModelSystemSession? session = null;
+        User? user = null;
+        IReadOnlyList<(int nodeIndex, string name, double min, double max)>? metadata = null;
+        SharedEstimationCompletion? acceptedCompletion;
+        lock (_sessionsByRunId)
+        {
+            bool hasMetadata = _remoteEstimationMetadata.TryGetValue(completion.RunId, out metadata);
+            bool hasSession = _sessionsByRunId.TryGetValue(completion.RunId, out var entry);
+            if (hasSession)
+            {
+                session = entry.Session;
+                user = entry.User;
+            }
+            bool hasContext = hasMetadata && hasSession;
+            if (!_remoteCompletionGate.TryReceive(completion, hasContext, out acceptedCompletion) ||
+                acceptedCompletion is null)
+                return;
+        }
+        if (session is null || user is null || metadata is null)
+            return;
+        if (!completion.Succeeded)
+        {
+            RunsViewModel.NotifyError(completion.RunId,
+                completion.FailureReason ?? "Remote estimation failed.", String.Empty, null, null);
+            return;
+        }
+
+        if (metadata is null || completion.BestParameters.Count != metadata.Count)
+            return;
+        var results = metadata.Select((item, index) => (item.nodeIndex, completion.BestParameters[index])).ToArray();
+        RunsViewModel.NotifyOptimizationResults(completion.RunId, session, user, results);
+        OptimizationResultsAvailable?.Invoke(completion.RunId, session, results);
+        RunsViewModel.NotifyFinished(completion.RunId,
+            $"[Estimation] converged after {completion.TotalEvaluations} fitness test(s) " +
+            $"in {completion.Iterations} iteration(s). Best fitness = {completion.BestFitness:G6}.");
     }
 
     private void OnClientOptimizationResultsAvailable(
@@ -313,6 +412,338 @@ public bool SendEstimationRun(
         [NotNullWhen(false)] out CommandError? error)
         => SendRun(projectSession, msSession, user, startToExecute, runName, RunMode.Estimation, endpointId, out id, out error);
 
+    /// <summary>
+    /// Starts an estimation run across the selected connected RunServers.
+    /// </summary>
+    public bool SendSharedEstimationRun(
+        Project projectSession,
+        ModelSystemSession msSession,
+        User user,
+        string startToExecute,
+        string runName,
+        IReadOnlyList<string> workerEndpointIds,
+        IReadOnlyDictionary<string, IReadOnlyDictionary<int, string>>? basicParameterOverridesByWorker,
+        [NotNullWhen(true)] out string? id,
+        [NotNullWhen(false)] out CommandError? error)
+    {
+        id = null;
+        error = null;
+        if (String.IsNullOrWhiteSpace(projectSession.ProjectDirectory))
+        {
+            error = new CommandError("Project directory is not set.");
+            return false;
+        }
+        if (workerEndpointIds.Count == 0)
+        {
+            error = new CommandError("At least one shared-estimation worker is required.");
+            return false;
+        }
+
+        var modelSystem = msSession.ModelSystem;
+        var enabledEntries = modelSystem.EstimationGroups
+            .Where(group => group.IsEnabled)
+            .SelectMany(group => group.Parameters)
+            .Where(entry => entry.IsEnabled)
+            .ToArray();
+        var metadata = msSession.GetOptimizationParameterMeta(RunMode.Estimation);
+        if (enabledEntries.Length == 0 || enabledEntries.Length != metadata.Count)
+        {
+            error = new CommandError("Estimation requires at least one enabled estimation parameter.");
+            return false;
+        }
+        if (modelSystem.EstimationFitnessNode is null)
+        {
+            error = new CommandError("Estimation requires a fitness node.");
+            return false;
+        }
+
+        var parameterEntries = enabledEntries
+            .Select((entry, index) => (entry, nodeIndex: metadata[index].nodeIndex))
+            .ToArray();
+
+        var runId = Guid.NewGuid().ToString();
+        var runDirectory = Path.Combine(projectSession.ProjectDirectory, "runs", runName);
+        using var modelStream = new MemoryStream();
+        if (!msSession.Save(out error, modelStream))
+            return false;
+
+        var pool = new SharedEstimationWorkerPool();
+        foreach (var endpointId in workerEndpointIds.Distinct(StringComparer.Ordinal))
+        {
+            if (!_connections.TryGet(endpointId, out var hostBus) || hostBus is null)
+            {
+                pool.Dispose();
+                error = new CommandError($"RunServer '{endpointId}' is not connected.");
+                return false;
+            }
+            if (!pool.AddExistingWorker(endpointId, endpointId, hostBus, out var workerError))
+            {
+                pool.Dispose();
+                error = new CommandError(workerError ?? $"Unable to add RunServer '{endpointId}'.");
+                return false;
+            }
+        }
+
+        var lower = parameterEntries.Select(item => item.entry.Min).ToArray();
+        var upper = parameterEntries.Select(item => item.entry.Max).ToArray();
+        var initial = parameterEntries.Select(item => item.entry.NullHypothesis).ToArray();
+        var algorithm = modelSystem.EstimationAlgorithmConfig.CreateAlgorithm(
+            parameterEntries.Length, lower, upper, initial,
+            modelSystem.EstimationObjective == EstimationObjective.Maximize);
+        var request = new SharedEstimationRunRequest(
+            runId, runDirectory, startToExecute, modelStream.ToArray(),
+            ProjectId: msSession.Project.Id,
+            ModelSystemId: msSession.ModelSystemHeader.Id,
+            OwnerUserId: user.UserId);
+        if (!pool.StartRun(request, out var startError, basicParameterOverridesByWorker))
+        {
+            pool.Dispose();
+            error = new CommandError(startError ?? "Unable to start shared estimation.");
+            return false;
+        }
+
+        var serverLabel = $"Shared ({workerEndpointIds.Count} workers)";
+        var runViewModel = RunsViewModel.AddRun(runId, runName, runDirectory, serverLabel, msSession, user);
+        var cancellation = new CancellationTokenSource();
+        runViewModel.SetRunMode(RunMode.Estimation, metadata, () =>
+        {
+            cancellation.Cancel();
+            pool.CancelRun("Cancelled by user.");
+        });
+        lock (_sessionsByRunId)
+            _sessionsByRunId[runId] = (msSession, user);
+
+        _ = Task.Run(() =>
+        {
+            try
+            {
+                var runner = new SharedEstimationCoordinatorRun(runId, algorithm, pool.Coordinator,
+                    modelSystem.EstimationObjective == EstimationObjective.Maximize,
+                    Path.Combine(runDirectory, "estimation_report.csv"),
+                    metadata.Select(item => item.name).ToArray());
+                var completion = runner.Execute(
+                    progress: progress => RunsViewModel.NotifySharedEstimationProgress(progress),
+                    cancellationToken: cancellation.Token);
+                if (!completion.Succeeded)
+                {
+                    RunsViewModel.NotifyError(runId, completion.FailureReason ?? "Shared estimation failed.",
+                        String.Empty, null, null);
+                    return;
+                }
+
+                var results = parameterEntries
+                    .Select((item, index) => (nodeIndex: item.nodeIndex, value: completion.BestParameters[index]))
+                    .ToArray();
+                RunsViewModel.NotifyOptimizationResults(runId, msSession, user, results);
+                OptimizationResultsAvailable?.Invoke(runId, msSession, results);
+                RunsViewModel.NotifyFinished(runId,
+                    $"[Estimation] converged after {completion.TotalEvaluations} fitness test(s) " +
+                    $"in {completion.Iterations} iteration(s). Best fitness = {completion.BestFitness:G6}.");
+            }
+            finally
+            {
+                cancellation.Dispose();
+                pool.Dispose();
+                lock (_sessionsByRunId)
+                    _sessionsByRunId.Remove(runId);
+            }
+        });
+
+        id = runId;
+        return true;
+    }
+
+    public bool SendRemoteSharedEstimationRun(
+        Project projectSession,
+        ModelSystemSession msSession,
+        User user,
+        string startToExecute,
+        string runName,
+        string orchestratorEndpointId,
+        IReadOnlyList<string> workerEndpointIds,
+        IReadOnlyDictionary<string, IReadOnlyDictionary<int, string>>? basicParameterOverridesByWorker,
+        IReadOnlyDictionary<string, int>? concurrentRunsByEndpoint,
+        [NotNullWhen(true)] out string? id,
+        [NotNullWhen(false)] out CommandError? error)
+    {
+        id = null;
+        error = null;
+        if (!_connections.TryGet(orchestratorEndpointId, out var orchestrator) || orchestrator is null)
+        {
+            error = new CommandError($"RunServer '{orchestratorEndpointId}' is not connected.");
+            return false;
+        }
+        var modelSystem = msSession.ModelSystem;
+        var enabledEntries = modelSystem.EstimationGroups
+            .Where(group => group.IsEnabled)
+            .SelectMany(group => group.Parameters)
+            .Where(entry => entry.IsEnabled)
+            .ToArray();
+        var metadata = msSession.GetOptimizationParameterMeta(RunMode.Estimation);
+        if (enabledEntries.Length == 0 || enabledEntries.Length != metadata.Count)
+        {
+            error = new CommandError("Estimation requires at least one enabled estimation parameter.");
+            return false;
+        }
+        if (modelSystem.EstimationFitnessNode is null)
+        {
+            error = new CommandError("Estimation requires a fitness node.");
+            return false;
+        }
+
+        var endpoints = GetConnectedRunServers()
+            .Where(endpoint => workerEndpointIds.Contains(endpoint.Id, StringComparer.Ordinal) &&
+                               endpoint.Id != orchestratorEndpointId)
+            .ToArray();
+        var invalidWorker = endpoints.FirstOrDefault(endpoint => endpoint.IsLocal ||
+            string.IsNullOrWhiteSpace(endpoint.Token) ||
+            string.IsNullOrWhiteSpace(endpoint.CertificateFingerprint));
+        if (invalidWorker is not null)
+        {
+            error = new CommandError(endpointError(invalidWorker));
+            return false;
+        }
+
+        static string endpointError(RunServerEndpoint endpoint)
+            => endpoint.IsLocal
+                ? $"Local RunServer '{endpoint.Name}' cannot be used as a worker with a remote coordinator. Select a network RunServer instead."
+                : $"RunServer '{endpoint.Name}' is missing its security token or certificate fingerprint.";
+
+        using var modelStream = new MemoryStream();
+        if (!msSession.Save(out error, modelStream))
+            return false;
+        var entries = enabledEntries
+            .Select((entry, index) => (entry, nodeIndex: metadata[index].nodeIndex))
+            .ToArray();
+        IReadOnlyDictionary<int, string>? coordinatorOverrides = null;
+        if (basicParameterOverridesByWorker is not null)
+            basicParameterOverridesByWorker.TryGetValue(orchestratorEndpointId, out coordinatorOverrides);
+        var request = new SharedEstimationCoordinatorRequest(
+            new SharedEstimationRunRequest(Guid.NewGuid().ToString(),
+                Path.Combine(projectSession.ProjectDirectory!, "runs", runName),
+                startToExecute, modelStream.ToArray(), coordinatorOverrides,
+                msSession.Project.Id, msSession.ModelSystemHeader.Id, user.UserId),
+            endpoints.Select(endpoint => new SharedEstimationWorkerEndpoint(
+                endpoint.Id, endpoint.Id, endpoint.Address, endpoint.Port, endpoint.Token,
+                endpoint.CertificateFingerprint,
+                basicParameterOverridesByWorker is not null &&
+                basicParameterOverridesByWorker.TryGetValue(endpoint.Id, out var overrides)
+                    ? overrides
+                    : null,
+                concurrentRunsByEndpoint is not null &&
+                concurrentRunsByEndpoint.TryGetValue(endpoint.Id, out var concurrentRuns)
+                    ? concurrentRuns
+                    : 1)).ToArray(),
+            modelSystem.EstimationAlgorithmConfig.AlgorithmId,
+            modelSystem.EstimationAlgorithmConfig.GetParameters(),
+            entries.Select(item => item.entry.Min).ToArray(),
+            entries.Select(item => item.entry.Max).ToArray(),
+            entries.Select(item => item.entry.NullHypothesis).ToArray(),
+            modelSystem.EstimationObjective == EstimationObjective.Maximize,
+            UseCoordinatorAsWorker: true,
+            Parameters: metadata.Select(item => new SharedEstimationParameterMetadata(
+                item.nodeIndex, item.name, item.min, item.max)).ToArray(),
+            CoordinatorConcurrentRuns: concurrentRunsByEndpoint is not null &&
+                concurrentRunsByEndpoint.TryGetValue(orchestratorEndpointId, out var coordinatorConcurrentRuns)
+                    ? coordinatorConcurrentRuns
+                    : 1);
+
+        if (!orchestrator.StartRemoteSharedEstimation(request, out error))
+            return false;
+
+        id = request.Run.RunId;
+        var submittedRunId = request.Run.RunId;
+        var runDirectory = request.Run.WorkingDirectory;
+        var runViewModel = RunsViewModel.AddRun(id, runName, runDirectory,
+            $"{orchestratorEndpointId} (coordinator + {endpoints.Length} remote worker(s))", msSession, user);
+        runViewModel.SetRemoteRunTracking(orchestratorEndpointId != LocalEndpointId);
+        runViewModel.SetRunMode(RunMode.Estimation, metadata, () =>
+        {
+            orchestrator.CancelSharedEstimation(submittedRunId, "Cancelled by user.", out _);
+        });
+        var initialWorkers = request.Workers.ToDictionary(worker => worker.WorkerId,
+            worker => worker, StringComparer.Ordinal);
+        var availableWorkers = GetConnectedRunServers()
+            .Where(endpoint => endpoint.Id != orchestratorEndpointId)
+            .Select(endpoint => initialWorkers.TryGetValue(endpoint.Id, out var initial)
+                ? initial
+                : new SharedEstimationWorkerEndpoint(endpoint.Id, endpoint.Id, endpoint.Address,
+                    endpoint.Port, endpoint.Token, endpoint.CertificateFingerprint))
+            .ToArray();
+        lock (_sessionsByRunId)
+        {
+            _hostBusesByRunId[submittedRunId] = orchestrator;
+            _remoteWorkerEndpointsByRunId[submittedRunId] = availableWorkers.ToDictionary(worker => worker.WorkerId,
+                worker => worker, StringComparer.Ordinal);
+        }
+        var workerRows = availableWorkers.Select(ToRunServerEndpoint).ToList();
+        var configuredWorkerCounts = availableWorkers.ToDictionary(worker => worker.WorkerId,
+            worker => worker.ConcurrentRuns, StringComparer.Ordinal);
+        if (request.UseCoordinatorAsWorker)
+        {
+            var coordinatorEndpoint = GetConnectedRunServers()
+                .FirstOrDefault(candidate => candidate.Id == orchestratorEndpointId);
+            workerRows.Add(ToCoordinatorRunServerEndpoint(coordinatorEndpoint, orchestratorEndpointId));
+            configuredWorkerCounts[RemoteEstimationWorkerViewModel.CoordinatorWorkerId] =
+                request.CoordinatorConcurrentRuns;
+        }
+        runViewModel.SetRemoteEstimationWorkers(
+            workerRows,
+            initialWorkers.Keys.ToArray(),
+            workerId => ChangeRemoteEstimationWorker(submittedRunId, workerId, add: true),
+            workerId => ChangeRemoteEstimationWorker(submittedRunId, workerId, add: false),
+            configuredWorkerCounts);
+        SharedEstimationCompletion? pendingCompletion;
+        lock (_sessionsByRunId)
+        {
+            _sessionsByRunId[id] = (msSession, user);
+            _remoteEstimationMetadata[id] = metadata;
+            pendingCompletion = _remoteCompletionGate.MarkReady(id);
+        }
+        if (pendingCompletion is not null)
+            OnSharedEstimationCompleted(orchestrator, pendingCompletion);
+        return true;
+    }
+
+    private static RunServerEndpoint ToRunServerEndpoint(SharedEstimationWorkerEndpoint endpoint)
+        => new()
+        {
+            Id = endpoint.EndpointId,
+            Name = Settings.Default.RunServers.FirstOrDefault(candidate =>
+                string.Equals(candidate.Id, endpoint.EndpointId, StringComparison.Ordinal))?.Name
+                ?? endpoint.EndpointId,
+            Address = endpoint.Address,
+            Port = endpoint.Port,
+            Token = endpoint.Token,
+            CertificateFingerprint = endpoint.CertificateFingerprint
+        };
+
+    private static RunServerEndpoint ToCoordinatorRunServerEndpoint(
+        RunServerEndpoint? endpoint, string fallbackName)
+        => new()
+        {
+            Id = RemoteEstimationWorkerViewModel.CoordinatorWorkerId,
+            Name = $"Coordinator ({endpoint?.Name ?? fallbackName})",
+            Address = endpoint?.Address ?? fallbackName,
+            Port = endpoint?.Port ?? 0,
+            IsLocal = endpoint?.IsLocal ?? false
+        };
+
+    private string? ChangeRemoteEstimationWorker(string runId, string workerId, bool add)
+    {
+        lock (_sessionsByRunId)
+        {
+            if (!_hostBusesByRunId.TryGetValue(runId, out var bus) ||
+                !_remoteWorkerEndpointsByRunId.TryGetValue(runId, out var workers) ||
+                !workers.TryGetValue(workerId, out var worker))
+                return "The remote estimation connection or worker is unavailable.";
+            var sent = add
+                ? bus.AddRemoteEstimationWorker(runId, worker, out var error)
+                : bus.RemoveRemoteEstimationWorker(runId, worker, out error);
+            return sent ? null : error?.Message ?? "Unable to send the worker change.";
+        }
+    }
+
     /// <summary>
     /// Sends a calibration run (proportional-update loop) to the client process.
     /// </summary>
@@ -379,7 +810,9 @@ private bool SendRun(
                     runViewModel = RunsViewModel.AddRun(runId, runName, runDirectory, serverLabel, msSession, user);
                 },
                 out id,
-                out error))
+                out error,
+                runName,
+                user.UserId))
         {
             return false;
         }
@@ -388,7 +821,10 @@ private bool SendRun(
             _sessionsByRunId[id] = (msSession, user);
             _hostBusesByRunId[id] = hostBus;
             _runDirectoriesByRunId[id] = runDirectory;
+            if (endpointId != LocalEndpointId)
+                _remoteRunBusesByRunId[id] = hostBus;
         }
+        runViewModel?.SetRemoteRunTracking(endpointId != LocalEndpointId);
         if (runMode != RunMode.Normal)
         {
             // Extract parameter metadata so the progress dialog can show names/bounds.
@@ -417,7 +853,7 @@ private RunController(XTMFRuntime runtime, HostBus hostBus, Process? runServerPr
         _hostBus = hostBus;
         _runServerProcess = runServerProcess;
         _connections = new RunServerConnectionManager();
-        _connections.StateChanged += state => RunServerStateChanged?.Invoke(state);
+        _connections.StateChanged += OnRunServerConnectionStateChanged;
         _connections.ConnectionAvailable += SubscribeToHostBus;
         _connections.AddConnection(RunServerEndpoint.CreateLocal(), hostBus, out _);
     }
@@ -471,6 +907,43 @@ private void ConnectConfiguredRunServers()
     public void RefreshConfiguredRunServers()
         => ConnectConfiguredRunServers();
 
+    private void OnRunServerConnectionStateChanged(RunServerConnectionInfo state)
+    {
+        RunServerStateChanged?.Invoke(state);
+        if (state.Endpoint.IsLocal)
+            return;
+
+        if (state.State == RunServerConnectionState.Disconnected)
+        {
+            lock (_sessionsByRunId)
+                _disconnectedRunServerIds.Add(state.Endpoint.Id);
+            foreach (var runId in GetEstimationRunsForWorker(state.Endpoint.Id))
+                RunsViewModel.NotifyRemoteWorkerDisconnected(runId, state.Endpoint.Id);
+            return;
+        }
+
+        if (state.State != RunServerConnectionState.Available)
+            return;
+
+        bool wasDisconnected;
+        lock (_sessionsByRunId)
+            wasDisconnected = _disconnectedRunServerIds.Remove(state.Endpoint.Id);
+        if (!wasDisconnected)
+            return;
+
+        foreach (var runId in GetEstimationRunsForWorker(state.Endpoint.Id))
+            RunsViewModel.ReconnectRemoteWorker(runId, state.Endpoint.Id);
+    }
+
+    private string[] GetEstimationRunsForWorker(string endpointId)
+    {
+        lock (_sessionsByRunId)
+            return _remoteWorkerEndpointsByRunId
+                .Where(entry => entry.Value.ContainsKey(endpointId))
+                .Select(entry => entry.Key)
+                .ToArray();
+    }
+
     public bool TryGetRunServer(string endpointId, out HostBus? hostBus)
         => _connections.TryGet(endpointId, out hostBus);
 
@@ -485,6 +958,107 @@ public IReadOnlyList<RunServerEndpoint> GetConnectedRunServers()
     public IReadOnlyList<RunServerConnectionInfo> GetRunServerStates()
         => _connections.GetStates();
 
+    public async Task<IReadOnlyList<RunServerActivityServerSnapshot>> QueryRunServerActivityAsync(
+        CancellationToken cancellationToken = default)
+    {
+        var states = _connections.GetStates();
+        var requests = states.Select(async state =>
+        {
+            if (state.State != RunServerConnectionState.Available ||
+                !_connections.TryGet(state.Endpoint.Id, out var hostBus) || hostBus is null)
+            {
+                return new RunServerActivityServerSnapshot(state.Endpoint, state.State,
+                    state.Error ?? (state.State == RunServerConnectionState.Connecting ? "Connecting" : "Not connected"),
+                    Array.Empty<RunServerActivity>());
+            }
+
+            try
+            {
+                var response = await hostBus.QueryServerActivityAsync(cancellationToken: cancellationToken)
+                    .ConfigureAwait(false);
+                return new RunServerActivityServerSnapshot(state.Endpoint, state.State, null, response.Activities);
+            }
+            catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+            {
+                return new RunServerActivityServerSnapshot(state.Endpoint, state.State,
+                    "Timed out waiting for RunServer activity.", Array.Empty<RunServerActivity>());
+            }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+            {
+                throw;
+            }
+            catch (Exception exception)
+            {
+                return new RunServerActivityServerSnapshot(state.Endpoint, state.State,
+                    exception.Message, Array.Empty<RunServerActivity>());
+            }
+        }).ToArray();
+
+        return await Task.WhenAll(requests).ConfigureAwait(false);
+    }
+
+    public async Task<IReadOnlyList<RunServerActivity>> QueryLocalRunServerActivityAsync(
+        CancellationToken cancellationToken = default)
+    {
+        if (!_connections.TryGet(LocalEndpointId, out var hostBus) || hostBus is null)
+            throw new IOException("The local RunServer is not connected.");
+
+        var response = await hostBus.QueryServerActivityAsync(cancellationToken: cancellationToken)
+            .ConfigureAwait(false);
+        return response.Activities;
+    }
+
+    public async Task<RunServerDrainStatus> BeginRunServerDeploymentDrainAsync(
+        string endpointId, CancellationToken cancellationToken = default)
+    {
+        if (!_connections.TryGet(endpointId, out var hostBus) || hostBus is null)
+            throw new IOException($"RunServer '{endpointId}' is not connected.");
+        return await hostBus.BeginDeploymentDrainAsync(cancellationToken: cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    public async Task<RunServerDrainStatus> StageLocalRunServerDeploymentAsync(
+        string endpointId, IReadOnlyList<string> selectedModules,
+        CancellationToken cancellationToken = default)
+    {
+        if (!_connections.TryGet(endpointId, out var hostBus) || hostBus is null)
+            throw new IOException($"RunServer '{endpointId}' is not connected.");
+
+        var archive = RunServerDeploymentBuilder.CreateLocalArchive(selectedModules);
+        var status = await hostBus.BeginDeploymentDrainAsync(cancellationToken: cancellationToken)
+            .ConfigureAwait(false);
+        if (status.State != RunServerDrainState.Idle)
+            return status;
+        var staged = await hostBus.SendDeploymentArchiveAsync(status.RequestId, archive.Content,
+            cancellationToken: cancellationToken).ConfigureAwait(false);
+        if (staged.State != RunServerDrainState.Staged)
+            return staged;
+        if (!hostBus.ActivateDeployment(staged.RequestId, out var error))
+            throw new IOException(error?.Message ?? "Unable to activate the staged RunServer deployment.");
+        return staged;
+    }
+
+    public bool KillRunServerActivity(string endpointId, RunServerActivity activity, out string? error)
+    {
+        ArgumentNullException.ThrowIfNull(activity);
+        if (!_connections.TryGet(endpointId, out var hostBus) || hostBus is null)
+        {
+            error = $"RunServer '{endpointId}' is not connected.";
+            return false;
+        }
+
+        if (activity.Kind is "Shared estimation coordinator" or "Shared estimation worker")
+        {
+            var sent = hostBus.CancelSharedEstimation(activity.RunId,
+                "Stopped from RunServer Activity window.", out var commandError);
+            error = commandError?.Message;
+            return sent;
+        }
+        var killed = hostBus.KillModelRun(activity.RunId, out var killError);
+        error = killError?.Message;
+        return killed;
+    }
+
     private void SubscribeToHostBus(HostBus hostBus)
     {
         lock (_hostBusSubscriptionLock)
@@ -498,14 +1072,525 @@ private void SubscribeToHostBus(HostBus hostBus)
         hostBus.ClientErrorWhenRunningModelSystem += OnClientErrorWhenRunningModelSystem;
         hostBus.ClientOptimizationResultsAvailable += OnClientOptimizationResultsAvailable;
         hostBus.ClientIterationProgressAvailable += OnClientIterationProgressAvailable;
+        hostBus.SharedEstimationProgressAvailable += OnSharedEstimationProgress;
+        hostBus.SharedEstimationCompleted += OnSharedEstimationCompleted;
+        hostBus.SharedEstimationWorkerControlAcknowledged += OnSharedEstimationWorkerControlAcknowledged;
+        hostBus.SharedEstimationStatusAvailable += OnSharedEstimationStatus;
+        hostBus.SharedEstimationJobSnapshotsAvailable += OnSharedEstimationJobSnapshotsAvailable;
+        hostBus.RemoteRunSnapshotsAvailable += OnRemoteRunSnapshotsAvailable;
+        hostBus.RemoteRunArtifactsAvailable += OnRemoteRunArtifactsAvailable;
         hostBus.ClientRunArtifactsReceived += OnClientRunArtifactsReceived;
         hostBus.Disconnected += OnHostBusDisconnected;
+        hostBus.QuerySharedEstimationJobs(out _);
+        hostBus.QueryRemoteRuns(out _);
+    }
+
+    private void OnSharedEstimationJobSnapshotsAvailable(
+        object? sender, IReadOnlyList<SharedEstimationJobSnapshot> snapshots)
+    {
+        var hostBus = sender as HostBus;
+        var endpoint = hostBus is not null && _connections.TryGetEndpoint(hostBus, out var matchedEndpoint)
+            ? matchedEndpoint
+            : null;
+        foreach (var snapshot in snapshots)
+        {
+            lock (_sessionsByRunId)
+            {
+                _recoveredSharedEstimationRuns[snapshot.RunId] = snapshot;
+                if (hostBus is not null)
+                    _hostBusesByRunId[snapshot.RunId] = hostBus;
+            }
+            if (!IsOwnedByCurrentUser(snapshot.OwnerUserId))
+                continue;
+            var isRemoteRun = endpoint is null || !endpoint.IsLocal;
+            var runServerName = endpoint?.Name ?? "Remote RunServer";
+            var run = RunsViewModel.RestoreSharedEstimationRun(snapshot, runServerName,
+                () => hostBus?.CancelSharedEstimation(snapshot.RunId, "Cancelled by user.", out _));
+            run.SetRemoteRunTracking(isRemoteRun);
+            if (!isRemoteRun)
+                run.SetLocalOutputDirectory(snapshot.WorkingDirectory);
+            var workers = GetConnectedRunServers()
+                .Where(worker => endpoint is null || worker.Id != endpoint.Id)
+                .Select(worker => new SharedEstimationWorkerEndpoint(worker.Id, worker.Id,
+                    worker.Address, worker.Port, worker.Token, worker.CertificateFingerprint))
+                .ToArray();
+            lock (_sessionsByRunId)
+                _remoteWorkerEndpointsByRunId[snapshot.RunId] = workers.ToDictionary(
+                    worker => worker.WorkerId, worker => worker, StringComparer.Ordinal);
+            var workerRows = workers.Select(ToRunServerEndpoint).ToList();
+            if (snapshot.ConfiguredWorkerCounts?.ContainsKey(
+                    RemoteEstimationWorkerViewModel.CoordinatorWorkerId) == true)
+                workerRows.Add(ToCoordinatorRunServerEndpoint(endpoint, runServerName));
+            RunsViewModel.ConfigureRecoveredSharedEstimationWorkers(snapshot.RunId,
+                workerRows,
+                snapshot.ActiveWorkerIds ?? Array.Empty<string>(),
+                workerId => ChangeRemoteEstimationWorker(snapshot.RunId, workerId, add: true),
+                workerId => ChangeRemoteEstimationWorker(snapshot.RunId, workerId, add: false),
+                snapshot.ConfiguredWorkerCounts);
+            if (snapshot.Completion is not null)
+                OnSharedEstimationCompleted(sender, snapshot.Completion);
+            TryAutomaticallyBindRecoveredRun(snapshot.RunId);
+        }
+    }
+
+    private void OnRemoteRunSnapshotsAvailable(object? sender, IReadOnlyList<RemoteRunSnapshot> snapshots)
+    {
+        var hostBus = sender as HostBus;
+        var endpoint = hostBus is not null && _connections.TryGetEndpoint(hostBus, out var matchedEndpoint)
+            ? matchedEndpoint
+            : null;
+        foreach (var snapshot in snapshots)
+        {
+            string? localRunDirectory = null;
+            lock (_sessionsByRunId)
+            {
+                _recoveredRemoteRuns[snapshot.RunId] = snapshot;
+                if (hostBus is not null)
+                    _remoteRunBusesByRunId[snapshot.RunId] = hostBus;
+                if (_sessionsByRunId.ContainsKey(snapshot.RunId))
+                    _runDirectoriesByRunId.TryGetValue(snapshot.RunId, out localRunDirectory);
+            }
+            if (!IsOwnedByCurrentUser(snapshot.OwnerUserId))
+                continue;
+            var isRemoteRun = endpoint is null || !endpoint.IsLocal;
+            var run = RunsViewModel.RestoreRemoteRun(snapshot, endpoint?.Name ?? "Remote RunServer",
+                () => hostBus?.CancelModelRun(snapshot.RunId, out _));
+            run.SetRemoteRunTracking(isRemoteRun);
+            if (isRemoteRun)
+            {
+                RunsViewModel.NotifyRemoteOutputAvailability(snapshot.RunId, snapshot.ArtifactsAvailable);
+            }
+            else
+            {
+                var localOutputDirectory = localRunDirectory ?? snapshot.WorkingDirectory;
+                run.SetLocalOutputDirectory(localOutputDirectory);
+            }
+            if (localRunDirectory is not null && hostBus is not null)
+                ReceiveBoundRemoteCompletion(run, snapshot, hostBus, localRunDirectory);
+            TryAutomaticallyBindRecoveredRun(snapshot.RunId);
+        }
+    }
+
+    public void EnableAutomaticRecoveredRunBinding(User user)
+    {
+        _recoveryUser = user ?? throw new ArgumentNullException(nameof(user));
+        RemoteRunSnapshot[] remoteSnapshots;
+        SharedEstimationJobSnapshot[] sharedSnapshots;
+        lock (_sessionsByRunId)
+        {
+            remoteSnapshots = _recoveredRemoteRuns.Values.ToArray();
+            sharedSnapshots = _recoveredSharedEstimationRuns.Values.ToArray();
+        }
+        foreach (var snapshot in remoteSnapshots)
+        {
+            HostBus? hostBus;
+            lock (_sessionsByRunId)
+                _remoteRunBusesByRunId.TryGetValue(snapshot.RunId, out hostBus);
+            OnRemoteRunSnapshotsAvailable(hostBus, [snapshot]);
+        }
+        foreach (var snapshot in sharedSnapshots)
+        {
+            HostBus? hostBus;
+            lock (_sessionsByRunId)
+                _hostBusesByRunId.TryGetValue(snapshot.RunId, out hostBus);
+            OnSharedEstimationJobSnapshotsAvailable(hostBus, [snapshot]);
+        }
+    }
+
+    private bool IsOwnedByCurrentUser(Guid? ownerUserId)
+        => ownerUserId is not null && _recoveryUser is not null && ownerUserId == _recoveryUser.UserId;
+
+    private void TryAutomaticallyBindRecoveredRun(string runId)
+    {
+        var user = _recoveryUser;
+        if (user is null)
+            return;
+
+        Guid? projectId;
+        Guid? modelSystemId;
+        lock (_sessionsByRunId)
+        {
+            if (!_automaticBindingAttempts.Add(runId))
+                return;
+            if (_recoveredRemoteRuns.TryGetValue(runId, out var remoteSnapshot))
+            {
+                projectId = remoteSnapshot.ProjectId;
+                modelSystemId = remoteSnapshot.ModelSystemId;
+            }
+            else if (_recoveredSharedEstimationRuns.TryGetValue(runId, out var estimationSnapshot))
+            {
+                projectId = estimationSnapshot.ProjectId;
+                modelSystemId = estimationSnapshot.ModelSystemId;
+            }
+            else
+            {
+                return;
+            }
+        }
+        if (projectId is null || modelSystemId is null)
+            return;
+
+        var projects = ProjectController.GetProjects(user).Where(project => project.Id == projectId).ToArray();
+        if (projects.Length != 1)
+            return;
+        var headers = projects[0].ModelSystems.Where(header => header.Id == modelSystemId).ToArray();
+        if (headers.Length != 1 ||
+            !Runtime.ProjectController.GetProjectSession(user, projects[0], out var projectSession, out _))
+            return;
+
+        using (projectSession)
+        {
+            if (!projectSession.EditModelSystem(user, headers[0], out var modelSystemSession, out _, out _) ||
+                modelSystemSession is null)
+                return;
+            if (!BindRecoveredRemoteRun(runId, modelSystemSession, user, out _))
+                modelSystemSession.Dispose();
+        }
+    }
+
+    private void ReceiveBoundRemoteCompletion(RunViewModel run, RemoteRunSnapshot snapshot,
+        HostBus hostBus, string localRunDirectory)
+    {
+        try
+        {
+            PersistRemoteRunSnapshot(snapshot);
+            if (snapshot.ArtifactsAvailable)
+            {
+                lock (_sessionsByRunId)
+                    _pendingRemoteReceipts[snapshot.RunId] = (hostBus, localRunDirectory);
+                RunsViewModel.NotifyRemoteReceiptPending(snapshot.RunId, true);
+                if (!hostBus.RequestRemoteRunArtifacts(snapshot.RunId, out var requestError))
+                    throw new IOException(requestError?.Message ?? "Unable to request remote run artifacts.");
+            }
+            else if (!hostBus.AcknowledgeRemoteRun(snapshot.RunId, out var acknowledgeError))
+            {
+                throw new IOException(acknowledgeError?.Message ?? "Unable to acknowledge the remote completion.");
+            }
+        }
+        catch (Exception exception) when (exception is IOException or UnauthorizedAccessException)
+        {
+            run.AppendStatus($"Remote completion receipt is pending: {exception.Message}");
+        }
+    }
+
+    public bool BindRecoveredRemoteRun(string runId, ModelSystemSession session, User user, out string? error)
+    {
+        RemoteRunSnapshot? snapshot;
+        SharedEstimationJobSnapshot? sharedSnapshot;
+        lock (_sessionsByRunId)
+        {
+            _recoveredRemoteRuns.TryGetValue(runId, out snapshot);
+            _recoveredSharedEstimationRuns.TryGetValue(runId, out sharedSnapshot);
+        }
+        if (snapshot is null && sharedSnapshot is not null)
+            return BindRecoveredSharedEstimationRun(runId, sharedSnapshot, session, user, out error);
+        if (snapshot is null)
+        {
+            error = "The remote run snapshot is no longer available.";
+            return false;
+        }
+
+        using var modelStream = new MemoryStream();
+        if (!session.Save(out var saveError, modelStream))
+        {
+            error = saveError?.Message ?? "Unable to serialize the selected model system.";
+            return false;
+        }
+        var modelHash = Convert.ToHexString(SHA256.HashData(modelStream.ToArray()));
+        if (!string.Equals(modelHash, snapshot.ModelSystemHash, StringComparison.OrdinalIgnoreCase))
+        {
+            error = "The selected model system does not match the model system used by this remote run.";
+            return false;
+        }
+
+        var projectDirectory = session.Project.ProjectDirectory;
+        if (string.IsNullOrWhiteSpace(projectDirectory))
+        {
+            error = "The selected project does not have a local directory.";
+            return false;
+        }
+        var localRunName = Path.GetFileName(snapshot.RunName.Replace('\\', '/').Trim('/'));
+        if (string.IsNullOrWhiteSpace(localRunName) || localRunName is "." or "..")
+            localRunName = runId;
+        var cachedOutputDirectory = RemoteRunOutputPaths.GetLocalDirectory(runId);
+        var targetDirectory = !snapshot.ArtifactsAvailable && Directory.Exists(cachedOutputDirectory)
+            ? cachedOutputDirectory
+            : Path.Combine(projectDirectory, "runs", localRunName);
+        HostBus? hostBus;
+        lock (_sessionsByRunId)
+        {
+            _remoteRunBusesByRunId.TryGetValue(runId, out hostBus);
+            _runDirectoriesByRunId[runId] = targetDirectory;
+            if (hostBus is not null)
+                _pendingRemoteReceipts[runId] = (hostBus, targetDirectory);
+        }
+        if (!RunsViewModel.SetRecoveredRunOutputDirectory(runId, targetDirectory))
+        {
+            error = "The recovered run is not present in the Runs list.";
+            return false;
+        }
+        if (hostBus is null)
+        {
+            error = "The RunServer connection for this run is no longer available.";
+            return false;
+        }
+        try
+        {
+            PersistRemoteRunSnapshot(snapshot);
+        }
+        catch (Exception exception) when (exception is IOException or UnauthorizedAccessException)
+        {
+            error = $"Unable to persist the remote run receipt: {exception.Message}";
+            return false;
+        }
+        if (snapshot.ArtifactsAvailable)
+        {
+            lock (_sessionsByRunId)
+                _pendingRemoteReceipts[runId] = (hostBus, targetDirectory);
+            if (!hostBus.RequestRemoteRunArtifacts(runId, out var requestError))
+            {
+                error = requestError?.Message ?? "Unable to request remote run artifacts.";
+                return false;
+            }
+        }
+        else
+        {
+            if (!hostBus.AcknowledgeRemoteRun(runId, out var acknowledgeError))
+            {
+                error = acknowledgeError?.Message ?? "Unable to acknowledge the remote completion.";
+                return false;
+            }
+        }
+        var metadata = session.GetOptimizationParameterMeta(snapshot.RunMode);
+        if (!RunsViewModel.BindRecoveredRun(runId, session, user, metadata))
+        {
+            error = "The recovered run is not present in the Runs list.";
+            return false;
+        }
+        lock (_sessionsByRunId)
+            _sessionsByRunId[runId] = (session, user);
+        error = null;
+        return true;
+    }
+
+    private bool BindRecoveredSharedEstimationRun(string runId, SharedEstimationJobSnapshot snapshot,
+        ModelSystemSession session, User user, out string? error)
+    {
+        using var modelStream = new MemoryStream();
+        if (!session.Save(out var saveError, modelStream))
+        {
+            error = saveError?.Message ?? "Unable to serialize the selected model system.";
+            return false;
+        }
+        var modelHash = Convert.ToHexString(SHA256.HashData(modelStream.ToArray()));
+        if (!string.Equals(modelHash, snapshot.ModelSystemHash, StringComparison.OrdinalIgnoreCase))
+        {
+            error = "The selected model system does not match the model system used by this remote estimation.";
+            return false;
+        }
+        var metadata = session.GetOptimizationParameterMeta(RunMode.Estimation);
+        if (snapshot.Parameters is { Count: > 0 } remoteParameters &&
+            (remoteParameters.Count != metadata.Count ||
+             remoteParameters.Where((parameter, index) => parameter.NodeIndex != metadata[index].nodeIndex).Any()))
+        {
+            error = "The selected model system's estimation parameters do not match the remote run.";
+            return false;
+        }
+        if (!RunsViewModel.BindRecoveredRun(runId, session, user, metadata))
+        {
+            error = "The recovered estimation is not present in the Runs list.";
+            return false;
+        }
+        SharedEstimationCompletion? pendingCompletion;
+        lock (_sessionsByRunId)
+        {
+            _sessionsByRunId[runId] = (session, user);
+            _remoteEstimationMetadata[runId] = metadata;
+            pendingCompletion = _remoteCompletionGate.MarkReady(runId);
+        }
+        if (pendingCompletion is not null)
+            OnSharedEstimationCompleted(_hostBusesByRunId.GetValueOrDefault(runId), pendingCompletion);
+        error = null;
+        return true;
+    }
+
+    public bool RetryRemoteRunReceipt(string runId, out string? error)
+    {
+        (HostBus HostBus, string TargetDirectory) receipt;
+        lock (_sessionsByRunId)
+        {
+            if (!_pendingRemoteReceipts.TryGetValue(runId, out receipt))
+            {
+                error = "There is no pending remote receipt for this run.";
+                return false;
+            }
+        }
+        if (!receipt.HostBus.RequestRemoteRunArtifacts(runId, out var requestError))
+        {
+            error = requestError?.Message ?? "Unable to request remote run artifacts.";
+            return false;
+        }
+        error = null;
+        return true;
+    }
+
+    public bool RequestRemoteRunOutputTransfer(string runId, out string? error)
+    {
+        HostBus? hostBus;
+        string targetDirectory;
+        lock (_sessionsByRunId)
+        {
+            _remoteRunBusesByRunId.TryGetValue(runId, out hostBus);
+            if (hostBus is null)
+                _hostBusesByRunId.TryGetValue(runId, out hostBus);
+            if (_runDirectoriesByRunId.TryGetValue(runId, out var knownDirectory))
+                targetDirectory = knownDirectory;
+            else
+                targetDirectory = RemoteRunOutputPaths.GetLocalDirectory(runId);
+            if (hostBus is not null)
+                _pendingRemoteReceipts[runId] = (hostBus, targetDirectory);
+        }
+
+        if (hostBus is null)
+        {
+            error = "The RunServer connection for this run is no longer available.";
+            return false;
+        }
+        RunsViewModel.NotifyRemoteReceiptPending(runId, true);
+        if (!hostBus.RequestRemoteRunArtifacts(runId, out var requestError))
+        {
+            RunsViewModel.NotifyRemoteReceiptPending(runId, false);
+            error = requestError?.Message ?? "Unable to request remote run output.";
+            return false;
+        }
+        error = null;
+        return true;
+    }
+
+    public async Task<RemoteRunDeletionResponse> DeleteRemoteRunAsync(string runId,
+        CancellationToken cancellationToken = default)
+    {
+        HostBus? hostBus;
+        lock (_sessionsByRunId)
+        {
+            _remoteRunBusesByRunId.TryGetValue(runId, out hostBus);
+            if (hostBus is null)
+                _hostBusesByRunId.TryGetValue(runId, out hostBus);
+        }
+        if (hostBus is null)
+            return new RemoteRunDeletionResponse(string.Empty, runId, false,
+                "The RunServer connection for this run is no longer available.");
+
+        var result = await hostBus.DeleteRemoteRunAsync(runId, cancellationToken: cancellationToken)
+            .ConfigureAwait(false);
+        if (result.IsDeletedOrNotFound)
+        {
+            lock (_sessionsByRunId)
+            {
+                _recoveredRemoteRuns.Remove(runId);
+                _remoteRunBusesByRunId.Remove(runId);
+                _hostBusesByRunId.Remove(runId);
+                _runDirectoriesByRunId.Remove(runId);
+                _pendingRemoteReceipts.Remove(runId);
+                _sessionsByRunId.Remove(runId);
+            }
+        }
+        return result;
+    }
+
+    private static void PersistRemoteRunSnapshot(RemoteRunSnapshot snapshot)
+    {
+        var receiptDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+            "XTMF2", "GUI", "RemoteRunReceipts");
+        Directory.CreateDirectory(receiptDirectory);
+        var key = Convert.ToHexString(SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(snapshot.RunId)));
+        var path = Path.Combine(receiptDirectory, $"{key}.json");
+        var temporaryPath = path + ".tmp";
+        var options = new System.Text.Json.JsonSerializerOptions
+        {
+            NumberHandling = System.Text.Json.Serialization.JsonNumberHandling.AllowNamedFloatingPointLiterals
+        };
+        File.WriteAllBytes(temporaryPath, System.Text.Json.JsonSerializer.SerializeToUtf8Bytes(snapshot, options));
+        File.Move(temporaryPath, path, true);
+    }
+
+    private void OnRemoteRunArtifactsAvailable(object? sender, RemoteRunArtifactsResponse response)
+    {
+        (HostBus HostBus, string TargetDirectory) receipt;
+        RemoteRunSnapshot? snapshot;
+        lock (_sessionsByRunId)
+        {
+            if (!_pendingRemoteReceipts.TryGetValue(response.RunId, out receipt))
+                return;
+            _recoveredRemoteRuns.TryGetValue(response.RunId, out snapshot);
+        }
+        if (response.Archive is null)
+        {
+            RunsViewModel.NotifyArtifactTransferFailed(response.RunId,
+                response.Error ?? "The RunServer returned no artifact archive.");
+            return;
+        }
+
+        try
+        {
+            using var archiveStream = new MemoryStream(response.Archive, writable: false);
+            ExtractRunArtifacts(archiveStream, receipt.TargetDirectory);
+            RunsViewModel.NotifyArtifactsTransferred(response.RunId);
+            if (snapshot is not null)
+                PersistRemoteRunSnapshot(snapshot with { ArtifactsAvailable = false });
+            if (!receipt.HostBus.AcknowledgeRemoteRun(response.RunId, out var error))
+                throw new IOException(error?.Message ?? "Unable to acknowledge the remote completion.");
+            lock (_sessionsByRunId)
+            {
+                _pendingRemoteReceipts.Remove(response.RunId);
+                if (snapshot is not null)
+                    _recoveredRemoteRuns[response.RunId] = snapshot with { ArtifactsAvailable = false };
+            }
+            RunsViewModel.NotifyRemoteReceiptCompleted(response.RunId);
+            RunsViewModel.NotifyArtifactsTransferred(response.RunId);
+        }
+        catch (Exception exception) when (exception is IOException or InvalidDataException or UnauthorizedAccessException)
+        {
+            RunsViewModel.NotifyArtifactTransferFailed(response.RunId, exception.Message);
+        }
+    }
+
+    private static void ExtractRunArtifacts(Stream archiveStream, string targetDirectory)
+    {
+        Directory.CreateDirectory(targetDirectory);
+        var root = Path.GetFullPath(targetDirectory);
+        var rootWithSeparator = root.EndsWith(Path.DirectorySeparatorChar) ? root : root + Path.DirectorySeparatorChar;
+        using var archive = new ZipArchive(archiveStream, ZipArchiveMode.Read, leaveOpen: true);
+        foreach (var entry in archive.Entries)
+        {
+            var destination = Path.GetFullPath(Path.Combine(root, entry.FullName));
+            if (!destination.StartsWith(rootWithSeparator, StringComparison.Ordinal)
+                && !string.Equals(destination, root, StringComparison.Ordinal))
+                throw new InvalidDataException("The RunServer returned an invalid artifact path.");
+            if (string.IsNullOrEmpty(entry.Name))
+            {
+                Directory.CreateDirectory(destination);
+                continue;
+            }
+            Directory.CreateDirectory(Path.GetDirectoryName(destination)!);
+            entry.ExtractToFile(destination, true);
+        }
     }
 
     private void OnHostBusDisconnected(object? sender, EventArgs e)
     {
         if (sender is HostBus hostBus)
+        {
+            string[] affectedRuns;
+            lock (_sessionsByRunId)
+                affectedRuns = _hostBusesByRunId
+                    .Where(entry => ReferenceEquals(entry.Value, hostBus))
+                    .Select(entry => entry.Key)
+                    .ToArray();
+            foreach (var runId in affectedRuns)
+                RunsViewModel.NotifyConnectionLost(runId);
             UnsubscribeFromHostBus(hostBus);
+        }
     }
 
     private void UnsubscribeFromHostBus(HostBus hostBus)
@@ -521,6 +1606,13 @@ private void UnsubscribeFromHostBus(HostBus hostBus)
         hostBus.ClientErrorWhenRunningModelSystem -= OnClientErrorWhenRunningModelSystem;
         hostBus.ClientOptimizationResultsAvailable -= OnClientOptimizationResultsAvailable;
         hostBus.ClientIterationProgressAvailable -= OnClientIterationProgressAvailable;
+        hostBus.SharedEstimationProgressAvailable -= OnSharedEstimationProgress;
+        hostBus.SharedEstimationCompleted -= OnSharedEstimationCompleted;
+        hostBus.SharedEstimationWorkerControlAcknowledged -= OnSharedEstimationWorkerControlAcknowledged;
+        hostBus.SharedEstimationStatusAvailable -= OnSharedEstimationStatus;
+        hostBus.SharedEstimationJobSnapshotsAvailable -= OnSharedEstimationJobSnapshotsAvailable;
+        hostBus.RemoteRunSnapshotsAvailable -= OnRemoteRunSnapshotsAvailable;
+        hostBus.RemoteRunArtifactsAvailable -= OnRemoteRunArtifactsAvailable;
         hostBus.ClientRunArtifactsReceived -= OnClientRunArtifactsReceived;
         hostBus.Disconnected -= OnHostBusDisconnected;
     }
@@ -554,3 +1646,41 @@ public void Dispose()
         _runServerProcess?.Dispose();
     }
 }
+
+internal sealed class SharedEstimationCompletionGate
+{
+    private readonly object _sync = new();
+    private readonly HashSet<string> _completedRunIds = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, SharedEstimationCompletion> _pending = new(StringComparer.Ordinal);
+
+    public bool TryReceive(SharedEstimationCompletion completion, bool contextReady,
+        out SharedEstimationCompletion? accepted)
+    {
+        lock (_sync)
+        {
+            accepted = null;
+            if (_completedRunIds.Contains(completion.RunId))
+                return false;
+            if (!contextReady)
+            {
+                _pending[completion.RunId] = completion;
+                return true;
+            }
+
+            _pending.Remove(completion.RunId);
+            _completedRunIds.Add(completion.RunId);
+            accepted = completion;
+            return true;
+        }
+    }
+
+    public SharedEstimationCompletion? MarkReady(string runId)
+    {
+        lock (_sync)
+        {
+            if (_completedRunIds.Contains(runId) || !_pending.Remove(runId, out var completion))
+                return null;
+            return completion;
+        }
+    }
+}
diff --git a/src/XTMF2.GUI/RunServerConnectionManager.cs b/src/XTMF2.GUI/RunServerConnectionManager.cs
index c70d431f..7e439d81 100644
--- a/src/XTMF2.GUI/RunServerConnectionManager.cs
+++ b/src/XTMF2.GUI/RunServerConnectionManager.cs
@@ -153,6 +153,18 @@ public bool TryGet(string endpointId, out HostBus? hostBus)
         }
     }
 
+    public bool TryGetEndpoint(HostBus hostBus, out RunServerEndpoint? endpoint)
+    {
+        ArgumentNullException.ThrowIfNull(hostBus);
+        lock (_sync)
+        {
+            var entry = _entries.Values.FirstOrDefault(candidate =>
+                ReferenceEquals(candidate.HostBus, hostBus) && candidate.State == RunServerConnectionState.Available);
+            endpoint = entry?.Endpoint.Clone();
+            return endpoint is not null;
+        }
+    }
+
     public IReadOnlyList<RunServerConnectionInfo> GetStates()
     {
         lock (_sync)
@@ -258,7 +270,13 @@ private void Publish(RunServerConnectionInfo? state)
     private static void DisposeHostBus(HostBus? hostBus)
     {
         if (hostBus is null) return;
-        hostBus.RequestClientShutdown(out _);
-        hostBus.Dispose();
+        try
+        {
+            hostBus.RequestClientShutdown(out _);
+        }
+        finally
+        {
+            hostBus.Dispose();
+        }
     }
 }
diff --git a/src/XTMF2.GUI/RunServerDeploymentBuilder.cs b/src/XTMF2.GUI/RunServerDeploymentBuilder.cs
new file mode 100644
index 00000000..bae09e7c
--- /dev/null
+++ b/src/XTMF2.GUI/RunServerDeploymentBuilder.cs
@@ -0,0 +1,54 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Collections.Generic;
+using XTMF2;
+
+namespace XTMF2.GUI;
+
+internal static class RunServerDeploymentBuilder
+{
+    public sealed record DeploymentArchive(byte[] Content, IReadOnlyList<string> ModuleNames);
+
+    public static DeploymentArchive CreateLocalArchive(IReadOnlyList<string> selectedModules)
+    {
+        if (selectedModules.Count == 0)
+            throw new InvalidOperationException("Select at least one module DLL to upload.");
+
+        var runtimeAssembly = typeof(XTMFRuntime).Assembly.Location;
+        var files = selectedModules
+            .Where(File.Exists)
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+        if (files.Length != selectedModules.Count)
+            throw new FileNotFoundException("One or more selected module DLLs no longer exists.");
+
+        var moduleNames = files.Select(path => Path.GetFileName(path)!)
+            .OrderBy(name => name, StringComparer.OrdinalIgnoreCase).ToArray();
+
+        using var output = new MemoryStream();
+        using (var archive = new ZipArchive(output, ZipArchiveMode.Create, leaveOpen: true))
+        {
+            var runtimeEntry = archive.CreateEntry("XTMF2.dll", CompressionLevel.Fastest);
+            using (var source = File.OpenRead(runtimeAssembly))
+            using (var destination = runtimeEntry.Open())
+                source.CopyTo(destination);
+
+            foreach (var file in files)
+            {
+                var entry = archive.CreateEntry("Modules/" + Path.GetFileName(file), CompressionLevel.Fastest);
+                using var source = File.OpenRead(file);
+                using var destination = entry.Open();
+                source.CopyTo(destination);
+            }
+
+            var manifest = archive.CreateEntry("deployment-manifest.txt", CompressionLevel.Fastest);
+            using var manifestWriter = new StreamWriter(manifest.Open());
+            manifestWriter.WriteLine("XTMF2.dll");
+            foreach (var moduleName in moduleNames)
+                manifestWriter.WriteLine("Modules/" + moduleName);
+        }
+        return new DeploymentArchive(output.ToArray(), moduleNames);
+    }
+}
diff --git a/src/XTMF2.GUI/ViewModels/ModelSystemEditorViewModel.cs b/src/XTMF2.GUI/ViewModels/ModelSystemEditorViewModel.cs
index 46261182..ca76a78d 100644
--- a/src/XTMF2.GUI/ViewModels/ModelSystemEditorViewModel.cs
+++ b/src/XTMF2.GUI/ViewModels/ModelSystemEditorViewModel.cs
@@ -31,6 +31,7 @@ You should have received a copy of the GNU General Public License
 using Avalonia.Platform.Storage;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
+using XTMF2.Bus.Optimization;
 using XTMF2;
 using XTMF2.AI;
 using XTMF2.Editing;
@@ -2759,6 +2760,25 @@ public async Task RemoveNodeFromCalibrationAsync(NodeViewModel nvm)
         return CollectFunctionNodes(Session.ModelSystem.GlobalBoundary);
     }
 
+    public System.Collections.Generic.List<XTMF2.ModelSystemConstruct.Node> GetInputDirectoryNodes()
+    {
+        return CollectInputDirectoryNodes(Session.ModelSystem.GlobalBoundary);
+    }
+
+    private static System.Collections.Generic.List<XTMF2.ModelSystemConstruct.Node> CollectInputDirectoryNodes(
+        XTMF2.ModelSystemConstruct.Boundary boundary)
+    {
+        var result = new System.Collections.Generic.List<XTMF2.ModelSystemConstruct.Node>();
+        foreach (var node in boundary.Modules)
+        {
+            if (node.Type == typeof(XTMF2.RuntimeModules.BasicParameter<string>))
+                result.Add(node);
+        }
+        foreach (var child in boundary.Boundaries)
+            result.AddRange(CollectInputDirectoryNodes(child));
+        return result;
+    }
+
     private static System.Collections.Generic.List<XTMF2.ModelSystemConstruct.Node> CollectFunctionNodes(
         XTMF2.ModelSystemConstruct.Boundary boundary)
     {
@@ -3502,10 +3522,10 @@ private async Task RunModelSystem()
             defaultRunName,
             availableStarts.Select(start => start.Name).ToList());
         if (runConfiguration is null) return;
-        var (runName, endpointId, startToExecute) = runConfiguration.Value;
+        var (runName, endpointIds, startToExecute, _, _, _) = runConfiguration.Value;
 
         var project = Session.Project;
-        if (!_runController.SendRun(project, Session, User, startToExecute, runName, endpointId, out _, out var runError))
+        if (!_runController.SendRun(project, Session, User, startToExecute, runName, endpointIds[0], out _, out var runError))
         {
             ShowToast($"Failed to start run: {runError?.Message}", isError: true, durationMs: 6000);
             return;
@@ -3529,15 +3549,33 @@ private async Task RunEstimation()
         }
 
         var defaultRunName = $"Estimation_{ModelSystemHeader.Name ?? "Run"}_{DateTime.Now:yyyyMMdd_HHmmss}";
+        var selectedInputDirectoryId = Session.ModelSystem.EstimationInputDirectoryNode?.Id;
+        var inputDirectory = Session.GetStringBasicParameterMeta()
+            .Where(parameter => selectedInputDirectoryId is not null && parameter.nodeId == selectedInputDirectoryId)
+            .ToList();
+        var inputDirectoryParameters = inputDirectory
+            .Select(parameter => new RunConfigurationDialog.PathParameter(
+                parameter.nodeIndex, parameter.nodeId, parameter.name, parameter.value))
+            .ToList();
         var runConfiguration = await ConfigureRunAsync(
             "Run Estimation",
             defaultRunName,
-            availableStarts.Select(start => start.Name).ToList());
+            availableStarts.Select(start => start.Name).ToList(),
+            allowMultipleRunServers: true,
+            inputDirectoryParameters);
         if (runConfiguration is null) return;
-        var (runName, endpointId, startToExecute) = runConfiguration.Value;
+        var (runName, endpointIds, startToExecute, pathOverrides, orchestratorEndpointId,
+            concurrentRunsByEndpoint) = runConfiguration.Value;
 
         var project = Session.Project;
-        if (!_runController.SendEstimationRun(project, Session, User, startToExecute, runName, endpointId, out _, out var runError))
+        CommandError? runError;
+        bool started = orchestratorEndpointId is not null
+            ? _runController.SendRemoteSharedEstimationRun(project, Session, User, startToExecute, runName,
+                orchestratorEndpointId, endpointIds, pathOverrides, concurrentRunsByEndpoint,
+                out _, out runError)
+            : _runController.SendEstimationRun(project, Session, User, startToExecute, runName,
+                endpointIds[0], out _, out runError);
+        if (!started)
         {
             ShowToast($"Failed to start estimation run: {runError?.Message}", isError: true, durationMs: 6000);
             return;
@@ -3566,10 +3604,10 @@ private async Task RunCalibration()
             defaultRunName,
             availableStarts.Select(start => start.Name).ToList());
         if (runConfiguration is null) return;
-        var (runName, endpointId, startToExecute) = runConfiguration.Value;
+        var (runName, endpointIds, startToExecute, _, _, _) = runConfiguration.Value;
 
         var project = Session.Project;
-        if (!_runController.SendCalibrationRun(project, Session, User, startToExecute, runName, endpointId, out _, out var runError))
+        if (!_runController.SendCalibrationRun(project, Session, User, startToExecute, runName, endpointIds[0], out _, out var runError))
         {
             ShowToast($"Failed to start calibration run: {runError?.Message}", isError: true, durationMs: 6000);
             return;
@@ -3579,10 +3617,15 @@ private async Task RunCalibration()
         RunStarted?.Invoke();
     }
 
-    private async Task<(string RunName, string EndpointId, string StartName)?> ConfigureRunAsync(
+    private async Task<(string RunName, IReadOnlyList<string> EndpointIds, string StartName,
+        IReadOnlyDictionary<string, IReadOnlyDictionary<int, string>> PathOverrides,
+        string? OrchestratorEndpointId,
+        IReadOnlyDictionary<string, int> ConcurrentRunsByEndpoint)?> ConfigureRunAsync(
         string title,
         string defaultRunName,
-        IReadOnlyList<string> startNames)
+        IReadOnlyList<string> startNames,
+        bool allowMultipleRunServers = false,
+        IReadOnlyList<RunConfigurationDialog.PathParameter>? pathParameters = null)
     {
         if (_runController is null)
             return null;
@@ -3594,17 +3637,24 @@ private async Task RunCalibration()
             return null;
         }
 
-        var dialog = new RunConfigurationDialog(title, defaultRunName, endpoints, startNames);
+        var dialog = new RunConfigurationDialog(title, defaultRunName, endpoints, startNames,
+            allowMultipleRunServers, pathParameters);
         await dialog.ShowDialog(ParentWindow!);
         if (dialog.WasCancelled)
             return null;
 
         var runName = dialog.RunName?.Trim();
-        var endpointId = dialog.SelectedRunServer?.Id;
+        var endpointIds = dialog.UseMultipleRunServers
+            ? dialog.SelectedRunServers.Select(endpoint => endpoint.Id).ToArray()
+            : dialog.SelectedRunServer is { } selectedRunServer ? [selectedRunServer.Id] : [];
         var startName = dialog.SelectedStartName;
-        return string.IsNullOrEmpty(runName) || endpointId is null || string.IsNullOrEmpty(startName)
+        var orchestratorEndpointId = dialog.UseMultipleRunServers
+            ? dialog.SelectedCoordinatorRunServer?.Id
+            : null;
+        return string.IsNullOrEmpty(runName) || endpointIds.Length == 0 || string.IsNullOrEmpty(startName)
             ? null
-            : (runName, endpointId, startName);
+            : (runName, endpointIds, startName, dialog.PathOverrides, orchestratorEndpointId,
+                dialog.ConcurrentRunsByEndpoint);
     }
 
     /// <summary>Save the model system to its project file.</summary>
diff --git a/src/XTMF2.GUI/ViewModels/RemoteEstimationWorkerViewModel.cs b/src/XTMF2.GUI/ViewModels/RemoteEstimationWorkerViewModel.cs
new file mode 100644
index 00000000..dfbe9663
--- /dev/null
+++ b/src/XTMF2.GUI/ViewModels/RemoteEstimationWorkerViewModel.cs
@@ -0,0 +1,75 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using System;
+using XTMF2.GUI.Properties;
+
+namespace XTMF2.GUI.ViewModels;
+
+public sealed partial class RemoteEstimationWorkerViewModel : ObservableObject
+{
+    public const string CoordinatorWorkerId = "coordinator";
+
+    public RunServerEndpoint Endpoint { get; }
+    public string WorkerId => Endpoint.Id;
+    public string Name => Endpoint.Name;
+    public bool IsCoordinator => string.Equals(WorkerId, CoordinatorWorkerId, StringComparison.Ordinal);
+    public int ConfiguredWorkerCount { get; }
+
+    [ObservableProperty]
+    private int _activeWorkerCount;
+
+    public string ActiveWorkerCountDisplay
+        => $"{ActiveWorkerCount} / {ConfiguredWorkerCount} workers";
+
+    [ObservableProperty]
+    private int _completedEvaluations;
+
+    public string EvaluationCountDisplay => $"Tests: {CompletedEvaluations}";
+
+    [ObservableProperty]
+    private bool _isActive;
+
+    [ObservableProperty]
+    private bool _isBusy;
+
+    public bool CanAdd => !IsCoordinator && IsInactive && IsNotBusy;
+    public bool CanRemove => !IsCoordinator && IsActive && IsNotBusy;
+    public bool IsInactive => !IsActive;
+    public bool IsNotBusy => !IsBusy;
+
+    partial void OnIsActiveChanged(bool value)
+    {
+        OnPropertyChanged(nameof(CanRemove));
+        OnPropertyChanged(nameof(IsInactive));
+        OnPropertyChanged(nameof(CanAdd));
+    }
+
+    partial void OnActiveWorkerCountChanged(int value)
+        => OnPropertyChanged(nameof(ActiveWorkerCountDisplay));
+
+    partial void OnCompletedEvaluationsChanged(int value)
+        => OnPropertyChanged(nameof(EvaluationCountDisplay));
+
+    partial void OnIsBusyChanged(bool value)
+    {
+        OnPropertyChanged(nameof(IsNotBusy));
+        OnPropertyChanged(nameof(CanAdd));
+        OnPropertyChanged(nameof(CanRemove));
+    }
+
+    public RemoteEstimationWorkerViewModel(RunServerEndpoint endpoint, bool isActive,
+        int configuredWorkerCount = 1)
+    {
+        Endpoint = endpoint;
+        ConfiguredWorkerCount = Math.Clamp(configuredWorkerCount, 1, 32);
+        IsActive = isActive || IsCoordinator;
+    }
+
+    internal void SetActiveWorkerCount(int count)
+    {
+        ActiveWorkerCount = Math.Max(0, count);
+        IsActive = IsCoordinator || ActiveWorkerCount > 0;
+    }
+
+    internal void SetCompletedEvaluations(int count)
+        => CompletedEvaluations = Math.Max(0, count);
+}
diff --git a/src/XTMF2.GUI/ViewModels/RunViewModel.cs b/src/XTMF2.GUI/ViewModels/RunViewModel.cs
index 643af336..03943875 100644
--- a/src/XTMF2.GUI/ViewModels/RunViewModel.cs
+++ b/src/XTMF2.GUI/ViewModels/RunViewModel.cs
@@ -24,9 +24,12 @@ You should have received a copy of the GNU General Public License
 using System.Linq;
 using System.Runtime.InteropServices;
 using XTMF2.Configuration;
+using XTMF2.GUI;
+using XTMF2.GUI.Properties;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
 using XTMF2.Editing;
 
 namespace XTMF2.GUI.ViewModels;
@@ -41,7 +44,9 @@ public enum RunStatus
     /// <summary>The run completed successfully.</summary>
     Finished,
     /// <summary>The run encountered an error.</summary>
-    Error
+    Error,
+    /// <summary>The RunServer restarted before the run completed.</summary>
+    Interrupted
 }
 
 /// <summary>
@@ -59,29 +64,86 @@ public sealed partial class RunViewModel : ObservableObject
     public string RunName { get; }
 
     /// <summary>The directory that the run executes in and writes its output to.</summary>
-    public string RunDirectory { get; }
+    public string RunDirectory { get; private set; }
 
     /// <summary>The configured RunServer that processed this run.</summary>
-    public string RunServer { get; }
+    public string RunServer { get; private set; }
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(CanTransferRemoteOutput))]
+    [NotifyPropertyChangedFor(nameof(OutputTransferStatus))]
+    private bool _isRemoteRun;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(CanTransferRemoteOutput))]
+    [NotifyPropertyChangedFor(nameof(OutputTransferStatus))]
+    private bool _remoteOutputAvailable;
+
+    public bool CanTransferRemoteOutput
+        => IsRemoteRun && IsCompleted && !ArtifactsAvailable && !HasPendingRemoteReceipt;
+
+    public string OutputTransferStatus => !IsRemoteRun
+        ? ArtifactsAvailable ? "Output is on this computer." : "Output has not been transferred yet."
+        : Status == RunStatus.Running ? "Output will be transferred when the run completes."
+        : ArtifactsAvailable ? "Output is on this computer."
+        : HasPendingRemoteReceipt ? "Output transfer is pending."
+        : RemoteOutputAvailable ? "Output is available on the RunServer."
+        : "RunServer output availability has not been confirmed.";
 
     /// <summary>True when this run has a known output directory that can be opened.</summary>
     public bool HasRunDirectory => ArtifactsAvailable && !string.IsNullOrWhiteSpace(RunDirectory);
 
     [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(CanTransferRemoteOutput))]
+    [NotifyPropertyChangedFor(nameof(OutputTransferStatus))]
     private bool _artifactsAvailable;
 
     internal void MarkArtifactsAvailable()
     {
         ArtifactsAvailable = true;
+        RemoteOutputAvailable = false;
+        HasPendingRemoteReceipt = false;
+        OnPropertyChanged(nameof(OutputTransferStatus));
+        OnPropertyChanged(nameof(HasRunDirectory));
+        OpenRunDirectoryCommand.NotifyCanExecuteChanged();
+    }
+
+    internal void SetRemoteRunTracking(bool isRemoteRun)
+        => IsRemoteRun = isRemoteRun;
+
+    internal void SetLocalOutputDirectory(string directory)
+    {
+        if (RunDirectory == directory)
+            return;
+        RunDirectory = directory;
+        ArtifactsAvailable = Directory.Exists(directory);
+        if (ArtifactsAvailable)
+            RemoteOutputAvailable = false;
+        OnPropertyChanged(nameof(RunDirectory));
         OnPropertyChanged(nameof(HasRunDirectory));
         OpenRunDirectoryCommand.NotifyCanExecuteChanged();
     }
 
+    internal void SetRunServer(string runServer)
+    {
+        if (RunServer == runServer)
+            return;
+        RunServer = runServer;
+        OnPropertyChanged(nameof(RunServer));
+    }
+
     internal void MarkArtifactTransferFailed(string message)
-        => AppendStatus($"Output transfer failed: {message}");
+    {
+        HasPendingRemoteReceipt = false;
+        AppendStatus($"Output transfer failed: {message}");
+        OnPropertyChanged(nameof(OutputTransferStatus));
+        OnPropertyChanged(nameof(CanTransferRemoteOutput));
+    }
 
     /// <summary>Current execution status.</summary>
     [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(OutputTransferStatus))]
+    [NotifyPropertyChangedFor(nameof(CanTransferRemoteOutput))]
     private RunStatus _status = RunStatus.Running;
 
     /// <summary>
@@ -101,11 +163,14 @@ internal void MarkArtifactTransferFailed(string message)
         RunStatus.Running  => "⏳",
         RunStatus.Finished => "✅",
         RunStatus.Error    => "❌",
+        RunStatus.Interrupted => "↻",
         _                  => "?"
     };
 
-    private readonly ModelSystemSession _session;
-    private readonly User _user;
+    private ModelSystemSession? _session;
+    private User? _user;
+    private RemoteRunSnapshot? _recoveredSnapshot;
+    private SharedEstimationJobSnapshot? _recoveredSharedEstimationSnapshot;
 
     public RunViewModel(string runId, string runName, string runDirectory, string runServer,
         ModelSystemSession session, User user)
@@ -118,6 +183,204 @@ public RunViewModel(string runId, string runName, string runDirectory, string ru
         _user = user;
     }
 
+    public RunViewModel(RemoteRunSnapshot snapshot, string runServer, Action? cancelAction = null)
+        : this(snapshot.RunId, snapshot.RunName, RemoteRunOutputPaths.GetLocalDirectory(snapshot.RunId), runServer, null!, null!)
+    {
+        _recoveredSnapshot = snapshot;
+        IsRemoteRun = true;
+        ArtifactsAvailable = Directory.Exists(RunDirectory);
+        RemoteOutputAvailable = snapshot.ArtifactsAvailable && !ArtifactsAvailable;
+        IsRecoveredRunUnbound = true;
+        SetRunMode(snapshot.RunMode,
+            Array.Empty<(int nodeIndex, string name, double min, double max)>(), cancelAction ?? (() => { }));
+        var parameterValues = snapshot.ProgressParameters
+            .Concat(snapshot.OptimizationResults ?? Array.Empty<RemoteRunParameterValue>())
+            .GroupBy(value => value.NodeIndex)
+            .Select(group => group.Last())
+            .ToArray();
+        foreach (var value in parameterValues)
+        {
+            var parameter = new OptimizationParameterViewModel(value.NodeIndex,
+                $"Parameter {value.NodeIndex}", 0, 0);
+            OptimizationParameters.Add(parameter);
+            _paramByIndex[value.NodeIndex] = parameter;
+        }
+        if (snapshot.ProgressParameters.Count > 0)
+            UpdateIterationProgress(snapshot.Iteration, snapshot.Fitness, 0,
+                snapshot.ProgressParameters.Select(value => (value.NodeIndex, value.Value)).ToArray());
+        if (snapshot.OptimizationResults is { Count: > 0 } results)
+        {
+            _optimizationResults = results.Select(value => (value.NodeIndex, value.Value)).ToArray();
+            HasOptimizationResults = true;
+        }
+        switch (snapshot.State)
+        {
+            case RemoteRunState.Completed:
+                MarkFinished(snapshot.Status);
+                break;
+            case RemoteRunState.Failed:
+                MarkError(snapshot.ErrorMessage ?? snapshot.Status, snapshot.ErrorStack ?? string.Empty, null, null);
+                break;
+            case RemoteRunState.Interrupted:
+                MarkInterrupted(snapshot.Status);
+                break;
+            default:
+                AppendStatus(snapshot.Status);
+                break;
+        }
+        if (snapshot.ArtifactsAvailable)
+            AppendStatus("Run output is retained on the RunServer and can be retrieved after binding this run.");
+    }
+
+    public RunViewModel(SharedEstimationJobSnapshot snapshot, string runServer, Action cancelAction)
+        : this(snapshot.RunId,
+            string.IsNullOrWhiteSpace(snapshot.RunName) ? $"Estimation {snapshot.RunId}" : snapshot.RunName,
+            snapshot.WorkingDirectory, runServer, null!, null!)
+    {
+        IsRecoveredRunUnbound = true;
+        IsRemoteSharedEstimation = true;
+        SetRunMode(RunMode.Estimation,
+            (snapshot.Parameters ?? Array.Empty<SharedEstimationParameterMetadata>())
+                .Select(parameter => (parameter.NodeIndex, parameter.Name, parameter.Min, parameter.Max)).ToArray(),
+            cancelAction);
+        ApplyRecoveredSharedEstimationSnapshot(snapshot);
+    }
+
+    [ObservableProperty]
+    private bool _isRecoveredRunUnbound;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(CanTransferRemoteOutput))]
+    [NotifyPropertyChangedFor(nameof(OutputTransferStatus))]
+    private bool _hasPendingRemoteReceipt;
+
+    internal void BindRecoveredRun(ModelSystemSession session, User user,
+        IReadOnlyList<(int nodeIndex, string name, double min, double max)> metadata)
+    {
+        _session = session;
+        _user = user;
+        IsRecoveredRunUnbound = false;
+        SetRunMode(RunType, metadata, _cancelAction ?? (() => { }));
+        if (_recoveredSnapshot is { ProgressParameters.Count: > 0 } snapshot)
+            UpdateIterationProgress(snapshot.Iteration, snapshot.Fitness, 0,
+                snapshot.ProgressParameters.Select(value => (value.NodeIndex, value.Value)).ToArray());
+        if (_recoveredSharedEstimationSnapshot?.Progress is { } sharedProgress)
+            UpdateSharedEstimationProgress(sharedProgress);
+        if (_optimizationResults is not null)
+        {
+            _optimizationSession = session;
+            _optimizationUser = user;
+            HasOptimizationResults = true;
+        }
+    }
+
+    internal void ApplyRecoveredSnapshot(RemoteRunSnapshot snapshot)
+    {
+        _recoveredSnapshot = snapshot;
+        IsRemoteRun = true;
+        RemoteOutputAvailable = snapshot.ArtifactsAvailable && !ArtifactsAvailable;
+        if (snapshot.ProgressParameters.Count > 0)
+        {
+            foreach (var value in snapshot.ProgressParameters)
+            {
+                if (!_paramByIndex.ContainsKey(value.NodeIndex))
+                {
+                    var parameter = new OptimizationParameterViewModel(value.NodeIndex,
+                        $"Parameter {value.NodeIndex}", 0, 0);
+                    OptimizationParameters.Add(parameter);
+                    _paramByIndex[value.NodeIndex] = parameter;
+                }
+            }
+            UpdateIterationProgress(snapshot.Iteration, snapshot.Fitness, 0,
+                snapshot.ProgressParameters.Select(value => (value.NodeIndex, value.Value)).ToArray());
+        }
+        if (snapshot.OptimizationResults is { Count: > 0 } results)
+        {
+            _optimizationResults = results.Select(value => (value.NodeIndex, value.Value)).ToArray();
+            if (_session is not null && _user is not null)
+            {
+                _optimizationSession = _session;
+                _optimizationUser = _user;
+            }
+            HasOptimizationResults = true;
+        }
+        switch (snapshot.State)
+        {
+            case RemoteRunState.Completed when Status != RunStatus.Finished:
+                MarkFinished(snapshot.Status);
+                break;
+            case RemoteRunState.Failed when Status != RunStatus.Error:
+                MarkError(snapshot.ErrorMessage ?? snapshot.Status, snapshot.ErrorStack ?? string.Empty, null, null);
+                break;
+            case RemoteRunState.Interrupted when Status != RunStatus.Interrupted:
+                MarkInterrupted(snapshot.Status);
+                break;
+            case RemoteRunState.Running when Status != RunStatus.Running:
+                Status = RunStatus.Running;
+                StatusText = snapshot.Status;
+                OnPropertyChanged(nameof(StatusBadge));
+                OnPropertyChanged(nameof(IsCompleted));
+                break;
+        }
+    }
+
+    internal void ApplyRecoveredSharedEstimationSnapshot(SharedEstimationJobSnapshot snapshot)
+    {
+        _recoveredSharedEstimationSnapshot = snapshot;
+        IsRemoteSharedEstimation = true;
+        var parameters = snapshot.Parameters ?? Array.Empty<SharedEstimationParameterMetadata>();
+        if (OptimizationParameters.Count == 0 && parameters.Count > 0)
+            SetRunMode(RunMode.Estimation,
+                parameters.Select(parameter => (parameter.NodeIndex, parameter.Name, parameter.Min, parameter.Max)).ToArray(),
+                _cancelAction ?? (() => { }));
+        if (snapshot.Progress is { } progress)
+            UpdateSharedEstimationProgress(progress);
+        if (snapshot.Completion is { } completion)
+        {
+            if (!completion.Succeeded)
+            {
+                MarkError(completion.FailureReason ?? "Remote estimation failed.", string.Empty, null, null);
+                return;
+            }
+            _optimizationResults = completion.BestParameters
+                .Select((value, index) => (parameters.Count > index ? parameters[index].NodeIndex : index, value))
+                .ToArray();
+            HasOptimizationResults = _optimizationResults.Count > 0;
+            MarkFinished($"[Estimation] converged after {completion.TotalEvaluations} fitness test(s) " +
+                $"in {completion.Iterations} iteration(s). Best fitness = {completion.BestFitness:G6}.");
+            return;
+        }
+        if (snapshot.State == SharedEstimationJobState.Running)
+        {
+            if (Status != RunStatus.Running)
+            {
+                Status = RunStatus.Running;
+                OnPropertyChanged(nameof(StatusBadge));
+                OnPropertyChanged(nameof(IsCompleted));
+                CancelRunCommand.NotifyCanExecuteChanged();
+            }
+            StatusText = "Estimation running";
+        }
+    }
+
+    internal void ApplyRecoveredSharedEstimationCompletion(SharedEstimationCompletion completion)
+    {
+        if (!IsRecoveredRunUnbound || _recoveredSharedEstimationSnapshot is not { } snapshot)
+            return;
+        ApplyRecoveredSharedEstimationSnapshot(snapshot with
+        {
+            State = SharedEstimationJobState.Completed,
+            Completion = completion
+        });
+    }
+
+    internal void SetRemoteReceiptPending(bool pending)
+    {
+        HasPendingRemoteReceipt = pending;
+        OnPropertyChanged(nameof(OutputTransferStatus));
+        OnPropertyChanged(nameof(CanTransferRemoteOutput));
+    }
+
     private bool CanOpenRunDirectory() => HasRunDirectory;
 
     /// <summary>
@@ -219,12 +482,21 @@ private static bool TryOpenDirectoryInFileExplorer(string directoryPath)
     [ObservableProperty]
     private double _currentFitness;
 
+    /// <summary>Number of fitness tests completed during the current iteration.</summary>
+    [ObservableProperty]
+    private int _currentIterationFitnessTests;
+
     /// <summary>Live parameter values for each optimisation parameter.</summary>
     public ObservableCollection<OptimizationParameterViewModel> OptimizationParameters { get; } = new();
 
     /// <summary>Complete history of all completed iterations (oldest first).</summary>
     public ObservableCollection<OptimizationIterationViewModel> IterationHistory { get; } = new();
 
+    public ObservableCollection<RemoteEstimationWorkerViewModel> RemoteWorkers { get; } = new();
+
+    [ObservableProperty]
+    private bool _isRemoteSharedEstimation;
+
     /// <summary>The iteration currently shown in the detail panel; auto-advances with each new iteration.</summary>
     [ObservableProperty]
     private OptimizationIterationViewModel? _selectedIteration;
@@ -251,11 +523,126 @@ internal void SetRunMode(RunMode runMode,
         CancelRunCommand.NotifyCanExecuteChanged();
     }
 
+    internal void SetRemoteEstimationWorkers(
+        IReadOnlyList<RunServerEndpoint> endpoints,
+        IReadOnlyCollection<string> activeWorkerIds,
+        Func<string, string?> addWorker,
+        Func<string, string?> removeWorker,
+        IReadOnlyDictionary<string, int>? configuredWorkerCounts = null)
+    {
+        IsRemoteSharedEstimation = true;
+        _addRemoteWorkerAction = addWorker;
+        _removeRemoteWorkerAction = removeWorker;
+        RemoteWorkers.Clear();
+        foreach (var endpoint in endpoints)
+        {
+            var configuredCount = configuredWorkerCounts is not null &&
+                configuredWorkerCounts.TryGetValue(endpoint.Id, out var count) ? count : 1;
+            var worker = new RemoteEstimationWorkerViewModel(endpoint,
+                activeWorkerIds.Contains(endpoint.Id, StringComparer.Ordinal), configuredCount);
+            RemoteWorkers.Add(worker);
+        }
+    }
+
+    internal void ApplyRemoteWorkerSnapshot(IReadOnlyCollection<string> activeWorkerIds)
+    {
+        foreach (var worker in RemoteWorkers)
+        {
+            worker.SetActiveWorkerCount(CountWorkerSlots(activeWorkerIds, worker.WorkerId));
+            worker.IsActive = worker.IsCoordinator || worker.ActiveWorkerCount > 0;
+            worker.IsBusy = false;
+        }
+    }
+
+    internal void MarkRemoteWorkerDisconnected(string workerId)
+    {
+        var worker = RemoteWorkers.FirstOrDefault(candidate =>
+            string.Equals(candidate.WorkerId, workerId, StringComparison.Ordinal));
+        if (worker is null)
+            return;
+        worker.IsActive = false;
+        worker.SetActiveWorkerCount(0);
+        worker.IsBusy = false;
+    }
+
+    internal void ReconnectRemoteWorker(string workerId)
+    {
+        if (string.Equals(workerId, RemoteEstimationWorkerViewModel.CoordinatorWorkerId,
+            StringComparison.Ordinal))
+            return;
+        if (Status != RunStatus.Running || _addRemoteWorkerAction is null)
+            return;
+        var worker = RemoteWorkers.FirstOrDefault(candidate =>
+            string.Equals(candidate.WorkerId, workerId, StringComparison.Ordinal));
+        if (worker is null || worker.IsActive || worker.IsBusy)
+            return;
+
+        worker.IsBusy = true;
+        var error = _addRemoteWorkerAction(workerId);
+        if (error is not null)
+        {
+            worker.IsBusy = false;
+            AppendStatus($"[Remote estimation] Unable to re-add worker: {error}");
+        }
+    }
+
+    internal void ApplyRemoteWorkerAcknowledgement(SharedEstimationWorkerControlAcknowledgement acknowledgement)
+    {
+        var worker = RemoteWorkers.FirstOrDefault(candidate =>
+            string.Equals(candidate.WorkerId, acknowledgement.WorkerId, StringComparison.Ordinal));
+        if (worker is null || worker.IsCoordinator)
+            return;
+        worker.IsBusy = false;
+        if (acknowledgement.Succeeded)
+        {
+            if (acknowledgement.Add)
+                worker.IsActive = true;
+            else
+                worker.SetActiveWorkerCount(0);
+        }
+        else
+            AppendStatus($"[Remote estimation] Worker change failed: {acknowledgement.Error}");
+    }
+
+    private Func<string, string?>? _addRemoteWorkerAction;
+    private Func<string, string?>? _removeRemoteWorkerAction;
+
+    [RelayCommand]
+    private void AddRemoteWorker(RemoteEstimationWorkerViewModel worker)
+    {
+        if (worker.IsCoordinator || worker.IsActive || worker.IsBusy || _addRemoteWorkerAction is null)
+            return;
+        worker.IsBusy = true;
+        var error = _addRemoteWorkerAction(worker.WorkerId);
+        if (error is not null)
+        {
+            worker.IsBusy = false;
+            AppendStatus($"[Remote estimation] Unable to add worker: {error}");
+        }
+    }
+
+    [RelayCommand]
+    private void RemoveRemoteWorker(RemoteEstimationWorkerViewModel worker)
+    {
+        if (worker.IsCoordinator || !worker.IsActive || worker.IsBusy || _removeRemoteWorkerAction is null)
+            return;
+        worker.IsBusy = true;
+        var error = _removeRemoteWorkerAction(worker.WorkerId);
+        if (error is not null)
+        {
+            worker.IsBusy = false;
+            AppendStatus($"[Remote estimation] Unable to remove worker: {error}");
+        }
+    }
+
     /// <summary>Called on the UI thread whenever the client sends per-iteration progress.</summary>
-    internal void UpdateIterationProgress(int iteration, double fitness, IReadOnlyList<(int nodeIndex, double value)> values)
+    internal void UpdateIterationProgress(int iteration, double fitness, int fitnessTestsThisIteration,
+        IReadOnlyList<(int nodeIndex, double value)> values)
     {
         CurrentIteration = iteration;
-        CurrentFitness   = fitness;
+        if (!double.IsNaN(fitness))
+            CurrentFitness = fitness;
+        CurrentIterationFitnessTests = fitnessTestsThisIteration;
         foreach (var (idx, val) in values)
         {
             if (_paramByIndex.TryGetValue(idx, out var vm))
@@ -268,10 +655,63 @@ internal void UpdateIterationProgress(int iteration, double fitness, IReadOnlyLi
                 : new ParameterSnapshot("?", 0, 0, v.value))
             .ToList();
         var snap = new OptimizationIterationViewModel(iteration, fitness, snapshots);
-        IterationHistory.Add(snap);
+        var existing = IterationHistory.LastOrDefault(item => item.Iteration == iteration);
+        if (existing is not null)
+        {
+            var index = IterationHistory.IndexOf(existing);
+            IterationHistory[index] = snap;
+        }
+        else
+        {
+            IterationHistory.Add(snap);
+        }
         SelectedIteration = snap;
     }
 
+    internal void UpdateSharedEstimationProgress(SharedEstimationProgress progress)
+    {
+        CurrentIteration = progress.Iteration;
+        if (!double.IsNaN(progress.BestFitness))
+            CurrentFitness = progress.BestFitness;
+        CurrentIterationFitnessTests = progress.FitnessTestsThisIteration;
+        var activeWorkers = progress.ActiveWorkerIds?.ToArray() ?? Array.Empty<string>();
+        foreach (var worker in RemoteWorkers)
+        {
+            worker.SetActiveWorkerCount(CountWorkerSlots(activeWorkers, worker.WorkerId));
+            worker.SetCompletedEvaluations(progress.EvaluationsByWorker is { } counts
+                ? CountWorkerEvaluations(counts, worker.WorkerId)
+                : 0);
+        }
+        if (progress.BestParameters is { Count: > 0 } bestParameters &&
+            bestParameters.Count == OptimizationParameters.Count)
+        {
+            var values = OptimizationParameters
+                .Select((parameter, index) => (parameter.NodeIndex, bestParameters[index]))
+                .ToArray();
+            UpdateIterationProgress(progress.Iteration, progress.BestFitness,
+                progress.FitnessTestsThisIteration, values);
+        }
+        AppendStatus($"[Estimation] iteration {progress.Iteration}: " +
+            $"{progress.FitnessTestsThisIteration} fitness test(s) completed; " +
+            $"best fitness {progress.BestFitness:G6}.");
+    }
+
+    private static int CountWorkerSlots(IReadOnlyCollection<string> workerIds, string endpointId)
+    {
+        var slotPrefix = endpointId + "#run-";
+        return workerIds.Count(workerId => workerId == endpointId ||
+            workerId.StartsWith(slotPrefix, StringComparison.Ordinal));
+    }
+
+    private static int CountWorkerEvaluations(IReadOnlyDictionary<string, int> evaluationsByWorker,
+        string endpointId)
+    {
+        var slotPrefix = endpointId + "#run-";
+        return evaluationsByWorker
+            .Where(pair => pair.Key == endpointId || pair.Key.StartsWith(slotPrefix, StringComparison.Ordinal))
+            .Sum(pair => pair.Value);
+    }
+
     // ── Cancel command ────────────────────────────────────────────────────
 
     private Action? _cancelAction;
@@ -316,7 +756,8 @@ internal void SetOptimizationResults(
         AppendStatus($"[Optimization complete] {results.Count} parameter(s) ready to apply.");
     }
 
-    private bool CanApplyOptimizationResults() => HasOptimizationResults;
+    private bool CanApplyOptimizationResults()
+        => HasOptimizationResults && _optimizationSession is not null && _optimizationUser is not null;
 
     /// <summary>
     /// Applies the optimization results back into the model system session.
@@ -352,10 +793,16 @@ private void AddMessage(string message)
     }
 
     /// <summary>Marks the run as finished successfully.</summary>
-    internal void MarkFinished()
+    internal void MarkFinished(string? completionMessage = null)
     {
         Status     = RunStatus.Finished;
-        StatusText = "Finished";
+        MarkSharedEstimationOutputAvailableIfPresent();
+        StatusText = completionMessage ??
+            (IsOptimizationRun && StatusText.StartsWith("[Estimation] converged", StringComparison.Ordinal)
+                ? StatusText
+                : "Finished");
+        if (completionMessage is not null)
+            AddMessage(completionMessage);
         OnPropertyChanged(nameof(StatusBadge));
         OnPropertyChanged(nameof(IsCompleted));
         CancelRunCommand.NotifyCanExecuteChanged();
@@ -365,6 +812,7 @@ internal void MarkFinished()
     internal void MarkError(string errorMessage, string stack, string? moduleName, Guid? elementId)
     {
         Status     = RunStatus.Error;
+        MarkSharedEstimationOutputAvailableIfPresent();
         StatusText = errorMessage;
         ErrorModuleName = moduleName;
         _errorElementId = elementId;
@@ -379,15 +827,35 @@ internal void MarkError(string errorMessage, string stack, string? moduleName, G
         CancelRunCommand.NotifyCanExecuteChanged();
     }
 
+    private void MarkInterrupted(string message)
+    {
+        Status = RunStatus.Interrupted;
+        MarkSharedEstimationOutputAvailableIfPresent();
+        StatusText = message;
+        AddMessage(message);
+        OnPropertyChanged(nameof(StatusBadge));
+        OnPropertyChanged(nameof(IsCompleted));
+        CancelRunCommand.NotifyCanExecuteChanged();
+    }
+
+    internal void MarkConnectionLost()
+        => MarkInterrupted("RunServer connection was lost; the run status is unknown until it reconnects.");
+
+    private void MarkSharedEstimationOutputAvailableIfPresent()
+    {
+        if (IsRemoteSharedEstimation && Directory.Exists(RunDirectory))
+            MarkArtifactsAvailable();
+    }
+
     /// <summary>
     /// Returns navigation context for the current failing element, when available.
     /// </summary>
     internal bool TryGetErrorNavigationTarget(out ModelSystemSession session, out User user, out Guid elementId)
     {
-        session = _session;
-        user = _user;
+        session = _session!;
+        user = _user!;
         elementId = Guid.Empty;
-        if (!_errorElementId.HasValue)
+        if (!_errorElementId.HasValue || _session is null || _user is null)
             return false;
         elementId = _errorElementId.Value;
         return true;
diff --git a/src/XTMF2.GUI/ViewModels/RunsViewModel.cs b/src/XTMF2.GUI/ViewModels/RunsViewModel.cs
index 8be9faf4..93e72674 100644
--- a/src/XTMF2.GUI/ViewModels/RunsViewModel.cs
+++ b/src/XTMF2.GUI/ViewModels/RunsViewModel.cs
@@ -23,7 +23,10 @@ You should have received a copy of the GNU General Public License
 using Avalonia.Threading;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
 using XTMF2.Editing;
+using XTMF2.GUI.Properties;
 
 namespace XTMF2.GUI.ViewModels;
 
@@ -73,20 +76,130 @@ internal RunViewModel AddRun(string runId, string runName, string runDirectory,
         return vm;
     }
 
+    internal RunViewModel RestoreRemoteRun(RemoteRunSnapshot snapshot, string runServer, Action cancelAction)
+    {
+        lock (_runsLock)
+        {
+            if (_runsById.TryGetValue(snapshot.RunId, out var existing))
+            {
+                void ApplySnapshot()
+                {
+                    existing.SetRunServer(runServer);
+                    existing.ApplyRecoveredSnapshot(snapshot);
+                }
+                if (Dispatcher.UIThread.CheckAccess())
+                    ApplySnapshot();
+                else
+                    Dispatcher.UIThread.Post(ApplySnapshot);
+                return existing;
+            }
+        }
+
+        var vm = new RunViewModel(snapshot, runServer, cancelAction);
+        lock (_runsLock)
+        {
+            if (_runsById.TryGetValue(snapshot.RunId, out var existing))
+                return existing;
+            _runsById.Add(snapshot.RunId, vm);
+        }
+        Dispatcher.UIThread.Post(() =>
+        {
+            Runs.Add(vm);
+            SelectedRun ??= vm;
+        });
+        return vm;
+    }
+
+    internal RunViewModel RestoreSharedEstimationRun(
+        SharedEstimationJobSnapshot snapshot, string runServer, Action cancelAction)
+    {
+        lock (_runsLock)
+        {
+            if (_runsById.TryGetValue(snapshot.RunId, out var existing))
+            {
+                void ApplySnapshot()
+                {
+                    existing.SetRunServer(runServer);
+                    existing.ApplyRecoveredSharedEstimationSnapshot(snapshot);
+                }
+                if (Dispatcher.UIThread.CheckAccess())
+                    ApplySnapshot();
+                else
+                    Dispatcher.UIThread.Post(ApplySnapshot);
+                return existing;
+            }
+        }
+
+        var vm = new RunViewModel(snapshot, runServer, cancelAction);
+        lock (_runsLock)
+        {
+            if (_runsById.TryGetValue(snapshot.RunId, out var existing))
+                return existing;
+            _runsById.Add(snapshot.RunId, vm);
+        }
+        Dispatcher.UIThread.Post(() =>
+        {
+            Runs.Add(vm);
+            SelectedRun ??= vm;
+        });
+        return vm;
+    }
+
+    internal void ConfigureRecoveredSharedEstimationWorkers(string runId,
+        IReadOnlyList<RunServerEndpoint> endpoints, IReadOnlyCollection<string> activeWorkerIds,
+        Func<string, string?> addWorker, Func<string, string?> removeWorker,
+        IReadOnlyDictionary<string, int>? configuredWorkerCounts = null)
+    {
+        var vm = FindRun(runId);
+        if (vm is null) return;
+        Dispatcher.UIThread.Post(() => vm.SetRemoteEstimationWorkers(
+            endpoints, activeWorkerIds, addWorker, removeWorker, configuredWorkerCounts));
+    }
+
+    internal bool BindRecoveredRun(string runId, ModelSystemSession session, User user,
+        IReadOnlyList<(int nodeIndex, string name, double min, double max)> metadata)
+    {
+        var vm = FindRun(runId);
+        if (vm is null)
+            return false;
+        Dispatcher.UIThread.Post(() => vm.BindRecoveredRun(session, user, metadata));
+        return true;
+    }
+
+    internal bool SetRecoveredRunOutputDirectory(string runId, string directory)
+    {
+        var vm = FindRun(runId);
+        if (vm is null)
+            return false;
+        Dispatcher.UIThread.Post(() => vm.SetLocalOutputDirectory(directory));
+        return true;
+    }
+
     /// <summary>
     /// Marks the run with <paramref name="runId"/> as finished.  Safe to call from any thread.
     /// </summary>
-    internal void NotifyFinished(string runId)
+    internal void NotifyFinished(string runId, string? completionMessage = null)
     {
         var vm = FindRun(runId);
         if (vm is null) return;
         Dispatcher.UIThread.Post(() =>
         {
-            vm.MarkFinished();
+            vm.MarkFinished(completionMessage);
             SystemAlert.ShowRunFinished(vm.RunName);
         });
     }
 
+    internal void NotifyConnectionLost(string runId)
+    {
+        var vm = FindRun(runId);
+        if (vm is null) return;
+        Dispatcher.UIThread.Post(() =>
+        {
+            if (vm.Status == RunStatus.Running)
+                vm.MarkConnectionLost();
+        });
+    }
+
     /// <summary>
     /// Marks the run with <paramref name="runId"/> as failed.  Safe to call from any thread.
     /// </summary>
@@ -123,6 +236,13 @@ internal void NotifyArtifactsTransferred(string runId)
         });
     }
 
+    internal void NotifyRemoteOutputAvailability(string runId, bool available)
+    {
+        var vm = FindRun(runId);
+        if (vm is null) return;
+        Dispatcher.UIThread.Post(() => vm.RemoteOutputAvailable = available && !vm.ArtifactsAvailable);
+    }
+
     internal void NotifyArtifactTransferFailed(string runId, string error)
     {
         var vm = FindRun(runId);
@@ -130,6 +250,20 @@ internal void NotifyArtifactTransferFailed(string runId, string error)
         Dispatcher.UIThread.Post(() => vm.MarkArtifactTransferFailed(error));
     }
 
+    internal void NotifyRemoteReceiptCompleted(string runId)
+    {
+        var vm = FindRun(runId);
+        if (vm is null) return;
+        Dispatcher.UIThread.Post(() => vm.SetRemoteReceiptPending(false));
+    }
+
+    internal void NotifyRemoteReceiptPending(string runId, bool pending)
+    {
+        var vm = FindRun(runId);
+        if (vm is null || !vm.IsRemoteRun) return;
+        Dispatcher.UIThread.Post(() => vm.SetRemoteReceiptPending(pending));
+    }
+
     /// <summary>
     /// Stores optimization results on the run entry so the user can apply them.
     /// Safe to call from any thread.
@@ -150,12 +284,56 @@ internal void NotifyOptimizationResults(
     /// Safe to call from any thread.
     /// </summary>
     internal void NotifyIterationProgress(
-        string runId, int iteration, double fitness,
+        string runId, int iteration, double fitness, int fitnessTestsThisIteration,
         IReadOnlyList<(int nodeIndex, double value)> values)
     {
         var vm = FindRun(runId);
         if (vm is null) return;
-        Dispatcher.UIThread.Post(() => vm.UpdateIterationProgress(iteration, fitness, values));
+        Dispatcher.UIThread.Post(() => vm.UpdateIterationProgress(
+            iteration, fitness, fitnessTestsThisIteration, values));
+    }
+
+    internal void NotifyRemoteWorkerSnapshot(string runId, IReadOnlyCollection<string> activeWorkerIds)
+    {
+        var vm = FindRun(runId);
+        if (vm is null) return;
+        Dispatcher.UIThread.Post(() => vm.ApplyRemoteWorkerSnapshot(activeWorkerIds));
+    }
+
+    internal void NotifyRemoteWorkerDisconnected(string runId, string workerId)
+    {
+        var vm = FindRun(runId);
+        if (vm is null) return;
+        Dispatcher.UIThread.Post(() => vm.MarkRemoteWorkerDisconnected(workerId));
+    }
+
+    internal void ReconnectRemoteWorker(string runId, string workerId)
+    {
+        var vm = FindRun(runId);
+        if (vm is null) return;
+        Dispatcher.UIThread.Post(() => vm.ReconnectRemoteWorker(workerId));
+    }
+
+    internal void NotifyRemoteWorkerAcknowledgement(
+        SharedEstimationWorkerControlAcknowledgement acknowledgement)
+    {
+        var vm = FindRun(acknowledgement.RunId);
+        if (vm is null) return;
+        Dispatcher.UIThread.Post(() => vm.ApplyRemoteWorkerAcknowledgement(acknowledgement));
+    }
+
+    internal void NotifySharedEstimationProgress(SharedEstimationProgress progress)
+    {
+        var vm = FindRun(progress.RunId);
+        if (vm is null) return;
+        Dispatcher.UIThread.Post(() => vm.UpdateSharedEstimationProgress(progress));
+    }
+
+    internal void NotifyRecoveredSharedEstimationCompletion(SharedEstimationCompletion completion)
+    {
+        var vm = FindRun(completion.RunId);
+        if (vm is null) return;
+        Dispatcher.UIThread.Post(() => vm.ApplyRecoveredSharedEstimationCompletion(completion));
     }
 
     private RunViewModel? FindRun(string runId)
@@ -198,23 +376,4 @@ private void RemoveRun(RunViewModel vm)
             SelectedRun = Runs.Count > 0 ? Runs[Math.Min(idx, Runs.Count - 1)] : null;
     }
 
-    /// <summary>
-    /// Removes all runs that have finished or errored from the list.
-    /// </summary>
-    [RelayCommand]
-    private void ClearCompletedRuns()
-    {
-        var wasSelected = SelectedRun;
-        for (var i = Runs.Count - 1; i >= 0; i--)
-        {
-            if (Runs[i].Status != RunStatus.Running)
-            {
-                lock (_runsLock)
-                    _runsById.Remove(Runs[i].RunId);
-                Runs.RemoveAt(i);
-            }
-        }
-        if (wasSelected is not null && !Runs.Contains(wasSelected))
-            SelectedRun = Runs.FirstOrDefault();
-    }
 }
diff --git a/src/XTMF2.GUI/Views/EstimationAlgorithmConfigDialog.axaml.cs b/src/XTMF2.GUI/Views/EstimationAlgorithmConfigDialog.axaml.cs
index d1de02c4..40f5e285 100644
--- a/src/XTMF2.GUI/Views/EstimationAlgorithmConfigDialog.axaml.cs
+++ b/src/XTMF2.GUI/Views/EstimationAlgorithmConfigDialog.axaml.cs
@@ -16,8 +16,10 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
+using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Linq;
 using Avalonia.Controls;
 using Avalonia.Interactivity;
 using XTMF2.Bus.Optimization;
@@ -59,8 +61,10 @@ public EstimationAlgorithmConfigDialog(
         EstimationAlgorithmConfig currentConfig)
     {
         _editorVm = editorVm;
-        _currentConfig = currentConfig;
-        Parameters = currentConfig.GetParameters();
+        _currentConfig = currentConfig.Clone();
+        Parameters = _currentConfig.GetParameters()
+            .OrderBy(parameter => parameter.Label, StringComparer.CurrentCultureIgnoreCase)
+            .ToArray();
         DataContext = this;
         InitializeComponent();
     }
diff --git a/src/XTMF2.GUI/Views/EstimationDialog.axaml b/src/XTMF2.GUI/Views/EstimationDialog.axaml
index ea0732be..32fc7e04 100644
--- a/src/XTMF2.GUI/Views/EstimationDialog.axaml
+++ b/src/XTMF2.GUI/Views/EstimationDialog.axaml
@@ -52,6 +52,22 @@
                 <Button Grid.Column="2" Content="Clear"
                         Click="ClearFitnessNode_Click" Margin="4,0,0,0" Padding="10,5"/>
             </Grid>
+            <Grid ColumnDefinitions="150,320,Auto,*" Margin="0,8,0,0">
+                <TextBlock Grid.Column="0" Text="Input Directory:" VerticalAlignment="Center" FontSize="12" Margin="0,0,8,0"/>
+                <ComboBox Grid.Column="1"
+                          ItemsSource="{Binding InputDirectoryNodes}"
+                          SelectedItem="{Binding SelectedInputDirectoryNode, Mode=TwoWay}"
+                          PlaceholderText="(none)"
+                          FontSize="12"
+                          HorizontalAlignment="Left"
+                          Width="320">
+                    <ComboBox.ItemTemplate>
+                        <DataTemplate x:DataType="xtmf2:Node">
+                            <TextBlock Text="{Binding Name}"/>
+                        </DataTemplate>
+                    </ComboBox.ItemTemplate>
+                </ComboBox>
+            </Grid>
             <!-- Algorithm + Objective row -->
             <Grid ColumnDefinitions="150,320,Auto,*,Auto,180" Margin="0,8,0,0">
                 <!-- Algorithm -->
diff --git a/src/XTMF2.GUI/Views/EstimationDialog.axaml.cs b/src/XTMF2.GUI/Views/EstimationDialog.axaml.cs
index 5a694995..7f5ea301 100644
--- a/src/XTMF2.GUI/Views/EstimationDialog.axaml.cs
+++ b/src/XTMF2.GUI/Views/EstimationDialog.axaml.cs
@@ -164,6 +164,22 @@ public Node? SelectedFitnessNode
 
     public List<Node> FunctionNodes => EditorVm?.GetFunctionNodes() ?? new();
 
+    public List<Node> InputDirectoryNodes => EditorVm?.GetInputDirectoryNodes() ?? new();
+
+    private Node? _selectedInputDirectoryNode;
+    public Node? SelectedInputDirectoryNode
+    {
+        get => _selectedInputDirectoryNode;
+        set
+        {
+            if (_selectedInputDirectoryNode == value) return;
+            _selectedInputDirectoryNode = value;
+            Raise(nameof(SelectedInputDirectoryNode));
+            if (!_suppressFitnessCommand)
+                EditorVm.Session.SetEstimationInputDirectoryNode(EditorVm.User, value, out _);
+        }
+    }
+
     // ── Group enabled toggle ──────────────────────────────────────────────
 
     public bool GroupIsEnabled
@@ -215,6 +231,7 @@ public EstimationDialog(ModelSystemEditorViewModel editorVm)
         SelectedGroup = GroupVms.FirstOrDefault();
         _suppressFitnessCommand = true;
         SelectedFitnessNode = EditorVm.Session.ModelSystem.EstimationFitnessNode;
+        SelectedInputDirectoryNode = EditorVm.Session.ModelSystem.EstimationInputDirectoryNode;
         _suppressFitnessCommand = false;
         // Sync algorithm selection without firing a command change.
         _suppressAlgorithmCommand = true;
diff --git a/src/XTMF2.GUI/Views/OptimizationProgressWindow.axaml b/src/XTMF2.GUI/Views/OptimizationProgressWindow.axaml
index cdb13828..7dd57012 100644
--- a/src/XTMF2.GUI/Views/OptimizationProgressWindow.axaml
+++ b/src/XTMF2.GUI/Views/OptimizationProgressWindow.axaml
@@ -32,6 +32,9 @@
                 <TextBlock Text="Iteration:" FontSize="12" Opacity="0.5" VerticalAlignment="Center"/>
                 <TextBlock Text="{Binding CurrentIteration}"
                            FontSize="12" FontWeight="SemiBold" VerticalAlignment="Center"/>
+                <TextBlock Text="Fitness tests:" FontSize="12" Opacity="0.5" VerticalAlignment="Center" Margin="8,0,0,0"/>
+                <TextBlock Text="{Binding CurrentIterationFitnessTests}"
+                           FontSize="12" FontWeight="SemiBold" VerticalAlignment="Center"/>
                 <TextBlock Text="Fitness:" FontSize="12" Opacity="0.5" VerticalAlignment="Center" Margin="8,0,0,0"/>
                 <TextBlock Text="{Binding CurrentFitness, StringFormat=G6}"
                            FontSize="12" FontWeight="SemiBold" VerticalAlignment="Center"
diff --git a/src/XTMF2.GUI/Views/RemoteEstimationWorkersWindow.axaml b/src/XTMF2.GUI/Views/RemoteEstimationWorkersWindow.axaml
new file mode 100644
index 00000000..38c5f638
--- /dev/null
+++ b/src/XTMF2.GUI/Views/RemoteEstimationWorkersWindow.axaml
@@ -0,0 +1,99 @@
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:vm="clr-namespace:XTMF2.GUI.ViewModels"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    mc:Ignorable="d"
+        x:Class="XTMF2.GUI.Views.RemoteEstimationWorkersWindow"
+        x:DataType="vm:RunViewModel"
+        x:CompileBindings="True"
+        Classes="neon-dialog"
+        Title="Estimation Workers"
+        Width="500"
+        Height="420"
+        MinWidth="380"
+        MinHeight="280"
+        WindowStartupLocation="CenterOwner"
+        CanResize="True">
+
+    <Grid RowDefinitions="Auto,*,Auto" Margin="16">
+        <StackPanel Grid.Row="0" Margin="0,0,0,10">
+            <TextBlock Text="{Binding RunName}"
+                       FontSize="18"
+                       FontWeight="Bold"
+                       Foreground="{DynamicResource DlgAccent}"
+                       TextTrimming="CharacterEllipsis"/>
+            <TextBlock Text="Add or remove RunServers participating in this estimation."
+                       FontSize="12"
+                       Opacity="0.65"
+                       Margin="0,4,0,0"
+                       TextWrapping="Wrap"/>
+        </StackPanel>
+
+        <Border Grid.Row="1" Classes="dlg-list" ClipToBounds="True">
+            <ScrollViewer VerticalScrollBarVisibility="Auto">
+                <ItemsControl x:Name="RemoteWorkersList" ItemsSource="{Binding RemoteWorkers}">
+                    <ItemsControl.ItemTemplate>
+                        <DataTemplate x:DataType="vm:RemoteEstimationWorkerViewModel"
+                                      x:CompileBindings="False">
+                            <Grid ColumnDefinitions="*,Auto,Auto"
+                                  Margin="8,6">
+                                <StackPanel VerticalAlignment="Center">
+                                    <TextBlock Text="{Binding Name}"
+                                               FontSize="13"
+                                               FontWeight="SemiBold"
+                                               TextTrimming="CharacterEllipsis"/>
+                                    <TextBlock Text="{Binding Endpoint.Address}"
+                                               FontSize="11"
+                                               Opacity="0.55"
+                                               TextTrimming="CharacterEllipsis"/>
+                                </StackPanel>
+                                <StackPanel Grid.Column="1"
+                                        VerticalAlignment="Center"
+                                        Margin="8,0"
+                                        Spacing="2">
+                                    <TextBlock Text="Active"
+                                           IsVisible="{Binding IsActive}"
+                                           Opacity="0.65"/>
+                                     <TextBlock Text="{Binding ActiveWorkerCountDisplay}"
+                                         Opacity="0.65"/>
+                                     <TextBlock Text="{Binding EvaluationCountDisplay}"
+                                         Opacity="0.65"/>
+                                    <TextBlock Text="Updating..."
+                                           IsVisible="{Binding IsBusy}"
+                                           Opacity="0.65"/>
+                                </StackPanel>
+                                <Button Grid.Column="2"
+                                        Content="Add"
+                                        IsVisible="{Binding IsInactive}"
+                                        IsEnabled="{Binding CanAdd}"
+                                        Command="{Binding $parent[Window].DataContext.AddRemoteWorkerCommand}"
+                                        CommandParameter="{Binding}"
+                                        Padding="10,4"/>
+                                <Button Grid.Column="2"
+                                        Content="Remove"
+                                        IsVisible="{Binding IsActive}"
+                                        IsEnabled="{Binding CanRemove}"
+                                        Command="{Binding $parent[Window].DataContext.RemoveRemoteWorkerCommand}"
+                                        CommandParameter="{Binding}"
+                                        Padding="10,4"/>
+                            </Grid>
+                        </DataTemplate>
+                    </ItemsControl.ItemTemplate>
+                </ItemsControl>
+            </ScrollViewer>
+        </Border>
+
+        <Border Grid.Row="2"
+                BorderBrush="{DynamicResource DlgSep}"
+                BorderThickness="0,1,0,0"
+                Margin="0,8,0,0"
+                Padding="0,8,0,0">
+            <Button Content="Close"
+                    HorizontalAlignment="Right"
+                    Padding="24,8"
+                    IsCancel="True"
+                    Click="CloseButton_Click"/>
+        </Border>
+    </Grid>
+</Window>
\ No newline at end of file
diff --git a/src/XTMF2.GUI/Views/RemoteEstimationWorkersWindow.axaml.cs b/src/XTMF2.GUI/Views/RemoteEstimationWorkersWindow.axaml.cs
new file mode 100644
index 00000000..553614b9
--- /dev/null
+++ b/src/XTMF2.GUI/Views/RemoteEstimationWorkersWindow.axaml.cs
@@ -0,0 +1,24 @@
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using XTMF2.GUI.ViewModels;
+
+namespace XTMF2.GUI.Views;
+
+/// <summary>
+/// Modeless window for managing the RunServers assigned to a shared estimation.
+/// </summary>
+public partial class RemoteEstimationWorkersWindow : Window
+{
+    public RemoteEstimationWorkersWindow()
+    {
+        InitializeComponent();
+    }
+
+    public RemoteEstimationWorkersWindow(RunViewModel run) : this()
+    {
+        DataContext = run;
+        Title = $"Estimation Workers - {run.RunName}";
+    }
+
+    private void CloseButton_Click(object? sender, RoutedEventArgs e) => Close();
+}
\ No newline at end of file
diff --git a/src/XTMF2.GUI/Views/RunConfigurationDialog.axaml b/src/XTMF2.GUI/Views/RunConfigurationDialog.axaml
index 062346ee..284dadbc 100644
--- a/src/XTMF2.GUI/Views/RunConfigurationDialog.axaml
+++ b/src/XTMF2.GUI/Views/RunConfigurationDialog.axaml
@@ -10,7 +10,7 @@
         WindowStartupLocation="CenterOwner"
         CanResize="False">
 
-    <Grid RowDefinitions="Auto,Auto,Auto,Auto,Auto,Auto" Margin="20">
+    <Grid RowDefinitions="Auto,Auto,Auto,Auto,Auto,Auto,Auto,Auto" Margin="20">
         <TextBlock Grid.Row="0"
                    Text="Enter a name for this run:"
                    FontSize="14"
@@ -30,8 +30,14 @@
                TextWrapping="Wrap"
                IsVisible="{Binding IsRunNameInvalid}"/>
 
-        <StackPanel Grid.Row="3"
-                    IsVisible="{Binding IsRunServerSelectionVisible}"
+        <CheckBox Grid.Row="3"
+              Content="Use multiple RunServers for distributed estimation"
+              IsVisible="{Binding AllowMultipleRunServers}"
+              IsChecked="{Binding UseMultipleRunServers, Mode=TwoWay}"
+              Margin="0,14,0,0"/>
+
+        <StackPanel Grid.Row="4"
+                    IsVisible="{Binding IsSingleRunServerSelectionVisible}"
                     Margin="0,14,0,0"
                     Spacing="6">
             <TextBlock Text="RunServer"
@@ -50,6 +56,58 @@
         </StackPanel>
 
         <StackPanel Grid.Row="4"
+                IsVisible="{Binding IsMultipleRunServerSelectionVisible}"
+                    Margin="0,14,0,0"
+                    Spacing="6">
+            <TextBlock Text="Estimation coordinator"
+                       FontSize="14"/>
+            <ComboBox ItemsSource="{Binding RunServers}"
+                      SelectedItem="{Binding SelectedCoordinatorRunServer}"
+                      HorizontalAlignment="Stretch"
+                      Margin="0,0,0,4">
+                <ComboBox.ItemTemplate>
+                    <DataTemplate>
+                        <TextBlock Text="{Binding Name}"/>
+                    </DataTemplate>
+                </ComboBox.ItemTemplate>
+            </ComboBox>
+            <TextBlock Text="Worker RunServers (the other selected servers)"
+                       FontSize="14"/>
+            <Grid ColumnDefinitions="*,Auto" Margin="4,0,8,0">
+                <TextBlock Text="RunServer" FontSize="12" Opacity="0.65"/>
+                <TextBlock Grid.Column="1" Text="Runs" FontSize="12" Opacity="0.65"
+                           HorizontalAlignment="Center" Width="120"/>
+            </Grid>
+            <ScrollViewer MaxHeight="180" VerticalScrollBarVisibility="Auto">
+                <ItemsControl ItemsSource="{Binding RunServerChoices}">
+                    <ItemsControl.ItemTemplate>
+                        <DataTemplate x:DataType="local:RunServerChoice">
+                            <Grid ColumnDefinitions="*,Auto" Margin="4,2">
+                                <CheckBox Content="{Binding Name}"
+                                          IsChecked="{Binding IsSelected, Mode=TwoWay}"
+                                          VerticalAlignment="Center"
+                                          MinHeight="32"/>
+                                <NumericUpDown Grid.Column="1"
+                                               Value="{Binding ConcurrentRuns, Mode=TwoWay}"
+                                               Minimum="1"
+                                               Maximum="32"
+                                               Increment="1"
+                                               FormatString="0"
+                                               Width="120"
+                                               IsEnabled="{Binding CanConfigureRuns}"
+                                               HorizontalContentAlignment="Right"/>
+                            </Grid>
+                        </DataTemplate>
+                    </ItemsControl.ItemTemplate>
+                </ItemsControl>
+            </ScrollViewer>
+            <TextBlock Text="{Binding SelectedRunServerSummary}"
+                       FontSize="12"
+                       Foreground="{DynamicResource DlgMutedFg}"
+                       TextWrapping="Wrap"/>
+        </StackPanel>
+
+        <StackPanel Grid.Row="5"
                 IsVisible="{Binding IsStartSelectionVisible}"
                 Margin="0,14,0,0"
                 Spacing="6">
@@ -61,7 +119,15 @@
                 TabIndex="2"/>
         </StackPanel>
 
-        <StackPanel Grid.Row="5"
+        <ScrollViewer Grid.Row="6"
+                      MaxHeight="260"
+                      IsVisible="{Binding IsPathOverridesVisible}"
+                      Margin="0,14,0,0"
+                      VerticalScrollBarVisibility="Auto">
+            <StackPanel x:Name="PathOverridesPanel" Spacing="8"/>
+        </ScrollViewer>
+
+        <StackPanel Grid.Row="7"
                     Orientation="Horizontal"
                     HorizontalAlignment="Right"
                     Spacing="10"
diff --git a/src/XTMF2.GUI/Views/RunConfigurationDialog.axaml.cs b/src/XTMF2.GUI/Views/RunConfigurationDialog.axaml.cs
index af1bc657..d6578f28 100644
--- a/src/XTMF2.GUI/Views/RunConfigurationDialog.axaml.cs
+++ b/src/XTMF2.GUI/Views/RunConfigurationDialog.axaml.cs
@@ -1,8 +1,11 @@
 using Avalonia.Controls;
+using Avalonia.Layout;
+using Avalonia.Media;
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.IO;
 using System.Linq;
@@ -10,19 +13,120 @@
 
 namespace XTMF2.GUI.Views;
 
+public sealed class RunServerChoice : INotifyPropertyChanged
+{
+    private bool _isSelected;
+    private bool _isCoordinator;
+    private int _concurrentRuns = 1;
+
+    public RunServerChoice(RunServerEndpoint endpoint, bool isSelected)
+    {
+        Endpoint = endpoint;
+        _isSelected = isSelected;
+    }
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+    public RunServerEndpoint Endpoint { get; }
+    public string Name => Endpoint.Name;
+    public bool CanConfigureRuns => IsSelected || _isCoordinator;
+
+    public bool IsSelected
+    {
+        get => _isSelected;
+        set
+        {
+            if (_isSelected == value) return;
+            _isSelected = value;
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsSelected)));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CanConfigureRuns)));
+        }
+    }
+
+    public void SetIsCoordinator(bool value)
+    {
+        if (_isCoordinator == value) return;
+        _isCoordinator = value;
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CanConfigureRuns)));
+    }
+
+    public int ConcurrentRuns
+    {
+        get => _concurrentRuns;
+        set
+        {
+            var boundedValue = Math.Clamp(value, 1, 32);
+            if (_concurrentRuns == boundedValue) return;
+            _concurrentRuns = boundedValue;
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(ConcurrentRuns)));
+        }
+    }
+}
+
 public partial class RunConfigurationDialog : Window, INotifyPropertyChanged
 {
+    public sealed record PathParameter(int NodeIndex, Guid NodeId, string Name, string Value);
+
     private string? _runName;
     private RunServerEndpoint? _selectedRunServer;
+    private RunServerEndpoint? _selectedCoordinatorRunServer;
     private string? _selectedStartName;
+    private bool _useMultipleRunServers;
+    private readonly IReadOnlyList<PathParameter> _pathParameters;
+    private readonly Dictionary<string, Dictionary<int, string>> _pathOverrides = new(StringComparer.Ordinal);
 
     public new event PropertyChangedEventHandler? PropertyChanged;
 
     public IReadOnlyList<RunServerEndpoint> RunServers { get; }
     public IReadOnlyList<string> StartNames { get; }
+    public ObservableCollection<RunServerChoice> RunServerChoices { get; } = new();
+    public bool AllowMultipleRunServers { get; }
+    public IReadOnlyList<RunServerEndpoint> SelectedRunServers => RunServerChoices
+        .Where(choice => choice.IsSelected)
+        .Select(choice => choice.Endpoint)
+        .ToArray();
+    public IReadOnlyDictionary<string, int> ConcurrentRunsByEndpoint => RunServerChoices
+        .Where(choice => choice.IsSelected || choice.Endpoint.Id == SelectedCoordinatorRunServer?.Id)
+        .DistinctBy(choice => choice.Endpoint.Id, StringComparer.Ordinal)
+        .ToDictionary(choice => choice.Endpoint.Id, choice => choice.ConcurrentRuns, StringComparer.Ordinal);
+    public RunServerEndpoint? SelectedCoordinatorRunServer
+    {
+        get => _selectedCoordinatorRunServer;
+        set
+        {
+            if (_selectedCoordinatorRunServer == value) return;
+            _selectedCoordinatorRunServer = value;
+            foreach (var choice in RunServerChoices)
+                choice.SetIsCoordinator(choice.Endpoint.Id == value?.Id);
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(SelectedCoordinatorRunServer)));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(ConcurrentRunsByEndpoint)));
+        }
+    }
+    public IReadOnlyDictionary<string, IReadOnlyDictionary<int, string>> PathOverrides =>
+        _pathOverrides.ToDictionary(pair => pair.Key, pair => (IReadOnlyDictionary<int, string>)pair.Value);
 
     public bool IsRunServerSelectionVisible => RunServers.Count > 1;
+    public bool IsSingleRunServerSelectionVisible => IsRunServerSelectionVisible && !UseMultipleRunServers;
+    public bool IsMultipleRunServerSelectionVisible => AllowMultipleRunServers && UseMultipleRunServers;
     public bool IsStartSelectionVisible => StartNames.Count > 1;
+    public bool IsPathOverridesVisible => IsMultipleRunServerSelectionVisible && _pathParameters.Count > 0 && SelectedRunServers.Count > 0;
+
+    public bool UseMultipleRunServers
+    {
+        get => _useMultipleRunServers;
+        set
+        {
+            if (_useMultipleRunServers == value) return;
+            _useMultipleRunServers = value && AllowMultipleRunServers;
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(UseMultipleRunServers)));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsSingleRunServerSelectionVisible)));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsMultipleRunServerSelectionVisible)));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsPathOverridesVisible)));
+            RebuildPathEditors();
+        }
+    }
+    public string SelectedRunServerSummary => SelectedRunServers.Count == 0
+        ? "No RunServers selected"
+        : $"Selected ({SelectedRunServers.Count}): {string.Join(", ", SelectedRunServers.Select(server => server.Name))}";
 
     public string? RunName
     {
@@ -69,23 +173,39 @@ public RunConfigurationDialog()
     {
         RunServers = [];
         StartNames = [];
+        _pathParameters = [];
+        AllowMultipleRunServers = false;
         InitializeComponent();
         DataContext = this;
+        RebuildPathEditors();
         RegisterEscapeClose();
     }
 
     public RunConfigurationDialog(string title, string defaultRunName,
                                   IReadOnlyList<RunServerEndpoint> runServers,
-                                  IReadOnlyList<string> startNames)
+                                  IReadOnlyList<string> startNames,
+                                  bool allowMultipleRunServers = false,
+                                  IReadOnlyList<PathParameter>? pathParameters = null)
     {
         RunServers = runServers;
         StartNames = startNames;
+        for (var index = 0; index < runServers.Count; index++)
+        {
+            var choice = new RunServerChoice(runServers[index], index == 0);
+            choice.PropertyChanged += OnRunServerChoiceChanged;
+            RunServerChoices.Add(choice);
+        }
+        AllowMultipleRunServers = allowMultipleRunServers;
+        _pathParameters = pathParameters ?? [];
         RunName = defaultRunName;
         SelectedRunServer = runServers.Count > 0 ? runServers[0] : null;
+        SelectedCoordinatorRunServer = runServers.Count > 0 ? runServers[0] : null;
+        InitializePathOverrides();
         SelectedStartName = startNames.Count > 0 ? startNames[0] : null;
         InitializeComponent();
         Title = title;
         DataContext = this;
+        RebuildPathEditors();
         RegisterEscapeClose();
         Opened += (_, _) =>
         {
@@ -104,13 +224,95 @@ private void RegisterEscapeClose() =>
 
     private void OK_Click(object? sender, RoutedEventArgs e)
     {
-        if (!IsRunNameValid || SelectedRunServer is null || SelectedStartName is null)
+        if (!IsRunNameValid || SelectedRunServer is null || SelectedStartName is null ||
+            (AllowMultipleRunServers && SelectedRunServers.Count == 0))
             return;
 
         WasCancelled = false;
+        SavePathOverrides();
         Close();
     }
 
+    private void OnRunServerChoiceChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName == nameof(RunServerChoice.IsSelected))
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(SelectedRunServers)));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(ConcurrentRunsByEndpoint)));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsPathOverridesVisible)));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(SelectedRunServerSummary)));
+            RebuildPathEditors();
+        }
+        else if (e.PropertyName == nameof(RunServerChoice.ConcurrentRuns))
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(ConcurrentRunsByEndpoint)));
+        }
+    }
+
+    private void InitializePathOverrides()
+    {
+        foreach (var endpoint in RunServers)
+        {
+            _pathOverrides[endpoint.Id] = _pathParameters.ToDictionary(parameter => parameter.NodeIndex,
+                parameter => endpoint.BasicParameterOverrides.TryGetValue(parameter.NodeId.ToString("D"), out var value)
+                    ? value
+                    : parameter.Value);
+        }
+    }
+
+    private void SavePathOverrides()
+    {
+        if (_pathParameters.Count == 0)
+            return;
+
+        foreach (var endpoint in SelectedRunServers)
+        {
+            endpoint.BasicParameterOverrides.Clear();
+            foreach (var parameter in _pathParameters)
+                endpoint.BasicParameterOverrides[parameter.NodeId.ToString("D")] =
+                    _pathOverrides[endpoint.Id][parameter.NodeIndex];
+
+            var configuredEndpoint = Settings.Default.RunServers
+                .FirstOrDefault(candidate => candidate.Id == endpoint.Id);
+            if (configuredEndpoint is null)
+                continue;
+            configuredEndpoint.BasicParameterOverrides =
+                new Dictionary<string, string>(endpoint.BasicParameterOverrides, StringComparer.OrdinalIgnoreCase);
+        }
+        Settings.Default.Save();
+    }
+
+    private void RebuildPathEditors()
+    {
+        if (!AllowMultipleRunServers || _pathParameters.Count == 0)
+            return;
+
+        PathOverridesPanel.Children.Clear();
+        PathOverridesPanel.Children.Add(new TextBlock
+        {
+            Text = "Worker path values",
+            FontSize = 14,
+            Margin = new Avalonia.Thickness(0, 0, 0, 4)
+        });
+        foreach (var endpoint in SelectedRunServers)
+        {
+            var values = _pathOverrides[endpoint.Id];
+            var editor = new StackPanel { Spacing = 4 };
+            editor.Children.Add(new TextBlock { Text = endpoint.Name, FontWeight = FontWeight.Bold });
+            foreach (var parameter in _pathParameters)
+            {
+                var row = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), ColumnSpacing = 8 };
+                row.Children.Add(new TextBlock { Text = parameter.Name, VerticalAlignment = VerticalAlignment.Center });
+                var textBox = new TextBox { Text = values[parameter.NodeIndex], HorizontalAlignment = HorizontalAlignment.Stretch };
+                Grid.SetColumn(textBox, 1);
+                textBox.TextChanged += (_, _) => values[parameter.NodeIndex] = textBox.Text ?? string.Empty;
+                row.Children.Add(textBox);
+                editor.Children.Add(row);
+            }
+            PathOverridesPanel.Children.Add(editor);
+        }
+    }
+
     private void Cancel_Click(object? sender, RoutedEventArgs e)
     {
         WasCancelled = true;
diff --git a/src/XTMF2.GUI/Views/RunServerActivityWindow.axaml b/src/XTMF2.GUI/Views/RunServerActivityWindow.axaml
new file mode 100644
index 00000000..9e3771d8
--- /dev/null
+++ b/src/XTMF2.GUI/Views/RunServerActivityWindow.axaml
@@ -0,0 +1,29 @@
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        x:Class="XTMF2.GUI.Views.RunServerActivityWindow"
+        Classes="neon-dialog"
+        Title="RunServer Activity"
+        Width="1040"
+        Height="680"
+        MinWidth="760"
+        MinHeight="460"
+        WindowStartupLocation="CenterOwner"
+        KeyDown="Window_KeyDown">
+    <Grid RowDefinitions="Auto,*,Auto" Margin="18">
+        <Grid Grid.Row="0" ColumnDefinitions="*,Auto" Margin="0,0,0,12">
+            <StackPanel Spacing="3">
+                <TextBlock Text="RunServer activity" FontSize="18" FontWeight="Bold"
+                           Foreground="{DynamicResource DlgAccent}"/>
+                <TextBlock x:Name="UpdatedText" Text="Waiting for server state" FontSize="11" Opacity="0.65"/>
+            </StackPanel>
+            <Button Grid.Column="1" x:Name="RefreshButton" Content="Refresh"
+                    Click="Refresh_Click" MinWidth="96" Height="34"/>
+        </Grid>
+        <ScrollViewer Grid.Row="1" HorizontalScrollBarVisibility="Disabled"
+                      VerticalScrollBarVisibility="Auto">
+            <StackPanel x:Name="ServerList" Spacing="14"/>
+        </ScrollViewer>
+        <TextBlock Grid.Row="2" x:Name="StatusText" Margin="0,10,0,0"
+                   FontSize="11" Opacity="0.72" TextWrapping="Wrap"/>
+    </Grid>
+</Window>
\ No newline at end of file
diff --git a/src/XTMF2.GUI/Views/RunServerActivityWindow.axaml.cs b/src/XTMF2.GUI/Views/RunServerActivityWindow.axaml.cs
new file mode 100644
index 00000000..f7e51abd
--- /dev/null
+++ b/src/XTMF2.GUI/Views/RunServerActivityWindow.axaml.cs
@@ -0,0 +1,282 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Threading;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
+
+namespace XTMF2.GUI.Views;
+
+public partial class RunServerActivityWindow : Window
+{
+    private readonly RunController? _runController;
+    private readonly DispatcherTimer _refreshTimer;
+    private readonly CancellationTokenSource _lifetime = new();
+    private bool _refreshing;
+
+    public RunServerActivityWindow()
+        : this(null)
+    {
+    }
+
+    public RunServerActivityWindow(RunController? runController)
+    {
+        _runController = runController;
+        InitializeComponent();
+        _refreshTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(10) };
+        _refreshTimer.Tick += OnRefreshTimerTick;
+        Opened += OnWindowOpened;
+    }
+
+    private async void OnWindowOpened(object? sender, EventArgs e)
+    {
+        _refreshTimer.Start();
+        await RefreshAsync();
+    }
+
+    private async void OnRefreshTimerTick(object? sender, EventArgs e)
+        => await RefreshAsync();
+
+    private async void Refresh_Click(object? sender, RoutedEventArgs e)
+        => await RefreshAsync();
+
+    private async Task RefreshAsync()
+    {
+        if (_refreshing || _lifetime.IsCancellationRequested)
+            return;
+        _refreshing = true;
+        RefreshButton.IsEnabled = false;
+        StatusText.Text = "Querying connected RunServers...";
+        try
+        {
+            if (_runController is null)
+            {
+                ServerList.Children.Clear();
+                StatusText.Text = "Run controller is unavailable.";
+                return;
+            }
+
+            var servers = await _runController.QueryRunServerActivityAsync(_lifetime.Token);
+            if (_lifetime.IsCancellationRequested)
+                return;
+            RenderServers(servers);
+            UpdatedText.Text = $"Updated {DateTime.Now.ToString("HH:mm:ss", System.Globalization.CultureInfo.CurrentCulture)}";
+            var connectedCount = servers.Count(server => server.ConnectionState == RunServerConnectionState.Available);
+            StatusText.Text = $"{connectedCount} of {servers.Count} configured RunServers connected.";
+        }
+        catch (OperationCanceledException) when (_lifetime.IsCancellationRequested)
+        {
+        }
+        catch (Exception exception)
+        {
+            StatusText.Text = $"Activity refresh failed: {exception.Message}";
+        }
+        finally
+        {
+            _refreshing = false;
+            if (!_lifetime.IsCancellationRequested)
+                RefreshButton.IsEnabled = true;
+        }
+    }
+
+    internal void RenderServers(System.Collections.Generic.IReadOnlyList<RunServerActivityServerSnapshot> servers)
+    {
+        ServerList.Children.Clear();
+        if (servers.Count == 0)
+        {
+            ServerList.Children.Add(new TextBlock { Text = "No RunServers are configured.", Opacity = 0.7 });
+            return;
+        }
+
+        foreach (var server in servers.OrderBy(item => item.Endpoint.Name, StringComparer.OrdinalIgnoreCase))
+        {
+            var content = new StackPanel { Spacing = 8 };
+            var header = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
+            header.Children.Add(new TextBlock
+            {
+                Text = server.Endpoint.Name,
+                FontSize = 14,
+                FontWeight = FontWeight.SemiBold,
+                VerticalAlignment = VerticalAlignment.Center
+            });
+            var connectionStatus = new TextBlock
+            {
+                Text = server.ConnectionState switch
+                {
+                    RunServerConnectionState.Available when server.Error is null => "Connected",
+                    RunServerConnectionState.Connecting => "Connecting",
+                    RunServerConnectionState.Disconnected => "Disconnected",
+                    _ => "Query error"
+                },
+                Foreground = server.ConnectionState == RunServerConnectionState.Available && server.Error is null
+                    ? Brushes.LimeGreen
+                    : Brushes.OrangeRed,
+                VerticalAlignment = VerticalAlignment.Center
+            };
+            Grid.SetColumn(connectionStatus, 1);
+            header.Children.Add(connectionStatus);
+            content.Children.Add(header);
+
+            var endpointAddress = server.Endpoint.IsLocal
+                ? "Local RunServer"
+                : $"{server.Endpoint.Address}:{server.Endpoint.Port}";
+            content.Children.Add(new TextBlock { Text = endpointAddress, FontSize = 11, Opacity = 0.58 });
+
+            if (!string.IsNullOrWhiteSpace(server.Error))
+            {
+                content.Children.Add(new TextBlock
+                {
+                    Text = server.Error,
+                    Foreground = Brushes.OrangeRed,
+                    TextWrapping = TextWrapping.Wrap
+                });
+            }
+            else if (server.ConnectionState == RunServerConnectionState.Available)
+            {
+                var activities = server.Activities
+                    .OrderBy(item => item.State == RunServerActivityState.Running ? 0 : 1)
+                    .ThenBy(item => item.QueuePosition)
+                    .ToArray();
+                if (activities.Length == 0)
+                {
+                    content.Children.Add(new TextBlock { Text = "No active or queued jobs.", Opacity = 0.65 });
+                }
+                else
+                {
+                    foreach (var activity in activities)
+                        content.Children.Add(CreateActivityRow(activity, server.Endpoint.Id, server.Endpoint.Name));
+                }
+            }
+
+            ServerList.Children.Add(new Border
+            {
+                BorderBrush = (IBrush?)Resources["DlgSep"] ?? Brushes.Gray,
+                BorderThickness = new Thickness(0, 0, 0, 1),
+                Padding = new Thickness(0, 0, 0, 12),
+                Child = content
+            });
+        }
+    }
+
+    private Control CreateActivityRow(RunServerActivity activity, string endpointId, string serverName)
+    {
+        var row = new Grid
+        {
+            ColumnDefinitions = new ColumnDefinitions("100,190,*,Auto,Auto"),
+            ColumnSpacing = 12,
+            Margin = new Thickness(0, 4, 0, 4)
+        };
+        row.Classes.Add("activity-row");
+        var state = activity.State == RunServerActivityState.Running
+            ? "Running"
+            : $"Queued #{activity.QueuePosition}";
+        row.Children.Add(new TextBlock
+        {
+            Text = state,
+            Foreground = activity.State == RunServerActivityState.Running ? Brushes.LimeGreen : Brushes.DarkOrange,
+            VerticalAlignment = VerticalAlignment.Top
+        });
+        var identity = new StackPanel { Spacing = 2 };
+        identity.Children.Add(new TextBlock
+        {
+            Text = activity.RunName,
+            FontWeight = FontWeight.SemiBold,
+            TextTrimming = TextTrimming.CharacterEllipsis
+        });
+        identity.Children.Add(new TextBlock { Text = activity.RunId, FontSize = 10, Opacity = 0.55 });
+        Grid.SetColumn(identity, 1);
+        row.Children.Add(identity);
+        var detail = new StackPanel { Spacing = 2 };
+        detail.Children.Add(new TextBlock { Text = activity.Kind, FontSize = 11, Opacity = 0.7 });
+        detail.Children.Add(new TextBlock { Text = activity.Status, TextWrapping = TextWrapping.Wrap });
+        if (activity.Iteration > 0 || activity.EvaluationsCompleted > 0)
+        {
+            var progress = activity.Iteration > 0 ? $"Iteration {activity.Iteration}" : string.Empty;
+            if (activity.EvaluationsCompleted > 0)
+                progress += $"  |  {activity.EvaluationsCompleted} evaluated";
+            if (activity.ActiveWorkers > 0)
+                progress += $"  |  {activity.ActiveWorkers} worker(s)";
+            detail.Children.Add(new TextBlock { Text = progress, FontSize = 10, Opacity = 0.6 });
+        }
+        Grid.SetColumn(detail, 2);
+        row.Children.Add(detail);
+        if (double.IsFinite(activity.Fitness))
+        {
+            var fitness = new TextBlock
+            {
+                Text = $"Fitness {activity.Fitness:G6}",
+                FontSize = 11,
+                VerticalAlignment = VerticalAlignment.Center
+            };
+            Grid.SetColumn(fitness, 3);
+            row.Children.Add(fitness);
+        }
+        ToolTip.SetTip(identity, activity.RunId);
+        var killButton = new Button
+        {
+            Name = "KillActivityButton",
+            Content = "✕",
+            Width = 30,
+            Height = 30,
+            FontSize = 16,
+            FontWeight = FontWeight.SemiBold,
+            Padding = new Thickness(0),
+            VerticalAlignment = VerticalAlignment.Center
+        };
+        killButton.Classes.Add("dlg-danger");
+        ToolTip.SetTip(killButton, "Kill this run on the RunServer.");
+        killButton.Click += async (_, _) => await KillActivityAsync(endpointId, serverName, activity, killButton);
+        Grid.SetColumn(killButton, 4);
+        row.Children.Add(killButton);
+        return row;
+    }
+
+    private async Task KillActivityAsync(string endpointId, string serverName,
+        RunServerActivity activity, Button button)
+    {
+        if (_runController is null)
+            return;
+
+        var confirmation = new ConfirmDialog("Stop RunServer Job?",
+            $"Stop '{activity.RunName}' ({activity.RunId}) on '{serverName}'? Active work may be interrupted.");
+        await confirmation.ShowDialog(this);
+        if (!confirmation.Result)
+            return;
+
+        button.IsEnabled = false;
+        StatusText.Text = $"Sending stop request for '{activity.RunName}'...";
+        if (!_runController.KillRunServerActivity(endpointId, activity, out var error))
+        {
+            StatusText.Text = $"Unable to stop '{activity.RunName}': {error}";
+            button.IsEnabled = true;
+            return;
+        }
+
+        StatusText.Text = $"Stop requested for '{activity.RunName}'.";
+        await RefreshAsync();
+    }
+
+    private void Window_KeyDown(object? sender, KeyEventArgs e)
+    {
+        if (e.Key == Key.Escape)
+        {
+            e.Handled = true;
+            Close();
+        }
+    }
+
+    protected override void OnClosed(EventArgs e)
+    {
+        _refreshTimer.Stop();
+        _lifetime.Cancel();
+        _lifetime.Dispose();
+        base.OnClosed(e);
+    }
+}
\ No newline at end of file
diff --git a/src/XTMF2.GUI/Views/RunServersWindow.axaml.cs b/src/XTMF2.GUI/Views/RunServersWindow.axaml.cs
index 620e4001..e2218b79 100644
--- a/src/XTMF2.GUI/Views/RunServersWindow.axaml.cs
+++ b/src/XTMF2.GUI/Views/RunServersWindow.axaml.cs
@@ -4,9 +4,11 @@
 using Avalonia.Interactivity;
 using Avalonia.Layout;
 using Avalonia.Media;
+using Avalonia.Platform.Storage;
 using Avalonia.Threading;
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using XTMF2.Bus;
 using XTMF2.GUI.Properties;
@@ -27,6 +29,7 @@ private sealed class RunServerEditor
         public required TextBox CertificateFingerprint { get; init; }
         public required TextBlock Status { get; init; }
         public required Button Reconnect { get; init; }
+        public required Button PrepareDeployment { get; init; }
         public required Button Remove { get; init; }
     }
 
@@ -89,6 +92,7 @@ private void AddRunServerEditor(RunServerEndpoint endpoint)
             MaxHeight = 48
         };
         var reconnect = new Button { Content = "Reconnect", Width = 130, IsEnabled = !endpoint.IsLocal && endpoint.Enabled };
+        var prepareDeployment = new Button { Content = "Upload Modules", IsEnabled = !endpoint.IsLocal && endpoint.Enabled };
         var remove = new Button { Content = "Remove", Width = 100, IsEnabled = !endpoint.IsLocal };
         var selectorName = new TextBlock
         {
@@ -122,11 +126,13 @@ private void AddRunServerEditor(RunServerEndpoint endpoint)
             CertificateFingerprint = certificateFingerprint,
             Status = status,
             Reconnect = reconnect,
+            PrepareDeployment = prepareDeployment,
             Remove = remove
         };
 
         name.TextChanged += (_, _) => selectorName.Text = string.IsNullOrWhiteSpace(name.Text) ? "RunServer" : name.Text;
         reconnect.Click += (_, _) => ReconnectRunServer(editor);
+        prepareDeployment.Click += async (_, _) => await PrepareDeploymentAsync(editor);
         remove.Click += (_, _) =>
         {
             var index = _editors.IndexOf(editor);
@@ -242,6 +248,7 @@ private void ShowSelectedEditor(RunServerEditor? editor)
             DetachFromParent(currentEditor.CertificateFingerprint);
             DetachFromParent(currentEditor.Status);
             DetachFromParent(currentEditor.Reconnect);
+            DetachFromParent(currentEditor.PrepareDeployment);
             DetachFromParent(currentEditor.Remove);
         }
         EndpointDetailsPanel.Children.Clear();
@@ -263,10 +270,69 @@ private void ShowSelectedEditor(RunServerEditor? editor)
         EndpointDetailsPanel.Children.Add(CreateField("Status", editor.Status));
         var actions = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 10, Margin = new Thickness(0, 8, 0, 0) };
         actions.Children.Add(editor.Reconnect);
+        actions.Children.Add(editor.PrepareDeployment);
         actions.Children.Add(editor.Remove);
         EndpointDetailsPanel.Children.Add(actions);
     }
 
+    private async System.Threading.Tasks.Task PrepareDeploymentAsync(RunServerEditor editor)
+    {
+        if (_runController is null)
+        {
+            SetConnectionError(editor, "RunServer connections are not available in this window.");
+            return;
+        }
+
+        IStorageFolder? suggestedStartLocation = null;
+        var modulesDirectory = Path.Combine(AppContext.BaseDirectory, "Modules");
+        if (Directory.Exists(modulesDirectory))
+            suggestedStartLocation = await StorageProvider.TryGetFolderFromPathAsync(modulesDirectory);
+
+        var files = await StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
+        {
+            Title = "Select module DLLs to upload",
+            AllowMultiple = true,
+            SuggestedStartLocation = suggestedStartLocation,
+            FileTypeFilter = new[]
+            {
+                new FilePickerFileType("Module DLLs") { Patterns = new[] { "*.dll" } }
+            }
+        });
+        var selectedModules = files
+            .Select(file => file.TryGetLocalPath())
+            .Where(path => !string.IsNullOrWhiteSpace(path))
+            .Cast<string>()
+            .ToArray();
+        if (selectedModules.Length == 0)
+            return;
+
+        editor.PrepareDeployment.IsEnabled = false;
+        editor.Status.Text = $"Uploading {selectedModules.Length} module(s)...";
+        editor.Status.Foreground = Brushes.Cyan;
+        try
+        {
+            var status = await _runController!.StageLocalRunServerDeploymentAsync(editor.Endpoint.Id, selectedModules);
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                editor.Status.Text = status.State == RunServerDrainState.Staged
+                    ? $"Upload complete: {selectedModules.Length} module(s) sent; RunServer restarting."
+                    : status.Message ?? status.State.ToString();
+                editor.Status.Foreground = status.State == RunServerDrainState.Staged
+                    ? Brushes.LimeGreen
+                    : status.State == RunServerDrainState.Failed ? Brushes.Red : Brushes.Cyan;
+                editor.PrepareDeployment.IsEnabled = true;
+            });
+        }
+        catch (Exception exception)
+        {
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                SetConnectionError(editor, exception.Message);
+                editor.PrepareDeployment.IsEnabled = true;
+            });
+        }
+    }
+
     private static void DetachFromParent(Control control)
     {
         if (control.Parent is Panel panel)
diff --git a/src/XTMF2.GUI/Views/RunsView.axaml b/src/XTMF2.GUI/Views/RunsView.axaml
index 614b754b..6912abe6 100644
--- a/src/XTMF2.GUI/Views/RunsView.axaml
+++ b/src/XTMF2.GUI/Views/RunsView.axaml
@@ -56,6 +56,16 @@
                                                    FontSize="11"
                                                    Opacity="0.65"
                                                    TextTrimming="CharacterEllipsis"/>
+                                        <StackPanel Orientation="Horizontal"
+                                                Spacing="4"
+                                                IsVisible="{Binding IsOptimizationRun}">
+                                            <TextBlock Text="Iteration" FontSize="10" Opacity="0.5"/>
+                                            <TextBlock Text="{Binding CurrentIteration}"
+                                                   FontSize="10" FontWeight="SemiBold"/>
+                                            <TextBlock Text="Tests" FontSize="10" Opacity="0.5" Margin="4,0,0,0"/>
+                                            <TextBlock Text="{Binding CurrentIterationFitnessTests}"
+                                                   FontSize="10" FontWeight="SemiBold"/>
+                                        </StackPanel>
                                     </StackPanel>
                                     <Button Grid.Column="2"
                                             Content="🗑"
@@ -63,8 +73,8 @@
                                             FontSize="14"
                                             VerticalAlignment="Center"
                                             IsEnabled="{Binding IsCompleted}"
-                                            Command="{Binding DataContext.RemoveRunCommand, RelativeSource={RelativeSource AncestorType=ListBox}}"
-                                            CommandParameter="{Binding}"/>
+                                            Click="RemoveRunButton_Click"
+                                            ToolTip.Tip="Remove this run; remote runs are deleted from their RunServer."/>
                                 </Grid>
                             </DataTemplate>
                         </ListBox.ItemTemplate>
@@ -72,10 +82,11 @@
 
                     <Button Grid.Row="1"
                             Content="Clear Completed"
-                            Command="{Binding ClearCompletedRunsCommand}"
+                            Click="ClearCompletedRunsButton_Click"
                             Classes="dlg-primary"
                             HorizontalAlignment="Stretch"
-                            Margin="0,4,0,2"/>
+                            Margin="0,4,0,2"
+                            ToolTip.Tip="Clears completed local runs and remote runs whose output has transferred to this computer. Remote-only runs are kept."/>
                 </Grid>
             </Border>
 
@@ -112,6 +123,21 @@
                                        Opacity="0.7"
                                        VerticalAlignment="Center"/>
                         </StackPanel>
+                        <StackPanel Orientation="Horizontal"
+                                    Spacing="8"
+                                    Margin="0,4,0,0"
+                                    IsVisible="{Binding SelectedRun.IsOptimizationRun}">
+                            <TextBlock Text="Iteration" FontSize="11" Opacity="0.55"/>
+                            <TextBlock Text="{Binding SelectedRun.CurrentIteration}"
+                                       FontSize="11" FontWeight="SemiBold"/>
+                            <TextBlock Text="Fitness tests" FontSize="11" Opacity="0.55"/>
+                            <TextBlock Text="{Binding SelectedRun.CurrentIterationFitnessTests}"
+                                       FontSize="11" FontWeight="SemiBold"/>
+                            <TextBlock Text="Best fitness" FontSize="11" Opacity="0.55"/>
+                            <TextBlock Text="{Binding SelectedRun.CurrentFitness, StringFormat=G6}"
+                                       FontSize="11" FontWeight="SemiBold"
+                                       FontFamily="Cascadia Code,Consolas,monospace"/>
+                        </StackPanel>
                         <Button Content="📂  Open Run Output Directory"
                                 Command="{Binding SelectedRun.OpenRunDirectoryCommand}"
                                 IsVisible="{Binding SelectedRun.HasRunDirectory}"
@@ -119,6 +145,27 @@
                                 Margin="0,6,0,0"
                                 HorizontalAlignment="Left"
                                 ToolTip.Tip="Open this run's output directory in the file explorer."/>
+                            <TextBlock Text="{Binding SelectedRun.OutputTransferStatus}"
+                                   IsVisible="{Binding SelectedRun.IsRemoteRun}"
+                                   FontSize="11" Opacity="0.7" Margin="0,4,0,0"/>
+                            <Button Content="Transfer Output to This Computer"
+                                IsVisible="{Binding SelectedRun.CanTransferRemoteOutput}"
+                                Classes="dlg-primary"
+                                Margin="0,4,0,0"
+                                HorizontalAlignment="Left"
+                                Click="TransferRemoteOutputButton_Click"/>
+                            <Button Content="Bind to Active Model System"
+                                IsVisible="{Binding SelectedRun.IsRecoveredRunUnbound}"
+                                Classes="dlg-primary"
+                                Margin="0,6,0,0"
+                                HorizontalAlignment="Left"
+                                Click="BindRecoveredRunButton_Click"/>
+                            <Button Content="Retry Remote Output Receipt"
+                                IsVisible="{Binding SelectedRun.HasPendingRemoteReceipt}"
+                                Classes="dlg-primary"
+                                Margin="0,6,0,0"
+                                HorizontalAlignment="Left"
+                                Click="RetryRemoteReceiptButton_Click"/>
                         <Button Content="{Binding SelectedRun.ErrorNavigationLinkText}"
                             IsVisible="{Binding SelectedRun.HasErrorNavigationTarget}"
                             Classes="dlg-primary"
@@ -135,13 +182,22 @@
                                 HorizontalAlignment="Left"
                                 ToolTip.Tip="Write the estimated/calibrated parameter values back into the model system. Undoable."/>
                         <!-- View per-iteration progress — only visible for estimation/calibration runs -->
-                        <Button Content="📊  View Parameter Progress"
+                        <StackPanel Orientation="Horizontal" Spacing="8" Margin="0,4,0,0">
+                            <Button x:Name="ViewProgressButton"
+                                Content="📊  View Parameter Progress"
                                 IsVisible="{Binding SelectedRun.IsOptimizationRun}"
                                 Classes="dlg-primary"
-                                Margin="0,4,0,0"
                                 HorizontalAlignment="Left"
                                 Click="ViewProgressButton_Click"
                                 ToolTip.Tip="Open the live optimisation progress window for this run."/>
+                            <Button x:Name="EstimationWorkersButton"
+                                Content="Estimation Workers"
+                                IsVisible="{Binding SelectedRun.IsRemoteSharedEstimation}"
+                                Classes="dlg-primary"
+                                HorizontalAlignment="Left"
+                                Click="EstimationWorkersButton_Click"
+                                ToolTip.Tip="Add or remove RunServers participating in this estimation."/>
+                        </StackPanel>
                     </StackPanel>
 
                     <!-- Message log -->
diff --git a/src/XTMF2.GUI/Views/RunsView.axaml.cs b/src/XTMF2.GUI/Views/RunsView.axaml.cs
index 7501c5b8..e8e82036 100644
--- a/src/XTMF2.GUI/Views/RunsView.axaml.cs
+++ b/src/XTMF2.GUI/Views/RunsView.axaml.cs
@@ -20,6 +20,10 @@ You should have received a copy of the GNU General Public License
 using System.ComponentModel;
 using Avalonia.Controls;
 using Avalonia.Interactivity;
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
 using XTMF2.GUI;
 using XTMF2.GUI.ViewModels;
 
@@ -28,6 +32,7 @@ namespace XTMF2.GUI.Views;
 public partial class RunsView : UserControl
 {
     private RunsViewModel? _vm;
+    private RemoteEstimationWorkersWindow? _workerWindow;
 
     public RunsView()
     {
@@ -74,6 +79,30 @@ private void ViewProgressButton_Click(object? sender, RoutedEventArgs e)
             window.Show();
     }
 
+    private void EstimationWorkersButton_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_vm?.SelectedRun is not { IsRemoteSharedEstimation: true } run)
+            return;
+        if (_workerWindow is { } existingWindow)
+        {
+            existingWindow.Activate();
+            return;
+        }
+
+        var window = new RemoteEstimationWorkersWindow(run);
+        _workerWindow = window;
+        window.Closed += (_, _) =>
+        {
+            if (ReferenceEquals(_workerWindow, window))
+                _workerWindow = null;
+        };
+        var owner = TopLevel.GetTopLevel(this) as Window;
+        if (owner is not null)
+            window.Show(owner);
+        else
+            window.Show();
+    }
+
     private void OpenErrorTargetButton_Click(object? sender, RoutedEventArgs e)
     {
         if (_vm?.SelectedRun is not { } run) return;
@@ -87,4 +116,136 @@ private void OpenErrorTargetButton_Click(object? sender, RoutedEventArgs e)
         mainWindow.FocusEditorTab(editor);
         editor.NavigateToElementById(elementId);
     }
+
+    private void BindRecoveredRunButton_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_vm?.SelectedRun is not { IsRecoveredRunUnbound: true } run)
+            return;
+        if (TopLevel.GetTopLevel(this) is not MainWindow mainWindow)
+            return;
+        if (!mainWindow.BindRecoveredRunToActiveModelSystem(run.RunId, out var error))
+        {
+            run.AppendStatus(error ?? "Unable to bind the recovered run.");
+            return;
+        }
+        run.AppendStatus("Bound to the active model system.");
+    }
+
+    private void RetryRemoteReceiptButton_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_vm?.SelectedRun is not { } run || TopLevel.GetTopLevel(this) is not MainWindow mainWindow)
+            return;
+        if (!mainWindow.RetryRemoteRunReceipt(run.RunId, out var error))
+            run.AppendStatus(error ?? "Unable to retry the remote output receipt.");
+    }
+
+    private void TransferRemoteOutputButton_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_vm?.SelectedRun is not { } run || TopLevel.GetTopLevel(this) is not MainWindow mainWindow)
+            return;
+        if (!mainWindow.RequestRemoteRunOutputTransfer(run.RunId, out var error))
+            run.AppendStatus(error ?? "Unable to request remote output transfer.");
+    }
+
+    private async void RemoveRunButton_Click(object? sender, RoutedEventArgs e)
+    {
+        if (sender is not Button { DataContext: RunViewModel run } || _vm is null)
+            return;
+        if (!run.IsRemoteRun)
+        {
+            _vm.RemoveRunCommand.Execute(run);
+            return;
+        }
+        if (TopLevel.GetTopLevel(this) is not MainWindow mainWindow)
+        {
+            run.AppendStatus("Unable to reach the RunServer controller.");
+            return;
+        }
+
+        if (!run.ArtifactsAvailable)
+        {
+            var confirmation = new ConfirmDialog("Delete Remote Run?",
+                $"The output for '{run.RunName}' ({run.RunId}) has not been transferred to this computer. " +
+                $"Deleting it from '{run.RunServer}' will permanently remove the only copy. Continue?");
+            await confirmation.ShowDialog(mainWindow);
+            if (!confirmation.Result)
+                return;
+        }
+
+        var button = sender as Button;
+        if (button is not null)
+            button.IsEnabled = false;
+        try
+        {
+            var result = await mainWindow.DeleteRemoteRunAsync(run.RunId);
+            if (!result.IsDeletedOrNotFound)
+            {
+                run.AppendStatus(result.Error ?? "The RunServer did not delete this run.");
+                return;
+            }
+            _vm.RemoveRunCommand.Execute(run);
+        }
+        catch (Exception exception) when (exception is IOException or OperationCanceledException or ObjectDisposedException)
+        {
+            run.AppendStatus($"Unable to delete the remote run: {exception.Message}");
+        }
+        finally
+        {
+            if (button is not null)
+                button.IsEnabled = run.Status != RunStatus.Running;
+        }
+    }
+
+    private void ClearCompletedRunsButton_Click(object? sender, RoutedEventArgs e)
+        => _ = ClearCompletedRunsAsync(sender);
+
+    private async Task ClearCompletedRunsAsync(object? sender)
+    {
+        if (_vm is null || sender is not Button button)
+            return;
+
+        button.IsEnabled = false;
+        try
+        {
+            var completedRuns = _vm.Runs.Where(run => run.IsCompleted).ToArray();
+            var mainWindow = TopLevel.GetTopLevel(this) as MainWindow;
+            foreach (var run in completedRuns)
+            {
+                if (run.IsRemoteRun)
+                {
+                    if (!run.ArtifactsAvailable)
+                    {
+                        run.AppendStatus("Kept by Clear Completed: output has not been transferred to this computer.");
+                        continue;
+                    }
+                    if (mainWindow is null)
+                    {
+                        run.AppendStatus("Unable to clear remote run: the RunServer controller is unavailable.");
+                        continue;
+                    }
+
+                    try
+                    {
+                        var result = await mainWindow.DeleteRemoteRunAsync(run.RunId);
+                        if (!result.IsDeletedOrNotFound)
+                        {
+                            run.AppendStatus(result.Error ?? "The RunServer did not delete this run.");
+                            continue;
+                        }
+                    }
+                    catch (Exception exception) when (exception is IOException or OperationCanceledException or ObjectDisposedException)
+                    {
+                        run.AppendStatus($"Unable to clear remote run: {exception.Message}");
+                        continue;
+                    }
+                }
+
+                _vm.RemoveRunCommand.Execute(run);
+            }
+        }
+        finally
+        {
+            button.IsEnabled = true;
+        }
+    }
 }
diff --git a/src/XTMF2.Run/Program.cs b/src/XTMF2.Run/Program.cs
index a9e0b21d..81d390fc 100644
--- a/src/XTMF2.Run/Program.cs
+++ b/src/XTMF2.Run/Program.cs
@@ -17,6 +17,7 @@ static void Main(string[] args)
             List<string> dllsToLoad = new List<string>();
             string? error = null;
             string? runID = null;
+            var sharedEstimationWorker = false;
             for (int i = 0; i < args.Length; i++)
             {
                 switch (args[i].ToLowerInvariant())
@@ -44,6 +45,9 @@ static void Main(string[] args)
                     case "-remote":
                         Console.WriteLine("Remote connections are not supported yet.");
                         return;
+                    case "-sharedestimationworker":
+                        sharedEstimationWorker = true;
+                        break;
                     case "-tcp":
                         if (i + 2 >= args.Length)
                         {
@@ -69,7 +73,7 @@ static void Main(string[] args)
                                 Console.WriteLine("No runID was provided!");
                                 return;
                             }
-                            Run(runID, tcpStream!, dllsToLoad);
+                            Run(runID, tcpStream!, dllsToLoad, sharedEstimationWorker);
                         }
                         finally
                         {
@@ -100,7 +104,7 @@ static void Main(string[] args)
                                 Console.WriteLine("Unable to create a connection to the XTMF2.Client!");
                                 return;
                             }
-                            Run(runID, toClient, dllsToLoad);
+                            Run(runID, toClient, dllsToLoad, sharedEstimationWorker);
                         }
                         finally
                         {
@@ -115,7 +119,8 @@ static void Main(string[] args)
             }
         }
 
-        private static void Run(string runID, Stream toClient, List<string> dllsToLoad)
+        private static void Run(string runID, Stream toClient, List<string> dllsToLoad,
+            bool sharedEstimationWorker)
         {
             var runtime = XTMFRuntime.CreateRuntime();
             var config = runtime.SystemConfiguration;
@@ -124,7 +129,10 @@ private static void Run(string runID, Stream toClient, List<string> dllsToLoad)
                 config.LoadAssembly(dll);
             }
             using var runBus = new RunBus(runID, toClient, true, runtime);
-            runBus.ProcessRequests();
+            if (sharedEstimationWorker)
+                runBus.ProcessSharedEstimationWorkerRequests();
+            else
+                runBus.ProcessRequests();
         }
     }
 }
diff --git a/src/XTMF2.RunServer.Updater/DeploymentFileTransaction.cs b/src/XTMF2.RunServer.Updater/DeploymentFileTransaction.cs
new file mode 100644
index 00000000..bd50c0fb
--- /dev/null
+++ b/src/XTMF2.RunServer.Updater/DeploymentFileTransaction.cs
@@ -0,0 +1,148 @@
+using System.IO.Compression;
+
+namespace XTMF2.RunServer.Updater;
+
+internal sealed class DeploymentFileTransaction
+{
+    private readonly string _deploymentDirectory;
+    private readonly string _runtimePath;
+    private readonly string _modulesPath;
+    private readonly bool _hadOriginalRuntime;
+    private readonly bool _hadOriginalModules;
+
+    public DeploymentFileTransaction(string installationDirectory, string deploymentDirectory)
+    {
+        _deploymentDirectory = deploymentDirectory;
+        _runtimePath = Path.Combine(installationDirectory, "XTMF2.dll");
+        _modulesPath = Path.Combine(installationDirectory, "Modules");
+        _hadOriginalRuntime = File.Exists(_runtimePath);
+        _hadOriginalModules = Directory.Exists(_modulesPath);
+        BackupDirectory = Path.Combine(deploymentDirectory, ".backup");
+    }
+
+    public string BackupDirectory { get; }
+
+    public void Apply()
+    {
+        EnsureDeploymentPayload(_deploymentDirectory);
+        Directory.CreateDirectory(BackupDirectory);
+        ReplaceDeploymentFile(_runtimePath,
+            Path.Combine(_deploymentDirectory, "XTMF2.dll"),
+            Path.Combine(BackupDirectory, "XTMF2.dll"));
+        ReplaceDeploymentDirectory(_modulesPath,
+            Path.Combine(_deploymentDirectory, "Modules"),
+            Path.Combine(BackupDirectory, "Modules"));
+    }
+
+    public void Rollback()
+    {
+        RestoreDeploymentFile(_runtimePath,
+            Path.Combine(BackupDirectory, "XTMF2.dll"), _hadOriginalRuntime);
+        RestoreDeploymentDirectory(_modulesPath,
+            Path.Combine(BackupDirectory, "Modules"), _hadOriginalModules);
+    }
+
+    private static void EnsureDeploymentPayload(string deploymentDirectory)
+    {
+        var runtimePath = Path.Combine(deploymentDirectory, "XTMF2.dll");
+        var modulesPath = Path.Combine(deploymentDirectory, "Modules");
+        if (File.Exists(runtimePath) && Directory.Exists(modulesPath))
+            return;
+
+        var archivePath = Path.Combine(deploymentDirectory, "deployment.zip");
+        if (!File.Exists(archivePath))
+            throw new InvalidDataException("Deployment staging data is incomplete.");
+        ExtractDeploymentArchive(archivePath, deploymentDirectory);
+        if (!File.Exists(runtimePath) || !Directory.Exists(modulesPath))
+            throw new InvalidDataException("Deployment archive is missing XTMF2.dll or Modules.");
+    }
+
+    private static void ExtractDeploymentArchive(string archivePath, string destinationRoot)
+    {
+        var root = Path.GetFullPath(destinationRoot);
+        using var archive = ZipFile.OpenRead(archivePath);
+        foreach (var entry in archive.Entries)
+        {
+            var normalizedName = entry.FullName.Replace('\\', '/');
+            if (normalizedName.Split('/', StringSplitOptions.RemoveEmptyEntries)
+                .Any(segment => segment is "." or ".."))
+                throw new InvalidDataException("Deployment archive contains an unsafe path.");
+            if (!normalizedName.Equals("XTMF2.dll", StringComparison.Ordinal) &&
+                !normalizedName.Equals("deployment-manifest.txt", StringComparison.Ordinal) &&
+                !normalizedName.Equals("Modules", StringComparison.Ordinal) &&
+                !normalizedName.StartsWith("Modules/", StringComparison.Ordinal))
+                throw new InvalidDataException("Deployment archive contains an unexpected file.");
+            if (normalizedName.Equals("Modules", StringComparison.Ordinal) && !string.IsNullOrEmpty(entry.Name))
+                throw new InvalidDataException("Deployment archive contains an invalid Modules entry.");
+
+            var relativePath = normalizedName.Replace('/', Path.DirectorySeparatorChar);
+            var destination = Path.GetFullPath(Path.Combine(root, relativePath));
+            var relativeDestination = Path.GetRelativePath(root, destination);
+            if (Path.IsPathRooted(relativeDestination) || relativeDestination == ".." ||
+                relativeDestination.StartsWith(".." + Path.DirectorySeparatorChar, StringComparison.Ordinal))
+                throw new InvalidDataException("Deployment archive contains an unsafe path.");
+            if (normalizedName.StartsWith("Modules/", StringComparison.Ordinal) && !string.IsNullOrEmpty(entry.Name))
+            {
+                var modulesRoot = Path.GetFullPath(Path.Combine(root, "Modules")) + Path.DirectorySeparatorChar;
+                var comparison = OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+                if (!destination.StartsWith(modulesRoot, comparison))
+                    throw new InvalidDataException("Deployment archive contains an unsafe module path.");
+            }
+
+            if (string.IsNullOrEmpty(entry.Name))
+            {
+                Directory.CreateDirectory(destination);
+                continue;
+            }
+
+            Directory.CreateDirectory(Path.GetDirectoryName(destination)!);
+            entry.ExtractToFile(destination, overwrite: true);
+        }
+    }
+
+    private static void ReplaceDeploymentFile(string destination, string staged, string backup)
+    {
+        if (!File.Exists(staged))
+            throw new InvalidDataException($"Deployment is missing required file '{Path.GetFileName(staged)}'.");
+        if (File.Exists(destination))
+            File.Move(destination, backup);
+        File.Move(staged, destination);
+    }
+
+    private static void ReplaceDeploymentDirectory(string destination, string staged, string backup)
+    {
+        if (!Directory.Exists(staged))
+            throw new InvalidDataException("Deployment is missing the required Modules directory.");
+        if (Directory.Exists(destination))
+            Directory.Move(destination, backup);
+        Directory.Move(staged, destination);
+    }
+
+    private static void RestoreDeploymentFile(string destination, string backup, bool hadOriginal)
+    {
+        if (File.Exists(backup))
+        {
+            if (File.Exists(destination))
+                File.Delete(destination);
+            File.Move(backup, destination);
+        }
+        else if (!hadOriginal && File.Exists(destination))
+        {
+            File.Delete(destination);
+        }
+    }
+
+    private static void RestoreDeploymentDirectory(string destination, string backup, bool hadOriginal)
+    {
+        if (Directory.Exists(backup))
+        {
+            if (Directory.Exists(destination))
+                Directory.Delete(destination, recursive: true);
+            Directory.Move(backup, destination);
+        }
+        else if (!hadOriginal && Directory.Exists(destination))
+        {
+            Directory.Delete(destination, recursive: true);
+        }
+    }
+}
diff --git a/src/XTMF2.RunServer.Updater/DeploymentUpdater.cs b/src/XTMF2.RunServer.Updater/DeploymentUpdater.cs
new file mode 100644
index 00000000..ac84605a
--- /dev/null
+++ b/src/XTMF2.RunServer.Updater/DeploymentUpdater.cs
@@ -0,0 +1,161 @@
+using System.ComponentModel;
+using System.Diagnostics;
+
+namespace XTMF2.RunServer.Updater;
+
+internal static class DeploymentUpdater
+{
+    private static readonly TimeSpan ProcessTimeout = TimeSpan.FromSeconds(30);
+
+    public static int Run(UpdaterArguments options)
+    {
+        if (!WaitForPreviousServer(options.PreviousProcessId))
+        {
+            Console.Error.WriteLine("The previous RunServer process did not exit before the update timeout.");
+            TryDeleteDirectory(options.DeploymentDirectory);
+            TryDeleteDirectory(options.StagingRoot);
+            return 1;
+        }
+
+        var deploymentFiles = new DeploymentFileTransaction(options.InstallationDirectory, options.DeploymentDirectory);
+        Process? deployedServer = null;
+        try
+        {
+            deploymentFiles.Apply();
+
+            var readyFile = Path.Combine(options.DeploymentDirectory, ".deployment-ready");
+            var startInfo = CreateRunServerStartInfo(options);
+            startInfo.Environment["XTMF2_DEPLOYMENT_MANIFEST"] =
+                Path.Combine(options.DeploymentDirectory, "deployment-manifest.txt");
+            startInfo.Environment["XTMF2_DEPLOYMENT_READY_FILE"] = readyFile;
+            deployedServer = Process.Start(startInfo)
+                ?? throw new InvalidOperationException("Unable to start the deployed RunServer.");
+            WaitForReadiness(deployedServer, readyFile);
+
+            deployedServer.Dispose();
+            deployedServer = null;
+            if (TryDeleteDirectory(deploymentFiles.BackupDirectory))
+                TryDeleteDirectory(options.DeploymentDirectory);
+            TryDeleteDirectory(options.StagingRoot);
+            return 0;
+        }
+        catch (Exception exception) when (exception is IOException or UnauthorizedAccessException or InvalidDataException or
+            InvalidOperationException or ArgumentException or Win32Exception)
+        {
+            Console.Error.WriteLine($"Unable to activate the deployed RunServer: {exception.Message}");
+            if (!StopProcess(deployedServer))
+            {
+                Console.Error.WriteLine($"Unable to stop the deployed RunServer; deployment backup retained at '{deploymentFiles.BackupDirectory}'.");
+                return 1;
+            }
+            var rollbackSucceeded = false;
+            try
+            {
+                deploymentFiles.Rollback();
+                if (Process.Start(CreateRunServerStartInfo(options)) is null)
+                    throw new InvalidOperationException("Unable to restart the previous RunServer version.");
+                rollbackSucceeded = true;
+            }
+            catch (Exception rollbackException) when (rollbackException is IOException or UnauthorizedAccessException or
+                InvalidOperationException or ArgumentException or Win32Exception)
+            {
+                Console.Error.WriteLine($"Unable to restore the previous RunServer version: {rollbackException.Message}");
+            }
+
+            if (rollbackSucceeded)
+            {
+                TryDeleteDirectory(options.DeploymentDirectory);
+                TryDeleteDirectory(options.StagingRoot);
+            }
+            return 1;
+        }
+        finally
+        {
+            deployedServer?.Dispose();
+        }
+    }
+
+    private static bool WaitForPreviousServer(int processId)
+    {
+        try
+        {
+            using var previousServer = Process.GetProcessById(processId);
+            return previousServer.WaitForExit((int)ProcessTimeout.TotalMilliseconds);
+        }
+        catch (ArgumentException)
+        {
+            return true;
+        }
+        catch (Win32Exception exception)
+        {
+            Console.Error.WriteLine($"Unable to wait for the previous RunServer process: {exception.Message}");
+            return false;
+        }
+    }
+
+    private static void WaitForReadiness(Process deployedServer, string readyFile)
+    {
+        var deadline = DateTime.UtcNow + ProcessTimeout;
+        while (!File.Exists(readyFile))
+        {
+            if (deployedServer.HasExited)
+                throw new InvalidOperationException("The deployed RunServer exited before becoming ready.");
+            if (DateTime.UtcNow >= deadline)
+                throw new InvalidOperationException("The deployed RunServer did not become ready.");
+            Thread.Sleep(250);
+        }
+    }
+
+    private static ProcessStartInfo CreateRunServerStartInfo(UpdaterArguments options)
+    {
+        var startInfo = new ProcessStartInfo(options.ServerProcessPath)
+        {
+            UseShellExecute = false,
+            WorkingDirectory = options.InstallationDirectory
+        };
+        if (IsDotnetHost(options.ServerProcessPath))
+            startInfo.ArgumentList.Add(options.ServerAssemblyPath);
+        foreach (var argument in options.ServerArguments)
+            startInfo.ArgumentList.Add(argument);
+        return startInfo;
+    }
+
+    private static bool IsDotnetHost(string processPath)
+        => string.Equals(Path.GetFileNameWithoutExtension(processPath), "dotnet", StringComparison.OrdinalIgnoreCase);
+
+    private static bool StopProcess(Process? process)
+    {
+        if (process is null)
+            return true;
+        try
+        {
+            if (!process.HasExited)
+            {
+                process.Kill(entireProcessTree: true);
+                return process.WaitForExit((int)ProcessTimeout.TotalMilliseconds);
+            }
+            return true;
+        }
+        catch (Exception exception) when (exception is InvalidOperationException or Win32Exception)
+        {
+            Console.Error.WriteLine($"Unable to terminate the deployed RunServer: {exception.Message}");
+            return false;
+        }
+    }
+
+    private static bool TryDeleteDirectory(string directory)
+    {
+        if (!Directory.Exists(directory))
+            return true;
+        try
+        {
+            Directory.Delete(directory, recursive: true);
+            return true;
+        }
+        catch (Exception exception) when (exception is IOException or UnauthorizedAccessException)
+        {
+            Console.Error.WriteLine($"Unable to clean up deployment directory '{directory}': {exception.Message}");
+            return false;
+        }
+    }
+}
diff --git a/src/XTMF2.RunServer.Updater/Program.cs b/src/XTMF2.RunServer.Updater/Program.cs
new file mode 100644
index 00000000..128bd9e6
--- /dev/null
+++ b/src/XTMF2.RunServer.Updater/Program.cs
@@ -0,0 +1,20 @@
+namespace XTMF2.RunServer.Updater;
+
+internal static class Program
+{
+    private static int Main(string[] args)
+    {
+        UpdaterArguments options;
+        try
+        {
+            options = UpdaterArguments.Parse(args);
+        }
+        catch (ArgumentException exception)
+        {
+            Console.Error.WriteLine(exception.Message);
+            return 2;
+        }
+
+        return DeploymentUpdater.Run(options);
+    }
+}
diff --git a/src/XTMF2.RunServer.Updater/ReadMe.md b/src/XTMF2.RunServer.Updater/ReadMe.md
new file mode 100644
index 00000000..9ec0745e
--- /dev/null
+++ b/src/XTMF2.RunServer.Updater/ReadMe.md
@@ -0,0 +1,23 @@
+# XTMF2.RunServer.Updater
+
+`XTMF2.RunServer.Updater` is a separate .NET 10 executable used by RunServer when activating an uploaded module deployment. RunServer starts the updater and exits, allowing the updater to replace files without holding the server's runtime assembly open.
+
+## Build
+
+Run these commands from the repository root:
+
+```powershell
+dotnet build .\src\XTMF2.RunServer.Updater\XTMF2.RunServer.Updater.csproj --configuration Release
+dotnet build .\XTMF2.sln --configuration Release
+```
+
+The updater project writes its output to the shared `XTMF2-Dev` directory, alongside RunServer. Building the RunServer project or the full solution also builds the updater. Keep the updater executable and its accompanying .NET runtime files beside RunServer; RunServer launches it automatically, so it is not normally run manually.
+
+## What it does
+
+1. Waits up to 30 seconds for the previous RunServer process to exit.
+2. Extracts and validates the staged deployment archive, then backs up and replaces `XTMF2.dll` and the `Modules` directory.
+3. Starts RunServer again with its original command-line arguments and waits up to 30 seconds for its readiness signal.
+4. If activation fails, stops the deployed server, restores the backups, and starts the previous RunServer version.
+
+Temporary deployment and staging files are removed after successful activation or rollback. If the updater cannot stop a failed deployed server or complete rollback, it retains the deployment backup for recovery.
diff --git a/src/XTMF2.RunServer.Updater/UpdaterArguments.cs b/src/XTMF2.RunServer.Updater/UpdaterArguments.cs
new file mode 100644
index 00000000..c70db902
--- /dev/null
+++ b/src/XTMF2.RunServer.Updater/UpdaterArguments.cs
@@ -0,0 +1,90 @@
+namespace XTMF2.RunServer.Updater;
+
+internal sealed record UpdaterArguments(
+    int PreviousProcessId,
+    string InstallationDirectory,
+    string ServerProcessPath,
+    string ServerAssemblyPath,
+    string DeploymentDirectory,
+    string StagingRoot,
+    IReadOnlyList<string> ServerArguments)
+{
+    public static UpdaterArguments Parse(string[] args)
+    {
+        int? previousProcessId = null;
+        string? installationDirectory = null;
+        string? serverProcessPath = null;
+        string? serverAssemblyPath = null;
+        string? deploymentDirectory = null;
+        string? stagingRoot = null;
+        var serverArguments = new List<string>();
+
+        for (var i = 0; i < args.Length; i++)
+        {
+            var option = args[i];
+            if (option == "--server-arg")
+            {
+                serverArguments.Add(ReadValue(args, ref i, option));
+                continue;
+            }
+
+            var value = ReadValue(args, ref i, option);
+            switch (option)
+            {
+                case "--old-pid":
+                    if (!int.TryParse(value, out var parsedProcessId) || parsedProcessId <= 0 || previousProcessId.HasValue)
+                        throw new ArgumentException("--old-pid must be specified once with a positive process ID.");
+                    previousProcessId = parsedProcessId;
+                    break;
+                case "--install-dir":
+                    if (installationDirectory is not null)
+                        throw new ArgumentException("--install-dir may only be specified once.");
+                    installationDirectory = GetFullPath(value, option);
+                    break;
+                case "--server-path":
+                    if (serverProcessPath is not null)
+                        throw new ArgumentException("--server-path may only be specified once.");
+                    serverProcessPath = GetFullPath(value, option);
+                    break;
+                case "--server-assembly":
+                    if (serverAssemblyPath is not null)
+                        throw new ArgumentException("--server-assembly may only be specified once.");
+                    serverAssemblyPath = GetFullPath(value, option);
+                    break;
+                case "--deployment-dir":
+                    if (deploymentDirectory is not null)
+                        throw new ArgumentException("--deployment-dir may only be specified once.");
+                    deploymentDirectory = GetFullPath(value, option);
+                    break;
+                case "--staging-root":
+                    if (stagingRoot is not null)
+                        throw new ArgumentException("--staging-root may only be specified once.");
+                    stagingRoot = GetFullPath(value, option);
+                    break;
+                default:
+                    throw new ArgumentException($"Unknown updater option '{option}'.");
+            }
+        }
+
+        if (!previousProcessId.HasValue || installationDirectory is null || serverProcessPath is null ||
+            serverAssemblyPath is null || deploymentDirectory is null || stagingRoot is null)
+            throw new ArgumentException("Updater options --old-pid, --install-dir, --server-path, --server-assembly, --deployment-dir, and --staging-root are required.");
+
+        return new UpdaterArguments(previousProcessId.Value, installationDirectory, serverProcessPath,
+            serverAssemblyPath, deploymentDirectory, stagingRoot, serverArguments);
+    }
+
+    private static string ReadValue(string[] args, ref int index, string option)
+    {
+        if (index + 1 >= args.Length)
+            throw new ArgumentException($"Missing value for updater option '{option}'.");
+        return args[++index];
+    }
+
+    private static string GetFullPath(string value, string option)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+            throw new ArgumentException($"Updater option '{option}' cannot be empty.");
+        return Path.GetFullPath(value);
+    }
+}
diff --git a/src/XTMF2.RunServer.Updater/XTMF2.RunServer.Updater.csproj b/src/XTMF2.RunServer.Updater/XTMF2.RunServer.Updater.csproj
new file mode 100644
index 00000000..dfd016bf
--- /dev/null
+++ b/src/XTMF2.RunServer.Updater/XTMF2.RunServer.Updater.csproj
@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+	<OutputType>Exe</OutputType>
+	<TargetFramework>net10.0</TargetFramework>
+	<RootNamespace>XTMF2.RunServer.Updater</RootNamespace>
+	<AssemblyName>XTMF2.RunServer.Updater</AssemblyName>
+	<Nullable>enable</Nullable>
+	<ImplicitUsings>enable</ImplicitUsings>
+	<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+	<AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+	<OutputPath>..\..\..\XTMF2-Dev\</OutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+	<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+	  <_Parameter1>XTMF2.UnitTests</_Parameter1>
+	</AssemblyAttribute>
+  </ItemGroup>
+
+</Project>
diff --git a/src/XTMF2/Bus/CreateStreams.cs b/src/XTMF2/Bus/CreateStreams.cs
index 6ee8a3a6..2e088e14 100644
--- a/src/XTMF2/Bus/CreateStreams.cs
+++ b/src/XTMF2/Bus/CreateStreams.cs
@@ -228,6 +228,7 @@ public static bool CreateSecureTcpClient(
 
             var client = new TcpClient();
             var certificateValidationFailed = false;
+            var authenticationStage = "TLS handshake";
             try
             {
                 var connectTask = client.ConnectAsync(address, port);
@@ -251,6 +252,7 @@ public static bool CreateSecureTcpClient(
                     return !certificateValidationFailed;
                 });
                 tls.AuthenticateAsClient(address, null, SslProtocols.Tls12 | SslProtocols.Tls13, false);
+                authenticationStage = "token authentication";
                 AuthenticateClient(tls, token, timeoutMilliseconds);
                 client.ReceiveTimeout = 0;
                 client.SendTimeout = 0;
@@ -260,10 +262,10 @@ public static bool CreateSecureTcpClient(
             catch (Exception ex) when (ex is SocketException or IOException or InvalidOperationException or AuthenticationException or CryptographicException or AggregateException)
             {
                 error = certificateValidationFailed
-                    ? "The RunServer certificate fingerprint does not match the configured fingerprint."
-                    : ex is AggregateException aggregate
+                    ? "TLS handshake failed: the RunServer certificate fingerprint does not match the configured fingerprint."
+                    : $"{authenticationStage} failed: {(ex is AggregateException aggregate
                     ? aggregate.GetBaseException().Message
-                    : ex.Message;
+                    : ex.Message)}";
                 return false;
             }
             finally
@@ -286,12 +288,14 @@ public static bool AuthenticateSecureTcpClient(
         {
             stream = null;
             error = null;
+            var authenticationStage = "TLS handshake";
             try
             {
                 client.ReceiveTimeout = timeoutMilliseconds;
                 client.SendTimeout = timeoutMilliseconds;
                 var tls = new SslStream(client.GetStream(), false);
                 tls.AuthenticateAsServer(certificate, false, SslProtocols.Tls12 | SslProtocols.Tls13, false);
+                authenticationStage = "token authentication";
                 AuthenticateServer(tls, token, timeoutMilliseconds);
                 client.ReceiveTimeout = 0;
                 client.SendTimeout = 0;
@@ -300,7 +304,7 @@ public static bool AuthenticateSecureTcpClient(
             }
             catch (Exception ex) when (ex is IOException or InvalidOperationException or AuthenticationException or CryptographicException)
             {
-                error = ex.Message;
+                error = $"{authenticationStage} failed: {ex.Message}";
                 return false;
             }
         }
diff --git a/src/XTMF2/Bus/DeploymentProtocol.cs b/src/XTMF2/Bus/DeploymentProtocol.cs
new file mode 100644
index 00000000..ae7a22a3
--- /dev/null
+++ b/src/XTMF2/Bus/DeploymentProtocol.cs
@@ -0,0 +1,170 @@
+using System;
+using System.IO;
+
+namespace XTMF2.Bus;
+
+public enum DeploymentMessageType
+{
+    BeginDrain = 0,
+    DrainStatus = 1,
+    CancelDrain = 2,
+    DrainCompleted = 3,
+    DeploymentFailed = 4,
+    DeployArchive = 5,
+    DeploymentStaged = 6,
+    ActivateDeployment = 7
+}
+
+public enum RunServerDrainState
+{
+    Draining = 0,
+    Idle = 1,
+    Cancelled = 2,
+    Failed = 3,
+    Staged = 4
+}
+
+public sealed record RunServerDrainStatus(
+    string RequestId,
+    RunServerDrainState State,
+    int ActiveCount,
+    int QueuedCount,
+    string? Message);
+
+public static class DeploymentProtocol
+{
+    private const int ProtocolVersion = 1;
+    private const int MaxStringLength = 1024;
+    public const int MaxArchiveBytes = 512 * 1024 * 1024;
+    public const int MaxArchiveEntries = 4096;
+    public const long MaxExpandedArchiveBytes = 1024L * 1024 * 1024;
+    public const long MaxArchiveEntryBytes = 256L * 1024 * 1024;
+
+    public static bool IsValidRequestId(string requestId)
+        => Guid.TryParseExact(requestId, "N", out _);
+
+    public static void WriteBeginDrain(BinaryWriter writer, string requestId)
+    {
+        WriteHeader(writer, DeploymentMessageType.BeginDrain);
+        WriteString(writer, requestId);
+    }
+
+    public static void WriteCancelDrain(BinaryWriter writer, string requestId)
+    {
+        WriteHeader(writer, DeploymentMessageType.CancelDrain);
+        WriteString(writer, requestId);
+    }
+
+    public static void WriteDrainStatus(BinaryWriter writer, RunServerDrainStatus status)
+    {
+        WriteHeader(writer, DeploymentMessageType.DrainStatus);
+        WriteStatusPayload(writer, status);
+    }
+
+    public static void WriteDrainCompleted(BinaryWriter writer, RunServerDrainStatus status)
+    {
+        WriteHeader(writer, DeploymentMessageType.DrainCompleted);
+        WriteStatusPayload(writer, status);
+    }
+
+    public static void WriteDeploymentStaged(BinaryWriter writer, RunServerDrainStatus status)
+    {
+        WriteHeader(writer, DeploymentMessageType.DeploymentStaged);
+        WriteStatusPayload(writer, status);
+    }
+
+    public static void WriteDeploymentFailed(BinaryWriter writer, string requestId, string message)
+    {
+        WriteHeader(writer, DeploymentMessageType.DeploymentFailed);
+        WriteString(writer, requestId);
+        WriteString(writer, message);
+    }
+
+    public static void WriteDeployArchive(BinaryWriter writer, string requestId, byte[] archive, string sha256)
+    {
+        WriteHeader(writer, DeploymentMessageType.DeployArchive);
+        WriteString(writer, requestId);
+        if (archive.Length > MaxArchiveBytes)
+            throw new ArgumentException("Deployment archive exceeds the 512 MB limit.", nameof(archive));
+        writer.Write(archive.Length);
+        WriteString(writer, sha256);
+        writer.Write(archive);
+    }
+
+    public static void WriteActivateDeployment(BinaryWriter writer, string requestId)
+    {
+        WriteHeader(writer, DeploymentMessageType.ActivateDeployment);
+        WriteString(writer, requestId);
+    }
+
+    public static (int Version, DeploymentMessageType Type) ReadHeader(BinaryReader reader)
+    {
+        var version = reader.ReadInt32();
+        if (version != ProtocolVersion)
+            throw new InvalidDataException($"Unsupported deployment protocol version {version}.");
+        return (version, (DeploymentMessageType)reader.ReadInt32());
+    }
+
+    public static string ReadRequestId(BinaryReader reader) => ReadString(reader);
+
+    public static RunServerDrainStatus ReadStatusPayload(BinaryReader reader)
+    {
+        var requestId = ReadString(reader);
+        var state = (RunServerDrainState)reader.ReadInt32();
+        if (!Enum.IsDefined(state))
+            throw new InvalidDataException("Unknown RunServer drain state.");
+        var activeCount = reader.ReadInt32();
+        var queuedCount = reader.ReadInt32();
+        if (activeCount < 0 || queuedCount < 0)
+            throw new InvalidDataException("RunServer activity counts cannot be negative.");
+        var message = reader.ReadBoolean() ? ReadString(reader) : null;
+        return new RunServerDrainStatus(requestId, state, activeCount, queuedCount, message);
+    }
+
+    public static string ReadFailureMessage(BinaryReader reader) => ReadString(reader);
+
+    public static (string RequestId, byte[] Archive, string Sha256) ReadDeployArchive(BinaryReader reader)
+    {
+        var requestId = ReadString(reader);
+        var length = reader.ReadInt32();
+        if (length < 0 || length > MaxArchiveBytes)
+            throw new InvalidDataException("Deployment archive length is invalid.");
+        var sha256 = ReadString(reader);
+        var archive = reader.ReadBytes(length);
+        if (archive.Length != length)
+            throw new EndOfStreamException("Deployment archive was truncated.");
+        return (requestId, archive, sha256);
+    }
+
+    private static void WriteHeader(BinaryWriter writer, DeploymentMessageType type)
+    {
+        writer.Write(ProtocolVersion);
+        writer.Write((int)type);
+    }
+
+    private static void WriteStatusPayload(BinaryWriter writer, RunServerDrainStatus status)
+    {
+        WriteString(writer, status.RequestId);
+        writer.Write((int)status.State);
+        writer.Write(status.ActiveCount);
+        writer.Write(status.QueuedCount);
+        writer.Write(status.Message is not null);
+        if (status.Message is not null)
+            WriteString(writer, status.Message);
+    }
+
+    private static void WriteString(BinaryWriter writer, string value)
+    {
+        if (string.IsNullOrWhiteSpace(value) || value.Length > MaxStringLength)
+            throw new ArgumentException("Deployment protocol strings must be non-empty and bounded.", nameof(value));
+        writer.Write(value);
+    }
+
+    private static string ReadString(BinaryReader reader)
+    {
+        var value = reader.ReadString();
+        if (string.IsNullOrWhiteSpace(value) || value.Length > MaxStringLength)
+            throw new InvalidDataException("Deployment protocol string is empty or too large.");
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/src/XTMF2/Bus/EstimationEvaluationReportWriter.cs b/src/XTMF2/Bus/EstimationEvaluationReportWriter.cs
new file mode 100644
index 00000000..dc23bcd5
--- /dev/null
+++ b/src/XTMF2/Bus/EstimationEvaluationReportWriter.cs
@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace XTMF2.Bus;
+
+internal sealed class EstimationEvaluationReportWriter : IDisposable
+{
+    private readonly StreamWriter _writer;
+
+    public EstimationEvaluationReportWriter(
+        string path,
+        string algorithmName,
+        IReadOnlyList<string> parameterNames)
+    {
+        var directory = Path.GetDirectoryName(path);
+        if (!string.IsNullOrEmpty(directory))
+            Directory.CreateDirectory(directory);
+        _writer = new StreamWriter(path, append: false,
+            new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
+        var iterationColumnName = algorithmName.Contains("genetic", StringComparison.OrdinalIgnoreCase)
+            ? "Generation"
+            : "Iteration";
+        var headers = new List<string> { iterationColumnName, "Fitness" };
+        headers.AddRange(parameterNames.Select((name, index) =>
+            string.IsNullOrWhiteSpace(name) ? $"Parameter {index + 1}" : name));
+        _writer.WriteLine(string.Join(",", headers.Select(EscapeCsv)));
+        _writer.Flush();
+    }
+
+    public void Write(int iteration, IReadOnlyList<double> parameters, double fitness)
+    {
+        var values = new List<string>(parameters.Count + 2)
+        {
+            iteration.ToString(CultureInfo.InvariantCulture),
+            fitness.ToString("R", CultureInfo.InvariantCulture)
+        };
+        values.AddRange(parameters.Select(value => value.ToString("R", CultureInfo.InvariantCulture)));
+        _writer.WriteLine(string.Join(",", values.Select(EscapeCsv)));
+        _writer.Flush();
+    }
+
+    public void Dispose() => _writer.Dispose();
+
+    private static string EscapeCsv(string value)
+        => value.IndexOfAny([',', '"', '\r', '\n']) < 0
+            ? value
+            : $"\"{value.Replace("\"", "\"\"")}\"";
+}
\ No newline at end of file
diff --git a/src/XTMF2/Bus/HostBus.cs b/src/XTMF2/Bus/HostBus.cs
index b43655e2..dc2195d2 100644
--- a/src/XTMF2/Bus/HostBus.cs
+++ b/src/XTMF2/Bus/HostBus.cs
@@ -20,9 +20,12 @@ You should have received a copy of the GNU General Public License
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.Collections.Concurrent;
+using System.Security.Cryptography;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using XTMF2.Bus.Optimization;
 using XTMF2.Editing;
 
 namespace XTMF2.Bus;
@@ -36,6 +39,9 @@ public sealed class HostBus : IDisposable
     private readonly bool _Owner;
     private volatile bool _Exit = false;
     private volatile bool _Exited = false;
+    private readonly ConcurrentDictionary<string, TaskCompletionSource<RunServerActivityResponse>> _pendingActivityRequests = new(StringComparer.Ordinal);
+    private readonly ConcurrentDictionary<string, TaskCompletionSource<RemoteRunDeletionResponse>> _pendingRemoteRunDeletionRequests = new(StringComparer.Ordinal);
+    private readonly ConcurrentDictionary<string, TaskCompletionSource<RunServerDrainStatus>> _pendingDrainRequests = new(StringComparer.Ordinal);
 
     /// <summary>
     /// Create a host on a given stream.
@@ -61,6 +67,10 @@ private void Dispose(bool managed)
             GC.SuppressFinalize(this);
         }
         _Exit = true;
+        if (_Owner)
+        {
+            _HostStream.Dispose();
+        }
         while (!_Exited)
         {
             Interlocked.MemoryBarrier();
@@ -70,10 +80,6 @@ private void Dispose(bool managed)
             }
             Interlocked.MemoryBarrier();
         }
-        if (_Owner)
-        {
-            _HostStream.Dispose();
-        }
     }
 
     /// <summary>
@@ -97,7 +103,9 @@ private enum In
         ClientReportedStatus = 8,
         ClientOptimizationResults = 9,
         ClientIterationProgress = 10,
-        ClientRunArtifacts = 11
+        ClientRunArtifacts = 11,
+        SharedEstimationMessage = 12,
+        DeploymentMessage = 13
     }
 
     /// <summary>
@@ -182,9 +190,10 @@ public delegate void OptimizationResultsAvailable(
     /// <param name="runID">The ID of the run sending the update.</param>
     /// <param name="iteration">The current iteration number (1-based).</param>
     /// <param name="fitness">The best fitness value seen so far.</param>
+    /// <param name="fitnessTestsThisIteration">Number of fitness tests completed since the previous progress update.</param>
     /// <param name="values">Ordered list of (node serialisation index, current value) pairs.</param>
     public delegate void IterationProgressUpdate(
-        object sender, string runID, int iteration, double fitness,
+        object sender, string runID, int iteration, double fitness, int fitnessTestsThisIteration,
         IReadOnlyList<(int nodeIndex, double value)> values);
 
     /// <summary>
@@ -192,6 +201,26 @@ public delegate void IterationProgressUpdate(
     /// </summary>
     public event IterationProgressUpdate? ClientIterationProgressAvailable;
 
+    public event EventHandler<SharedEstimationEvaluationResult>? SharedEstimationResultAvailable;
+
+    public event EventHandler<SharedEstimationProgress>? SharedEstimationProgressAvailable;
+
+    public event EventHandler<SharedEstimationCompletion>? SharedEstimationCompleted;
+
+    public event EventHandler<IReadOnlyList<SharedEstimationJobSnapshot>>? SharedEstimationJobSnapshotsAvailable;
+
+    public event EventHandler<IReadOnlyList<RemoteRunSnapshot>>? RemoteRunSnapshotsAvailable;
+
+    public event EventHandler<RemoteRunArtifactsResponse>? RemoteRunArtifactsAvailable;
+
+    public event EventHandler<SharedEstimationWorkerControlAcknowledgement>? SharedEstimationWorkerControlAcknowledged;
+
+    public event EventHandler<SharedEstimationStatus>? SharedEstimationStatusAvailable;
+
+    public event EventHandler<SharedEstimationWorkerReady>? SharedEstimationWorkerReadyAvailable;
+
+    public event EventHandler<RunServerDrainStatus>? RunServerDrainStatusAvailable;
+
     private static void IgnoreWarnings(Action toRun)
     {
         /*
@@ -221,7 +250,8 @@ private Thread StartListenner()
                 using var reader = new BinaryReader(_HostStream, Encoding.UTF8, true);
                 while (!_Exit)
                 {
-                    var command = (In)reader.ReadInt32();
+                    var commandValue = reader.ReadInt32();
+                    var command = (In)commandValue;
                     switch (command)
                     {
                         case In.Heartbeat:
@@ -289,11 +319,13 @@ private Thread StartListenner()
                                 var runId = reader.ReadString();
                                 int iteration = reader.ReadInt32();
                                 double fitness = reader.ReadDouble();
+                                int fitnessTestsThisIteration = reader.ReadInt32();
                                 int count = reader.ReadInt32();
                                 var values = new (int nodeIndex, double value)[count];
                                 for (int i = 0; i < count; i++)
                                     values[i] = (reader.ReadInt32(), reader.ReadDouble());
-                                IgnoreWarnings(() => ClientIterationProgressAvailable?.Invoke(this, runId, iteration, fitness, values));
+                                IgnoreWarnings(() => ClientIterationProgressAvailable?.Invoke(
+                                    this, runId, iteration, fitness, fitnessTestsThisIteration, values));
                             }
                             break;
                         case In.ClientRunArtifacts:
@@ -314,8 +346,97 @@ private Thread StartListenner()
                                 }
                             }
                             break;
+                        case In.SharedEstimationMessage:
+                            {
+                                var (_, messageType) = SharedEstimationProtocol.ReadHeader(reader);
+                                switch (messageType)
+                                {
+                                    case SharedEstimationMessageType.EvaluationResult:
+                                        IgnoreWarnings(() => SharedEstimationResultAvailable?.Invoke(
+                                            this, SharedEstimationProtocol.ReadResultPayload(reader)));
+                                        break;
+                                    case SharedEstimationMessageType.Progress:
+                                        IgnoreWarnings(() => SharedEstimationProgressAvailable?.Invoke(
+                                            this, SharedEstimationProtocol.ReadProgressPayload(reader)));
+                                        break;
+                                    case SharedEstimationMessageType.Complete:
+                                        IgnoreWarnings(() => SharedEstimationCompleted?.Invoke(
+                                            this, SharedEstimationProtocol.ReadCompletionPayload(reader)));
+                                        break;
+                                    case SharedEstimationMessageType.JobSnapshots:
+                                        IgnoreWarnings(() => SharedEstimationJobSnapshotsAvailable?.Invoke(
+                                            this, SharedEstimationProtocol.ReadJobSnapshotsPayload(reader)));
+                                        break;
+                                    case SharedEstimationMessageType.WorkerControlAcknowledgement:
+                                        IgnoreWarnings(() => SharedEstimationWorkerControlAcknowledged?.Invoke(
+                                            this, SharedEstimationProtocol.ReadWorkerControlAcknowledgementPayload(reader)));
+                                        break;
+                                    case SharedEstimationMessageType.Status:
+                                        IgnoreWarnings(() => SharedEstimationStatusAvailable?.Invoke(
+                                            this, SharedEstimationProtocol.ReadStatusPayload(reader)));
+                                        break;
+                                    case SharedEstimationMessageType.WorkerReady:
+                                        var readiness = SharedEstimationProtocol.ReadWorkerReadyPayload(reader);
+                                        IgnoreWarnings(() => SharedEstimationWorkerReadyAvailable?.Invoke(this, readiness));
+                                        break;
+                                    case SharedEstimationMessageType.RemoteRunSnapshots:
+                                        IgnoreWarnings(() => RemoteRunSnapshotsAvailable?.Invoke(
+                                            this, SharedEstimationProtocol.ReadRemoteRunSnapshotsPayload(reader)));
+                                        break;
+                                    case SharedEstimationMessageType.RemoteRunArtifacts:
+                                        IgnoreWarnings(() => RemoteRunArtifactsAvailable?.Invoke(
+                                            this, SharedEstimationProtocol.ReadRemoteRunArtifactsPayload(reader)));
+                                        break;
+                                    case SharedEstimationMessageType.ServerActivitySnapshots:
+                                        var activityResponse = SharedEstimationProtocol.ReadServerActivitySnapshotsPayload(reader);
+                                        if (_pendingActivityRequests.TryRemove(activityResponse.RequestId, out var pendingActivity))
+                                            pendingActivity.TrySetResult(activityResponse);
+                                        break;
+                                    case SharedEstimationMessageType.RemoteRunDeleted:
+                                        var deletionResponse = SharedEstimationProtocol.ReadRemoteRunDeletedPayload(reader);
+                                        if (_pendingRemoteRunDeletionRequests.TryRemove(deletionResponse.RequestId, out var pendingDeletion))
+                                            pendingDeletion.TrySetResult(deletionResponse);
+                                        break;
+                                    default:
+                                        throw new InvalidDataException(
+                                            $"Unexpected shared estimation message from RunServer: {messageType}.");
+                                }
+                            }
+                            break;
+                        case In.DeploymentMessage:
+                            {
+                                var (_, messageType) = DeploymentProtocol.ReadHeader(reader);
+                                switch (messageType)
+                                {
+                                    case DeploymentMessageType.DrainStatus:
+                                    case DeploymentMessageType.DrainCompleted:
+                                    case DeploymentMessageType.DeploymentStaged:
+                                        var status = DeploymentProtocol.ReadStatusPayload(reader);
+                                        if ((messageType == DeploymentMessageType.DrainCompleted ||
+                                            messageType == DeploymentMessageType.DeploymentStaged) &&
+                                            _pendingDrainRequests.TryGetValue(status.RequestId, out var pendingDrain))
+                                        {
+                                            pendingDrain.TrySetResult(status);
+                                            _pendingDrainRequests.TryRemove(status.RequestId, out _);
+                                        }
+                                        IgnoreWarnings(() => RunServerDrainStatusAvailable?.Invoke(this, status));
+                                        break;
+                                    case DeploymentMessageType.DeploymentFailed:
+                                        var requestId = DeploymentProtocol.ReadRequestId(reader);
+                                        var failure = new RunServerDrainStatus(requestId, RunServerDrainState.Failed, 0, 0,
+                                            DeploymentProtocol.ReadFailureMessage(reader));
+                                        if (_pendingDrainRequests.TryGetValue(requestId, out var failedDrain))
+                                            failedDrain.TrySetResult(failure);
+                                        IgnoreWarnings(() => RunServerDrainStatusAvailable?.Invoke(this, failure));
+                                        break;
+                                    default:
+                                        throw new InvalidDataException($"Unexpected deployment message from RunServer: {messageType}.");
+                                }
+                            }
+                            break;
                         default:
-                            throw new Exception($"Unsupported command: {Enum.GetName<In>(command)}");
+                            throw new InvalidDataException(
+                                $"Unsupported command value {commandValue}: {Enum.GetName<In>(command) ?? "unknown"}.");
                     }
                     System.Threading.Interlocked.MemoryBarrier();
                 }
@@ -329,6 +450,12 @@ private Thread StartListenner()
             finally
             {
                 _Exited = true;
+                foreach (var request in _pendingActivityRequests.ToArray())
+                    if (_pendingActivityRequests.TryRemove(request.Key, out var pending))
+                        pending.TrySetException(new IOException("The RunServer connection was closed before the activity response arrived."));
+                foreach (var request in _pendingDrainRequests.ToArray())
+                    if (_pendingDrainRequests.TryRemove(request.Key, out var pending))
+                        pending.TrySetException(new IOException("The RunServer connection was closed during deployment drain."));
                 IgnoreWarnings(() => Disconnected?.Invoke(this, EventArgs.Empty));
             }
         })
@@ -360,6 +487,8 @@ private enum Out
         CancelModelRun = 2,
         KillModelRun = 3,
         RequestClientShutdown = 4,
+        SharedEstimationMessage = 5,
+        DeploymentMessage = 6,
     }
 
     /// <summary>
@@ -402,7 +531,8 @@ public bool RunModelSystem(ModelSystemSession modelSystem, string cwd, string st
     public bool RunModelSystem(ModelSystemSession modelSystem, string cwd, string startToExecute,
         RunMode runMode,
         Action<string>? onIdCreated,
-        [NotNullWhen(true)] out string? id, [NotNullWhen(false)] out CommandError? error)
+        [NotNullWhen(true)] out string? id, [NotNullWhen(false)] out CommandError? error,
+        string? runName = null, Guid? ownerUserId = null)
     {
         id = null;
         lock (_outLock)
@@ -424,6 +554,10 @@ public bool RunModelSystem(ModelSystemSession modelSystem, string cwd, string st
                 writer.Write(cwd);
                 writer.Write(startToExecute);
                 writer.Write((int)runMode);
+                writer.Write(runName ?? Path.GetFileName(cwd.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)));
+                writer.Write(modelSystem.Project.Id.ToString("D"));
+                writer.Write(modelSystem.ModelSystemHeader.Id.ToString("D"));
+                writer.Write(ownerUserId?.ToString("D") ?? string.Empty);
                 writer.Write(memStream.Length);
                 memStream.WriteTo(_HostStream);
                 return true;
@@ -499,7 +633,275 @@ public bool RequestClientShutdown([NotNullWhen(false)] out CommandError? error)
                 writer.Write((int)Out.RequestClientShutdown);
                 return true;
             }
-            catch (IOException e)
+            catch (Exception e) when (e is IOException or ObjectDisposedException or InvalidOperationException or ArgumentException)
+            {
+                error = new CommandError(e.Message);
+                return false;
+            }
+        }
+    }
+
+    public async Task<RunServerDrainStatus> BeginDeploymentDrainAsync(
+        TimeSpan? timeout = null, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var requestId = Guid.NewGuid().ToString("N");
+        var completion = new TaskCompletionSource<RunServerDrainStatus>(TaskCreationOptions.RunContinuationsAsynchronously);
+        if (!_pendingDrainRequests.TryAdd(requestId, completion))
+            throw new InvalidOperationException("Unable to register the deployment drain request.");
+
+        try
+        {
+            if (!WriteDeployment(writer => DeploymentProtocol.WriteBeginDrain(writer, requestId), out var error))
+                throw new IOException(error?.Message ?? "Unable to begin RunServer deployment drain.");
+        }
+        catch
+        {
+            _pendingDrainRequests.TryRemove(requestId, out _);
+            throw;
+        }
+
+        using var linkedCancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        linkedCancellation.CancelAfter(timeout ?? TimeSpan.FromMinutes(30));
+        using var registration = linkedCancellation.Token.Register(() =>
+        {
+            if (_pendingDrainRequests.TryRemove(requestId, out var pending))
+                pending.TrySetCanceled(linkedCancellation.Token);
+            WriteDeployment(writer => DeploymentProtocol.WriteCancelDrain(writer, requestId), out _);
+        });
+
+        try
+        {
+            return await completion.Task.ConfigureAwait(false);
+        }
+        finally
+        {
+            _pendingDrainRequests.TryRemove(requestId, out _);
+        }
+    }
+
+    public bool SendDeploymentArchive(string requestId, byte[] archive,
+        [NotNullWhen(false)] out CommandError? error)
+    {
+        error = null;
+        try
+        {
+            var hash = Convert.ToHexString(SHA256.HashData(archive));
+            return WriteDeployment(writer => DeploymentProtocol.WriteDeployArchive(writer, requestId, archive, hash), out error);
+        }
+        catch (ArgumentException exception)
+        {
+            error = new CommandError(exception.Message);
+            return false;
+        }
+    }
+
+    public bool ActivateDeployment(string requestId,
+        [NotNullWhen(false)] out CommandError? error)
+        => WriteDeployment(writer => DeploymentProtocol.WriteActivateDeployment(writer, requestId), out error);
+
+    public async Task<RunServerDrainStatus> SendDeploymentArchiveAsync(string requestId, byte[] archive,
+        TimeSpan? timeout = null, CancellationToken cancellationToken = default)
+    {
+        var completion = new TaskCompletionSource<RunServerDrainStatus>(TaskCreationOptions.RunContinuationsAsynchronously);
+        if (!_pendingDrainRequests.TryAdd(requestId, completion))
+            throw new InvalidOperationException("A deployment request with this ID is already pending.");
+
+        try
+        {
+            if (!SendDeploymentArchive(requestId, archive, out var error))
+                throw new IOException(error?.Message ?? "Unable to send the deployment archive.");
+
+            using var linkedCancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            linkedCancellation.CancelAfter(timeout ?? TimeSpan.FromMinutes(30));
+            using var registration = linkedCancellation.Token.Register(() =>
+            {
+                if (_pendingDrainRequests.TryRemove(requestId, out var pending))
+                    pending.TrySetCanceled(linkedCancellation.Token);
+            });
+            return await completion.Task.ConfigureAwait(false);
+        }
+        finally
+        {
+            _pendingDrainRequests.TryRemove(requestId, out _);
+        }
+    }
+
+    public bool StartSharedEstimation(SharedEstimationRunRequest request,
+        [NotNullWhen(false)] out CommandError? error)
+        => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteRunRequest(writer, request), out error);
+
+    public bool StartRemoteSharedEstimation(SharedEstimationCoordinatorRequest request,
+        [NotNullWhen(false)] out CommandError? error)
+        => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteCoordinatorRequest(writer, request), out error);
+
+    public bool AddSharedEstimationWorker(SharedEstimationWorkerRegistration registration,
+        [NotNullWhen(false)] out CommandError? error)
+        => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteWorkerRegistration(writer, registration, remove: false), out error);
+
+    public bool RemoveSharedEstimationWorker(SharedEstimationWorkerRegistration registration,
+        [NotNullWhen(false)] out CommandError? error)
+        => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteWorkerRegistration(writer, registration, remove: true), out error);
+
+    public bool SendSharedEstimationCandidate(SharedEstimationCandidate candidate,
+        [NotNullWhen(false)] out CommandError? error)
+        => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteCandidate(writer, candidate), out error);
+
+    public bool CancelSharedEstimation(string runId, string? reason,
+        [NotNullWhen(false)] out CommandError? error)
+        => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteCancel(writer, runId, reason), out error);
+
+    public bool QuerySharedEstimationJobs([NotNullWhen(false)] out CommandError? error)
+        => WriteSharedEstimation(SharedEstimationProtocol.WriteQueryJobs, out error);
+
+    public bool QueryRemoteRuns([NotNullWhen(false)] out CommandError? error)
+        => WriteSharedEstimation(SharedEstimationProtocol.WriteQueryRemoteRuns, out error);
+
+    public async Task<RunServerActivityResponse> QueryServerActivityAsync(
+        TimeSpan? timeout = null, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var requestId = Guid.NewGuid().ToString("N");
+        var completion = new TaskCompletionSource<RunServerActivityResponse>(TaskCreationOptions.RunContinuationsAsynchronously);
+        if (!_pendingActivityRequests.TryAdd(requestId, completion))
+            throw new InvalidOperationException("Unable to register the RunServer activity request.");
+
+        try
+        {
+            if (!WriteSharedEstimation(writer =>
+                SharedEstimationProtocol.WriteQueryServerActivity(writer, requestId), out var error))
+                throw new IOException(error?.Message ?? "Unable to query RunServer activity.");
+        }
+        catch
+        {
+            _pendingActivityRequests.TryRemove(requestId, out _);
+            throw;
+        }
+
+        using var linkedCancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        linkedCancellation.CancelAfter(timeout ?? TimeSpan.FromSeconds(8));
+        using var registration = linkedCancellation.Token.Register(() =>
+        {
+            if (_pendingActivityRequests.TryRemove(requestId, out var pending))
+                pending.TrySetCanceled(linkedCancellation.Token);
+        });
+
+        try
+        {
+            return await completion.Task.ConfigureAwait(false);
+        }
+        finally
+        {
+            _pendingActivityRequests.TryRemove(requestId, out _);
+        }
+    }
+
+    public bool RequestRemoteRunArtifacts(string runId, [NotNullWhen(false)] out CommandError? error)
+        => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteGetRemoteRunArtifacts(writer, runId), out error);
+
+    public bool AcknowledgeRemoteRun(string runId, [NotNullWhen(false)] out CommandError? error)
+        => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteAcknowledgeRemoteRun(writer, runId), out error);
+
+    public async Task<RemoteRunDeletionResponse> DeleteRemoteRunAsync(string runId,
+        TimeSpan? timeout = null, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var requestId = Guid.NewGuid().ToString("N");
+        var completion = new TaskCompletionSource<RemoteRunDeletionResponse>(TaskCreationOptions.RunContinuationsAsynchronously);
+        if (!_pendingRemoteRunDeletionRequests.TryAdd(requestId, completion))
+            throw new InvalidOperationException("Unable to register the remote run deletion request.");
+
+        try
+        {
+            if (!WriteSharedEstimation(writer =>
+                SharedEstimationProtocol.WriteDeleteRemoteRun(writer, requestId, runId), out var error))
+                throw new IOException(error?.Message ?? "Unable to request remote run deletion.");
+        }
+        catch
+        {
+            _pendingRemoteRunDeletionRequests.TryRemove(requestId, out _);
+            throw;
+        }
+
+        using var linkedCancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        linkedCancellation.CancelAfter(timeout ?? TimeSpan.FromSeconds(15));
+        using var registration = linkedCancellation.Token.Register(() =>
+        {
+            if (_pendingRemoteRunDeletionRequests.TryRemove(requestId, out var pending))
+                pending.TrySetCanceled(linkedCancellation.Token);
+        });
+
+        try
+        {
+            return await completion.Task.ConfigureAwait(false);
+        }
+        finally
+        {
+            _pendingRemoteRunDeletionRequests.TryRemove(requestId, out _);
+        }
+    }
+
+    public bool AddRemoteEstimationWorker(string runId, SharedEstimationWorkerEndpoint worker,
+        [NotNullWhen(false)] out CommandError? error)
+        => WriteSharedEstimation(writer =>
+            SharedEstimationProtocol.WriteCoordinatorWorkerRequest(writer, runId, worker, remove: false), out error);
+
+    public bool RemoveRemoteEstimationWorker(string runId, SharedEstimationWorkerEndpoint worker,
+        [NotNullWhen(false)] out CommandError? error)
+        => WriteSharedEstimation(writer =>
+            SharedEstimationProtocol.WriteCoordinatorWorkerRequest(writer, runId, worker, remove: true), out error);
+
+    private bool WriteSharedEstimation(Action<BinaryWriter> writePayload,
+        [NotNullWhen(false)] out CommandError? error)
+    {
+        error = null;
+        using var payload = new MemoryStream();
+        try
+        {
+            using var payloadWriter = new BinaryWriter(payload, Encoding.UTF8, true);
+            writePayload(payloadWriter);
+            payloadWriter.Flush();
+        }
+        catch (ArgumentException e)
+        {
+            error = new CommandError(e.Message);
+            return false;
+        }
+
+        lock (_outLock)
+        {
+            try
+            {
+                using var writer = new BinaryWriter(_HostStream, Encoding.UTF8, true);
+                writer.Write((int)Out.SharedEstimationMessage);
+                payload.Position = 0;
+                payload.CopyTo(_HostStream);
+                writer.Flush();
+                return true;
+            }
+            catch (Exception e) when (e is IOException or ObjectDisposedException or InvalidOperationException or ArgumentException)
+            {
+                error = new CommandError(e.Message);
+                return false;
+            }
+        }
+    }
+
+    private bool WriteDeployment(Action<BinaryWriter> writePayload,
+        [NotNullWhen(false)] out CommandError? error)
+    {
+        error = null;
+        lock (_outLock)
+        {
+            try
+            {
+                using var writer = new BinaryWriter(_HostStream, Encoding.UTF8, true);
+                writer.Write((int)Out.DeploymentMessage);
+                writePayload(writer);
+                writer.Flush();
+                return true;
+            }
+            catch (Exception e) when (e is IOException or ObjectDisposedException or InvalidOperationException or ArgumentException)
             {
                 error = new CommandError(e.Message);
                 return false;
diff --git a/src/XTMF2/Bus/IRunOutputSink.cs b/src/XTMF2/Bus/IRunOutputSink.cs
new file mode 100644
index 00000000..ae8086ae
--- /dev/null
+++ b/src/XTMF2/Bus/IRunOutputSink.cs
@@ -0,0 +1,27 @@
+using System.IO;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace XTMF2.Bus;
+
+internal interface IRunOutputSink
+{
+    IReadOnlyList<string> ExtraDlls { get; }
+
+    Task StartProcessingRequestFromRun(string id, Stream clientToRunStream);
+
+    void ModelRunFailedValidation(string runId, string? error, string? moduleName = null, string? elementId = null);
+
+    void ModelRunFailed(string runId, string? message, string? stackTrace, string? moduleName = null, string? elementId = null);
+
+    void SendStatusMessage(string runId, string? message);
+
+    void SendOptimizationResults(string runId, IReadOnlyList<(int nodeIndex, double value)> results);
+
+    void SendIterationProgress(string runId, int iteration, double fitness,
+        int fitnessTestsThisIteration, IReadOnlyList<(int nodeIndex, double value)> values);
+
+    void ModelRunComplete(string runId);
+
+    void SendRunArtifacts(string runId, string runDirectory);
+}
\ No newline at end of file
diff --git a/src/XTMF2/Bus/Optimization/EstimationAlgorithmConfig.cs b/src/XTMF2/Bus/Optimization/EstimationAlgorithmConfig.cs
index 71a47423..0c5136d0 100644
--- a/src/XTMF2/Bus/Optimization/EstimationAlgorithmConfig.cs
+++ b/src/XTMF2/Bus/Optimization/EstimationAlgorithmConfig.cs
@@ -31,10 +31,51 @@ namespace XTMF2.Bus.Optimization;
 /// </summary>
 public abstract class EstimationAlgorithmConfig : INotifyPropertyChanged
 {
+    private int _randomSeed = 42;
+
     public event PropertyChangedEventHandler? PropertyChanged;
     protected void Raise(string name) =>
         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
 
+    public int RandomSeed
+    {
+        get => _randomSeed;
+        set
+        {
+            if (_randomSeed == value) return;
+            _randomSeed = value;
+            Raise(nameof(RandomSeed));
+        }
+    }
+
+    protected AlgorithmParameterDescriptor CreateRandomSeedParameter() => new()
+    {
+        Key = "RandomSeed",
+        Label = "Random Seed",
+        Hint = "Use the same seed to reproduce stochastic search results",
+        Value = RandomSeed.ToString(CultureInfo.InvariantCulture)
+    };
+
+    protected bool TryReadRandomSeed(
+        IReadOnlyList<AlgorithmParameterDescriptor> parameters,
+        out int randomSeed,
+        out string? error)
+    {
+        randomSeed = RandomSeed;
+        error = null;
+        foreach (var parameter in parameters)
+        {
+            if (parameter.Key != "RandomSeed")
+                continue;
+            if (!int.TryParse(parameter.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out randomSeed))
+            {
+                error = "Random Seed must be a 32-bit integer.";
+                return false;
+            }
+        }
+        return true;
+    }
+
     /// <summary>Stable identifier used as the JSON type-discriminator.</summary>
     public abstract string AlgorithmId { get; }
 
@@ -73,6 +114,7 @@ internal void Save(Utf8JsonWriter writer)
     {
         writer.WriteStartObject();
         writer.WriteString(TypeProperty, AlgorithmId);
+        writer.WriteNumber("RandomSeed", RandomSeed);
         SaveProperties(writer);
         writer.WriteEndObject();
     }
@@ -118,6 +160,11 @@ internal void Save(Utf8JsonWriter writer)
             var prop = reader.GetString() ?? string.Empty;
             reader.Read();
             if (prop == TypeProperty) continue;
+            if (prop == "RandomSeed")
+            {
+                cfg.RandomSeed = reader.GetInt32();
+                continue;
+            }
             cfg.LoadProperty(prop, ref reader);
         }
         return cfg;
@@ -140,6 +187,34 @@ private static void SkipObject(ref Utf8JsonReader reader)
     /// <summary>Default algorithm config used when no config is stored in the file.</summary>
     public static EstimationAlgorithmConfig Default => new NelderMeadConfig();
 
+    public static EstimationAlgorithmConfig? Create(string algorithmId)
+    {
+        foreach (var algorithm in AvailableAlgorithms)
+        {
+            if (algorithm.AlgorithmId != algorithmId)
+                continue;
+            return algorithm.AlgorithmId switch
+            {
+                NelderMeadConfig.Id => new NelderMeadConfig(),
+                ParticleSwarmConfig.Id => new ParticleSwarmConfig(),
+                GeneticAlgorithmConfig.Id => new GeneticAlgorithmConfig(),
+                StochasticGradientConfig.Id => new StochasticGradientConfig(),
+                _ => null
+            };
+        }
+        return null;
+    }
+
+    public EstimationAlgorithmConfig Clone()
+    {
+        var clone = Create(AlgorithmId)
+            ?? throw new InvalidOperationException($"Unknown estimation algorithm '{AlgorithmId}'.");
+        var error = clone.ApplyParameters(GetParameters());
+        if (error is not null)
+            throw new InvalidOperationException($"Unable to copy estimation algorithm configuration: {error}");
+        return clone;
+    }
+
     /// <inheritdoc/>
     public override bool Equals(object? obj) =>
         obj is EstimationAlgorithmConfig other && AlgorithmId == other.AlgorithmId;
@@ -183,6 +258,7 @@ public double ConvergenceTolerance
 
     public override IReadOnlyList<AlgorithmParameterDescriptor> GetParameters() =>
     [
+        CreateRandomSeedParameter(),
         new() { Key = "MaxIterations",        Label = "Max Iterations",
                 Hint  = "Stop after this many simplex iterations",
                 Value = _maxIterations.ToString(CultureInfo.InvariantCulture) },
@@ -193,6 +269,8 @@ public override IReadOnlyList<AlgorithmParameterDescriptor> GetParameters() =>
 
     public override string? ApplyParameters(IReadOnlyList<AlgorithmParameterDescriptor> parameters)
     {
+        if (!TryReadRandomSeed(parameters, out var randomSeed, out var seedError))
+            return seedError;
         var inv = CultureInfo.InvariantCulture;
         int mi = _maxIterations; double tol = _convergenceTolerance;
         foreach (var p in parameters)
@@ -211,6 +289,7 @@ public override IReadOnlyList<AlgorithmParameterDescriptor> GetParameters() =>
         }
         _maxIterations = mi;
         _convergenceTolerance = tol;
+        RandomSeed = randomSeed;
         return null;
     }
 
@@ -313,6 +392,7 @@ public int NoImprovementLimit
 
     public override IReadOnlyList<AlgorithmParameterDescriptor> GetParameters() =>
     [
+        CreateRandomSeedParameter(),
         new() { Key = "SwarmSize",            Label = "Swarm Size",
                 Hint  = "Number of particles (minimum 2)",
                 Value = _swarmSize.ToString(CultureInfo.InvariantCulture) },
@@ -338,6 +418,8 @@ public override IReadOnlyList<AlgorithmParameterDescriptor> GetParameters() =>
 
     public override string? ApplyParameters(IReadOnlyList<AlgorithmParameterDescriptor> parameters)
     {
+        if (!TryReadRandomSeed(parameters, out var randomSeed, out var seedError))
+            return seedError;
         var inv = CultureInfo.InvariantCulture;
         int swarm = _swarmSize, maxIter = _maxIterations, noImprove = _noImprovementLimit;
         double inertia = _inertia, cog = _cognitiveCoeff, soc = _socialCoeff, tol = _convergenceTolerance;
@@ -378,6 +460,7 @@ public override IReadOnlyList<AlgorithmParameterDescriptor> GetParameters() =>
         _swarmSize = swarm; _maxIterations = maxIter; _inertia = inertia;
         _cognitiveCoeff = cog; _socialCoeff = soc; _convergenceTolerance = tol;
         _noImprovementLimit = noImprove;
+        RandomSeed = randomSeed;
         return null;
     }
 
@@ -385,7 +468,8 @@ public override IEstimationAlgorithm CreateAlgorithm(
         int dimensions, double[] lower, double[] upper, double[] initial,
         bool isMaximize = false)
     {
-        var alg = new ParticleSwarmAlgorithm(_swarmSize, _inertia, _cognitiveCoeff, _socialCoeff, _noImprovementLimit);
+        var alg = new ParticleSwarmAlgorithm(_swarmSize, _inertia, _cognitiveCoeff, _socialCoeff,
+            _noImprovementLimit, RandomSeed);
         alg.Initialize(dimensions, lower, upper, initial, _maxIterations, _convergenceTolerance, isMaximize);
         return alg;
     }
@@ -489,6 +573,7 @@ public double ConvergenceTolerance
 
     public override IReadOnlyList<AlgorithmParameterDescriptor> GetParameters() =>
     [
+        CreateRandomSeedParameter(),
         new() { Key = "PopulationSize",       Label = "Population Size",
                 Hint  = "Individuals per generation (minimum 4)",
                 Value = _populationSize.ToString(CultureInfo.InvariantCulture) },
@@ -514,6 +599,8 @@ public override IReadOnlyList<AlgorithmParameterDescriptor> GetParameters() =>
 
     public override string? ApplyParameters(IReadOnlyList<AlgorithmParameterDescriptor> parameters)
     {
+        if (!TryReadRandomSeed(parameters, out var randomSeed, out var seedError))
+            return seedError;
         var inv = CultureInfo.InvariantCulture;
         int pop = _populationSize, maxGen = _maxGenerations, elite = _elitismCount, tournament = _tournamentSize;
         double cross = _crossoverRate, mut = _mutationRate, tol = _convergenceTolerance;
@@ -554,6 +641,7 @@ public override IReadOnlyList<AlgorithmParameterDescriptor> GetParameters() =>
         _populationSize = pop; _maxGenerations = maxGen; _crossoverRate = cross;
         _mutationRate = mut; _elitismCount = elite; _tournamentSize = tournament;
         _convergenceTolerance = tol;
+        RandomSeed = randomSeed;
         return null;
     }
 
@@ -562,7 +650,7 @@ public override IEstimationAlgorithm CreateAlgorithm(
         bool isMaximize = false)
     {
         var alg = new GeneticAlgorithm(_populationSize, _crossoverRate, _mutationRate,
-                                       _elitismCount, _tournamentSize);
+                                       _elitismCount, _tournamentSize, RandomSeed);
         alg.Initialize(dimensions, lower, upper, initial, _maxGenerations, _convergenceTolerance, isMaximize);
         return alg;
     }
@@ -665,6 +753,7 @@ public double Gamma
 
     public override IReadOnlyList<AlgorithmParameterDescriptor> GetParameters() =>
     [
+        CreateRandomSeedParameter(),
         new() { Key = "MaxIterations",        Label = "Max Iterations",
                 Hint  = "Hard cap on SPSA iterations (each uses 3 evaluations)",
                 Value = _maxIterations.ToString(CultureInfo.InvariantCulture) },
@@ -690,6 +779,8 @@ public override IReadOnlyList<AlgorithmParameterDescriptor> GetParameters() =>
 
     public override string? ApplyParameters(IReadOnlyList<AlgorithmParameterDescriptor> parameters)
     {
+        if (!TryReadRandomSeed(parameters, out var randomSeed, out var seedError))
+            return seedError;
         var inv = CultureInfo.InvariantCulture;
         int maxIter = _maxIterations;
         double tol = _convergenceTolerance, a = _a, c = _c, bigA = _bigA, alpha = _alpha, gamma = _gamma;
@@ -729,6 +820,7 @@ public override IReadOnlyList<AlgorithmParameterDescriptor> GetParameters() =>
         }
         _maxIterations = maxIter; _convergenceTolerance = tol;
         _a = a; _c = c; _bigA = bigA; _alpha = alpha; _gamma = gamma;
+        RandomSeed = randomSeed;
         return null;
     }
 
@@ -736,7 +828,7 @@ public override IEstimationAlgorithm CreateAlgorithm(
         int dimensions, double[] lower, double[] upper, double[] initial,
         bool isMaximize = false)
     {
-        var alg = new StochasticGradientAlgorithm(_a, _c, _bigA, _alpha, _gamma);
+        var alg = new StochasticGradientAlgorithm(_a, _c, _bigA, _alpha, _gamma, RandomSeed);
         alg.Initialize(dimensions, lower, upper, initial, _maxIterations, _convergenceTolerance, isMaximize);
         return alg;
     }
diff --git a/src/XTMF2/Bus/Optimization/EstimationAlgorithms/GeneticAlgorithm.cs b/src/XTMF2/Bus/Optimization/EstimationAlgorithms/GeneticAlgorithm.cs
index 06435f2b..fe01f0e0 100644
--- a/src/XTMF2/Bus/Optimization/EstimationAlgorithms/GeneticAlgorithm.cs
+++ b/src/XTMF2/Bus/Optimization/EstimationAlgorithms/GeneticAlgorithm.cs
@@ -17,6 +17,7 @@ You should have received a copy of the GNU General Public License
     along with XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 using System;
+using System.Collections.Generic;
 
 namespace XTMF2.Bus.Optimization;
 
@@ -27,7 +28,7 @@ namespace XTMF2.Bus.Optimization;
 /// Uses <b>arithmetic (BLX-α) crossover</b>, <b>Gaussian mutation</b>,
 /// <b>tournament selection</b>, and optional elitism.
 /// Each gene is clamped to its per-dimension bounds after mutation.
-/// The algorithm is deterministic given a fixed random seed (42).
+/// The algorithm is deterministic given a fixed configured random seed.
 /// </remarks>
 public sealed class GeneticAlgorithm : IEstimationAlgorithm
 {
@@ -36,6 +37,7 @@ public sealed class GeneticAlgorithm : IEstimationAlgorithm
     private readonly double _mutationRate;
     private readonly int    _elitismCount;
     private readonly int    _tournamentSize;
+    private readonly int    _randomSeed;
 
     private int      _n;
     private double[] _lower   = [];
@@ -59,18 +61,21 @@ public sealed class GeneticAlgorithm : IEstimationAlgorithm
     /// <summary>
     /// Creates a new <see cref="GeneticAlgorithm"/> with the specified hyperparameters.
     /// </summary>
+    /// <param name="randomSeed">Seed used for reproducible population initialization and evolution.</param>
     public GeneticAlgorithm(
         int    populationSize = 50,
         double crossoverRate  = 0.8,
         double mutationRate   = 0.05,
         int    elitismCount   = 2,
-        int    tournamentSize = 3)
+        int    tournamentSize = 3,
+        int    randomSeed      = 42)
     {
         _populationSize = Math.Max(4, populationSize);
         _crossoverRate  = Math.Clamp(crossoverRate, 0.0, 1.0);
         _mutationRate   = Math.Clamp(mutationRate,  0.0, 1.0);
         _elitismCount   = Math.Max(0, elitismCount);
         _tournamentSize = Math.Max(2, tournamentSize);
+        _randomSeed     = randomSeed;
     }
 
     /// <inheritdoc/>
@@ -92,10 +97,20 @@ public void Initialize(int dimensions, double[] lowerBounds, double[] upperBound
     public void Run(Func<double[], double> fitnessEvaluator,
                     Action<int, double>? progressCallback = null,
                     Func<bool>? shouldCancel = null)
+    {
+        RunBatch(fitnessEvaluator, candidates => EvaluateSequentially(fitnessEvaluator, candidates),
+            progressCallback, shouldCancel);
+    }
+
+    /// <inheritdoc/>
+    public void RunBatch(Func<double[], double> fitnessEvaluator,
+                         Func<IReadOnlyList<double[]>, IReadOnlyList<double>> batchFitnessEvaluator,
+                         Action<int, double>? progressCallback = null,
+                         Func<bool>? shouldCancel = null)
     {
         if (_n == 0) return;
 
-        var rng = new Random(42);
+        var rng = new Random(_randomSeed);
 
         // Negate fitness internally when maximising so the algorithm always minimises.
         Func<double[], double> eval = _isMaximize
@@ -116,9 +131,12 @@ public void Run(Func<double[], double> fitnessEvaluator,
                 population[i][d] = _lower[d] + rng.NextDouble() * (_upper[d] - _lower[d]);
         }
 
+        var initialFitness = batchFitnessEvaluator(population);
+        if (initialFitness.Count != population.Length)
+            throw new InvalidOperationException("The batch fitness evaluator must return one value per candidate.");
         for (int i = 0; i < _populationSize; i++)
         {
-            fitnesses[i] = eval(population[i]);
+            fitnesses[i] = _isMaximize ? -initialFitness[i] : initialFitness[i];
             if (fitnesses[i] < _bestInternalFitness)
             {
                 _bestInternalFitness = fitnesses[i];
@@ -164,12 +182,23 @@ public void Run(Func<double[], double> fitnessEvaluator,
 
                 Mutate(rng, child);
                 next[i]    = child;
-                nextFit[i] = eval(child);
+            }
 
+            var generated = new double[_populationSize - eliteCount][];
+            for (int i = eliteCount; i < _populationSize; i++)
+                generated[i - eliteCount] = next[i];
+            var generatedFitness = batchFitnessEvaluator(generated);
+            if (generatedFitness.Count != generated.Length)
+                throw new InvalidOperationException("The batch fitness evaluator must return one value per candidate.");
+            for (int i = eliteCount; i < _populationSize; i++)
+            {
+                nextFit[i] = _isMaximize
+                    ? -generatedFitness[i - eliteCount]
+                    : generatedFitness[i - eliteCount];
                 if (nextFit[i] < _bestInternalFitness)
                 {
                     _bestInternalFitness = nextFit[i];
-                    BestParameters       = (double[])child.Clone();
+                    BestParameters       = (double[])next[i].Clone();
                 }
             }
 
@@ -185,6 +214,15 @@ public void Run(Func<double[], double> fitnessEvaluator,
         }
     }
 
+    private static IReadOnlyList<double> EvaluateSequentially(
+        Func<double[], double> fitnessEvaluator, IReadOnlyList<double[]> candidates)
+    {
+        var results = new double[candidates.Count];
+        for (int i = 0; i < candidates.Count; i++)
+            results[i] = fitnessEvaluator(candidates[i]);
+        return results;
+    }
+
     /// <summary>Tournament selection — returns index of the winner (lowest fitness).</summary>
     private int TournamentSelect(Random rng, double[] fitnesses)
     {
diff --git a/src/XTMF2/Bus/Optimization/EstimationAlgorithms/NelderMeadAlgorithm.cs b/src/XTMF2/Bus/Optimization/EstimationAlgorithms/NelderMeadAlgorithm.cs
index 319ee1b8..a67cc84a 100644
--- a/src/XTMF2/Bus/Optimization/EstimationAlgorithms/NelderMeadAlgorithm.cs
+++ b/src/XTMF2/Bus/Optimization/EstimationAlgorithms/NelderMeadAlgorithm.cs
@@ -18,6 +18,7 @@ You should have received a copy of the GNU General Public License
 */
 
 using System;
+using System.Collections.Generic;
 
 namespace XTMF2.Bus.Optimization;
 
@@ -80,6 +81,16 @@ public void Initialize(int dimensions, double[] lowerBounds, double[] upperBound
     public void Run(Func<double[], double> fitnessEvaluator,
                     Action<int, double>? progressCallback = null,
                     Func<bool>? shouldCancel = null)
+    {
+        RunBatch(fitnessEvaluator, candidates => EvaluateSequentially(fitnessEvaluator, candidates),
+            progressCallback, shouldCancel);
+    }
+
+    /// <inheritdoc/>
+    public void RunBatch(Func<double[], double> fitnessEvaluator,
+                         Func<IReadOnlyList<double[]>, IReadOnlyList<double>> batchFitnessEvaluator,
+                         Action<int, double>? progressCallback = null,
+                         Func<bool>? shouldCancel = null)
     {
         if (_n == 0) return;
 
@@ -103,10 +114,13 @@ public void Run(Func<double[], double> fitnessEvaluator,
             simplex[i] = Clamp(v);
         }
 
-        // Evaluate all initial vertices
+        // The initial simplex is independent and can be evaluated concurrently.
+        var initialFitness = batchFitnessEvaluator(simplex);
+        if (initialFitness.Count != simplex.Length)
+            throw new InvalidOperationException("The batch fitness evaluator must return one value per candidate.");
         for (int i = 0; i <= _n; i++)
         {
-            fitness[i] = eval(simplex[i]);
+            fitness[i] = _isMaximize ? -initialFitness[i] : initialFitness[i];
             TrackBest(simplex[i], fitness[i]);
         }
 
@@ -206,10 +220,16 @@ public void Run(Func<double[], double> fitnessEvaluator,
                 {
                     // Shrink all vertices toward the best
                     var xBest = simplex[idx[0]];
+                    var shrinkCandidates = new double[_n][];
+                    for (int s = 1; s <= _n; s++)
+                        shrinkCandidates[s - 1] = simplex[idx[s]] =
+                            Clamp(AddScaled(xBest, Sigma, Sub(simplex[idx[s]], xBest)));
+                    var shrinkFitness = batchFitnessEvaluator(shrinkCandidates);
+                    if (shrinkFitness.Count != shrinkCandidates.Length)
+                        throw new InvalidOperationException("The batch fitness evaluator must return one value per candidate.");
                     for (int s = 1; s <= _n; s++)
                     {
-                        simplex[idx[s]] = Clamp(AddScaled(xBest, Sigma, Sub(simplex[idx[s]], xBest)));
-                        fitness[idx[s]] = eval(simplex[idx[s]]);
+                        fitness[idx[s]] = _isMaximize ? -shrinkFitness[s - 1] : shrinkFitness[s - 1];
                         TrackBest(simplex[idx[s]], fitness[idx[s]]);
                     }
                 }
@@ -219,6 +239,15 @@ public void Run(Func<double[], double> fitnessEvaluator,
         }
     }
 
+    private static IReadOnlyList<double> EvaluateSequentially(
+        Func<double[], double> fitnessEvaluator, IReadOnlyList<double[]> candidates)
+    {
+        var results = new double[candidates.Count];
+        for (int i = 0; i < candidates.Count; i++)
+            results[i] = fitnessEvaluator(candidates[i]);
+        return results;
+    }
+
     // ── Helpers ──────────────────────────────────────────────────────────────────
 
     private void TrackBest(double[] point, double f)
diff --git a/src/XTMF2/Bus/Optimization/EstimationAlgorithms/ParticleSwarmAlgorithm.cs b/src/XTMF2/Bus/Optimization/EstimationAlgorithms/ParticleSwarmAlgorithm.cs
index 74603ac3..a36332cd 100644
--- a/src/XTMF2/Bus/Optimization/EstimationAlgorithms/ParticleSwarmAlgorithm.cs
+++ b/src/XTMF2/Bus/Optimization/EstimationAlgorithms/ParticleSwarmAlgorithm.cs
@@ -17,6 +17,7 @@ You should have received a copy of the GNU General Public License
     along with XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 using System;
+using System.Collections.Generic;
 
 namespace XTMF2.Bus.Optimization;
 
@@ -38,6 +39,7 @@ public sealed class ParticleSwarmAlgorithm : IEstimationAlgorithm
     private readonly double _c1;   // cognitive coefficient
     private readonly double _c2;   // social coefficient
     private readonly int    _noImprovementLimit;
+    private readonly int    _randomSeed;
 
     private int      _n;
     private double[] _lower   = [];
@@ -67,16 +69,18 @@ public sealed class ParticleSwarmAlgorithm : IEstimationAlgorithm
     /// <param name="socialCoeff">Global-best attraction c2 (default 1.49).</param>
     /// <param name="noImprovementLimit">Stop after this many consecutive iterations
     /// without improvement in the global best (default 5). Set to 0 to disable.</param>
+    /// <param name="randomSeed">Seed used for reproducible swarm initialization and updates.</param>
     public ParticleSwarmAlgorithm(
         int swarmSize = 29, double inertia = -0.4438,
         double cognitiveCoeff = -0.2699, double socialCoeff = 3.3950,
-        int noImprovementLimit = 5)
+        int noImprovementLimit = 5, int randomSeed = 42)
     {
         _swarmSize          = Math.Max(2, swarmSize);
         _inertia            = inertia;
         _c1                 = cognitiveCoeff;
         _c2                 = socialCoeff;
         _noImprovementLimit = Math.Max(0, noImprovementLimit);
+        _randomSeed         = randomSeed;
     }
 
     /// <inheritdoc/>
@@ -98,10 +102,20 @@ public void Initialize(int dimensions, double[] lowerBounds, double[] upperBound
     public void Run(Func<double[], double> fitnessEvaluator,
                     Action<int, double>? progressCallback = null,
                     Func<bool>? shouldCancel = null)
+    {
+        RunBatch(fitnessEvaluator, candidates => EvaluateSequentially(fitnessEvaluator, candidates),
+            progressCallback, shouldCancel);
+    }
+
+    /// <inheritdoc/>
+    public void RunBatch(Func<double[], double> fitnessEvaluator,
+                         Func<IReadOnlyList<double[]>, IReadOnlyList<double>> batchFitnessEvaluator,
+                         Action<int, double>? progressCallback = null,
+                         Func<bool>? shouldCancel = null)
     {
         if (_n == 0) return;
 
-        var rng = new Random(42);
+        var rng = new Random(_randomSeed);
 
         // Negate fitness internally when maximising so the algorithm always minimises.
         Func<double[], double> eval = _isMaximize
@@ -133,10 +147,13 @@ public void Run(Func<double[], double> fitnessEvaluator,
             }
         }
 
-        // Evaluate initial fitness.
+        // Evaluate initial fitness as one independent population.
+        var initialFitness = batchFitnessEvaluator(positions);
+        if (initialFitness.Count != positions.Length)
+            throw new InvalidOperationException("The batch fitness evaluator must return one value per candidate.");
         for (int i = 0; i < _swarmSize; i++)
         {
-            double f = eval(positions[i]);
+            double f = _isMaximize ? -initialFitness[i] : initialFitness[i];
             pBest[i]    = (double[])positions[i].Clone();
             pBestFit[i] = f;
             if (f < _bestInternalFitness)
@@ -171,7 +188,14 @@ public void Run(Func<double[], double> fitnessEvaluator,
                         positions[i][d] + velocities[i][d]));
                 }
 
-                double fitness = eval(positions[i]);
+            }
+
+            var populationFitness = batchFitnessEvaluator(positions);
+            if (populationFitness.Count != positions.Length)
+                throw new InvalidOperationException("The batch fitness evaluator must return one value per candidate.");
+            for (int i = 0; i < _swarmSize; i++)
+            {
+                double fitness = _isMaximize ? -populationFitness[i] : populationFitness[i];
                 if (fitness < pBestFit[i])
                 {
                     pBestFit[i] = fitness;
@@ -202,6 +226,15 @@ public void Run(Func<double[], double> fitnessEvaluator,
         }
     }
 
+    private static IReadOnlyList<double> EvaluateSequentially(
+        Func<double[], double> fitnessEvaluator, IReadOnlyList<double[]> candidates)
+    {
+        var results = new double[candidates.Count];
+        for (int i = 0; i < candidates.Count; i++)
+            results[i] = fitnessEvaluator(candidates[i]);
+        return results;
+    }
+
     private double[] Clamp(double[] v)
     {
         for (int d = 0; d < _n; d++)
diff --git a/src/XTMF2/Bus/Optimization/EstimationAlgorithms/StochasticGradientAlgorithm.cs b/src/XTMF2/Bus/Optimization/EstimationAlgorithms/StochasticGradientAlgorithm.cs
index 729adb44..c46cddf8 100644
--- a/src/XTMF2/Bus/Optimization/EstimationAlgorithms/StochasticGradientAlgorithm.cs
+++ b/src/XTMF2/Bus/Optimization/EstimationAlgorithms/StochasticGradientAlgorithm.cs
@@ -44,6 +44,7 @@ public sealed class StochasticGradientAlgorithm : IEstimationAlgorithm
     private readonly double _bigA;       // stability constant A
     private readonly double _alpha;      // step-size decay exponent
     private readonly double _gamma;      // perturbation-size decay exponent
+    private readonly int _randomSeed;
 
     private int      _n;
     private double[] _lower   = [];
@@ -72,18 +73,21 @@ public sealed class StochasticGradientAlgorithm : IEstimationAlgorithm
     /// <param name="bigA">Stability constant — typically 10 % of max iterations (default 20).</param>
     /// <param name="alpha">Step-size decay exponent (default 0.602).</param>
     /// <param name="gamma">Perturbation decay exponent (default 0.101).</param>
+    /// <param name="randomSeed">Seed used for reproducible perturbations.</param>
     public StochasticGradientAlgorithm(
         double a      = 0.1,
         double c      = 0.1,
         double bigA   = 20.0,
         double alpha  = 0.602,
-        double gamma  = 0.101)
+        double gamma  = 0.101,
+        int randomSeed = 42)
     {
         _a     = a;
         _c     = c;
         _bigA  = Math.Max(0.0, bigA);
         _alpha = alpha;
         _gamma = gamma;
+        _randomSeed = randomSeed;
     }
 
     /// <inheritdoc/>
@@ -113,7 +117,7 @@ public void Run(Func<double[], double> fitnessEvaluator,
             ? v => -fitnessEvaluator(v)
             : fitnessEvaluator;
 
-        var rng   = new Random(42);
+        var rng   = new Random(_randomSeed);
         var theta = Clamp((double[])BestParameters.Clone());
 
         // Evaluate starting point.
diff --git a/src/XTMF2/Bus/Optimization/IEstimationAlgorithm.cs b/src/XTMF2/Bus/Optimization/IEstimationAlgorithm.cs
index 7c78b832..14b4ec3f 100644
--- a/src/XTMF2/Bus/Optimization/IEstimationAlgorithm.cs
+++ b/src/XTMF2/Bus/Optimization/IEstimationAlgorithm.cs
@@ -18,6 +18,7 @@ You should have received a copy of the GNU General Public License
 */
 
 using System;
+using System.Collections.Generic;
 
 namespace XTMF2.Bus.Optimization;
 
@@ -77,6 +78,27 @@ void Run(Func<double[], double> fitnessEvaluator,
              Action<int, double>? progressCallback = null,
              Func<bool>? shouldCancel = null);
 
+    /// <summary>
+    /// Execute the search while allowing independent candidate evaluations to be submitted as
+    /// a batch. The default implementation preserves the existing sequential behaviour and
+    /// lets algorithms adopt parallel evaluation incrementally.
+    /// </summary>
+    /// <param name="fitnessEvaluator">Fallback evaluator for a single candidate.</param>
+    /// <param name="batchFitnessEvaluator">
+    /// Evaluates the supplied candidates and returns one fitness value per candidate, in the
+    /// same order. Implementations may dispatch these evaluations to multiple run servers.
+    /// </param>
+    /// <param name="progressCallback">Optional progress callback.</param>
+    /// <param name="shouldCancel">Optional cancellation predicate.</param>
+    void RunBatch(
+        Func<double[], double> fitnessEvaluator,
+        Func<IReadOnlyList<double[]>, IReadOnlyList<double>> batchFitnessEvaluator,
+        Action<int, double>? progressCallback = null,
+        Func<bool>? shouldCancel = null)
+    {
+        Run(fitnessEvaluator, progressCallback, shouldCancel);
+    }
+
     /// <summary>The parameter vector that produced the lowest fitness seen so far.</summary>
     double[] BestParameters { get; }
 
diff --git a/src/XTMF2/Bus/Optimization/RemoteSharedEstimationCoordinatorSession.cs b/src/XTMF2/Bus/Optimization/RemoteSharedEstimationCoordinatorSession.cs
new file mode 100644
index 00000000..687b92fa
--- /dev/null
+++ b/src/XTMF2/Bus/Optimization/RemoteSharedEstimationCoordinatorSession.cs
@@ -0,0 +1,54 @@
+using System;
+using XTMF2.Bus;
+
+namespace XTMF2.Bus.Optimization;
+
+/// <summary>
+/// Adapts one RunServer connection to the process-level remote estimation registry.
+/// </summary>
+public sealed class RemoteSharedEstimationCoordinatorSession : IDisposable
+{
+    private readonly RunServerBus _bus;
+    private readonly RemoteSharedEstimationRegistry _registry;
+
+    public RemoteSharedEstimationCoordinatorSession(RunServerBus bus, RemoteSharedEstimationRegistry registry)
+    {
+        _bus = bus ?? throw new ArgumentNullException(nameof(bus));
+        _registry = registry ?? throw new ArgumentNullException(nameof(registry));
+        _bus.SharedEstimationCoordinatorRequested += OnCoordinatorRequested;
+        _bus.SharedEstimationCancellationRequested += OnCancellationRequested;
+        _bus.SharedEstimationJobsQueryRequested += OnJobsQueryRequested;
+        _bus.SharedEstimationCoordinatorWorkerRequested += OnCoordinatorWorkerRequested;
+    }
+
+    private void OnCoordinatorRequested(object _, SharedEstimationCoordinatorRequest request)
+        => _registry.Start(_bus, request);
+
+    private void OnCancellationRequested(object _, string runId, string? reason)
+        => _registry.Cancel(runId, reason);
+
+    private void OnJobsQueryRequested(object _)
+        => _registry.SendSnapshots(_bus);
+
+    private void OnCoordinatorWorkerRequested(object _, string runId, SharedEstimationWorkerEndpoint worker, bool remove)
+    {
+        var acknowledgement = _registry.ChangeWorker(
+            runId, worker, add: !remove);
+        try
+        {
+            _bus.SendSharedEstimationWorkerControlAcknowledgement(acknowledgement);
+        }
+        catch (System.IO.IOException)
+        {
+        }
+    }
+
+    public void Dispose()
+    {
+        _registry.Detach(_bus);
+        _bus.SharedEstimationCoordinatorRequested -= OnCoordinatorRequested;
+        _bus.SharedEstimationCancellationRequested -= OnCancellationRequested;
+        _bus.SharedEstimationJobsQueryRequested -= OnJobsQueryRequested;
+        _bus.SharedEstimationCoordinatorWorkerRequested -= OnCoordinatorWorkerRequested;
+    }
+}
diff --git a/src/XTMF2/Bus/Optimization/RemoteSharedEstimationRegistry.cs b/src/XTMF2/Bus/Optimization/RemoteSharedEstimationRegistry.cs
new file mode 100644
index 00000000..657c9b2a
--- /dev/null
+++ b/src/XTMF2/Bus/Optimization/RemoteSharedEstimationRegistry.cs
@@ -0,0 +1,503 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using XTMF2.Bus;
+
+namespace XTMF2.Bus.Optimization;
+
+/// <summary>
+/// Owns remote shared-estimation jobs for the lifetime of a RunServer process.
+/// Connection sessions attach only as observers and never own job lifetime.
+/// </summary>
+public sealed class RemoteSharedEstimationRegistry : IDisposable
+{
+    private readonly object _sync = new();
+    private readonly Dictionary<string, RemoteJob> _jobs = new(StringComparer.Ordinal);
+    private bool _disposed;
+    private bool _acceptingWork = true;
+
+    public bool IsIdle
+    {
+        get
+        {
+            lock (_sync)
+                return _jobs.Values.All(job => job.GetSnapshot().State != SharedEstimationJobState.Running);
+        }
+    }
+
+    public void BeginDrain()
+    {
+        lock (_sync)
+            _acceptingWork = false;
+    }
+
+    public void EndDrain()
+    {
+        lock (_sync)
+            _acceptingWork = true;
+    }
+
+    public void Start(RunServerBus observer, SharedEstimationCoordinatorRequest request)
+    {
+        ArgumentNullException.ThrowIfNull(observer);
+        ArgumentNullException.ThrowIfNull(request);
+
+        RemoteJob job;
+        lock (_sync)
+        {
+            if (_disposed || !_acceptingWork || _jobs.ContainsKey(request.Run.RunId))
+                return;
+
+            job = new RemoteJob(this, observer, request);
+            _jobs.Add(request.Run.RunId, job);
+            job.Start();
+        }
+    }
+
+    public void Cancel(string runId, string? reason)
+    {
+        lock (_sync)
+        {
+            if (_jobs.TryGetValue(runId, out var job))
+                job.Cancel(reason ?? "Cancelled by host.");
+        }
+    }
+
+    public SharedEstimationWorkerControlAcknowledgement ChangeWorker(
+        string runId, SharedEstimationWorkerEndpoint worker, bool add)
+    {
+        lock (_sync)
+        {
+            if (!_jobs.TryGetValue(runId, out var job))
+                return new(runId, worker.WorkerId, add, false, "The remote estimation job was not found.", 0);
+            return job.ChangeWorker(worker, add);
+        }
+    }
+
+    public void Detach(RunServerBus observer)
+    {
+        lock (_sync)
+        {
+            foreach (var job in _jobs.Values)
+                job.Detach(observer);
+        }
+    }
+
+    public void SendSnapshots(RunServerBus observer)
+    {
+        SharedEstimationJobSnapshot[] snapshots;
+        lock (_sync)
+        {
+            snapshots = _jobs.Values.Select(job =>
+            {
+                job.Attach(observer);
+                return job.GetSnapshot();
+            }).ToArray();
+        }
+        observer.SendSharedEstimationJobSnapshots(snapshots);
+    }
+
+    public IReadOnlyList<RunServerActivity> GetActiveActivities()
+    {
+        lock (_sync)
+        {
+            return _jobs.Values
+                .Select(job => job.GetSnapshot())
+                .Where(snapshot => snapshot.State == SharedEstimationJobState.Running)
+                .Select(snapshot => new RunServerActivity(snapshot.RunId,
+                    string.IsNullOrWhiteSpace(snapshot.RunName) ? "Shared estimation" : snapshot.RunName,
+                    "Shared estimation coordinator", RunServerActivityState.Running,
+                    snapshot.Progress is { } progress
+                        ? $"Iteration {progress.Iteration}; {progress.EvaluationsCompleted} evaluations completed, {progress.EvaluationsPending} pending."
+                        : "Preparing shared estimation.",
+                    Iteration: snapshot.Progress?.Iteration ?? 0,
+                    Fitness: snapshot.Progress?.BestFitness ?? double.NaN,
+                    ActiveWorkers: snapshot.ActiveWorkerIds?.Count ?? 0,
+                    EvaluationsCompleted: snapshot.Progress?.EvaluationsCompleted ?? 0,
+                    EvaluationsPending: snapshot.Progress?.EvaluationsPending ?? 0))
+                .ToArray();
+        }
+    }
+
+    public void Dispose()
+    {
+        RemoteJob[] jobs;
+        lock (_sync)
+        {
+            if (_disposed)
+                return;
+            _disposed = true;
+            jobs = _jobs.Values.ToArray();
+        }
+
+        foreach (var job in jobs)
+            job.Cancel("RunServer is shutting down.");
+    }
+
+    private void Complete(RemoteJob job)
+    {
+        lock (_sync)
+        {
+            if (_jobs.TryGetValue(job.RunId, out var current) && ReferenceEquals(current, job))
+                job.MarkCompleted();
+        }
+    }
+
+    private sealed class RemoteJob
+    {
+        private readonly RemoteSharedEstimationRegistry _registry;
+        private readonly SharedEstimationCoordinatorRequest _request;
+        private readonly IReadOnlyList<string> _extraDlls;
+        private readonly object _sync = new();
+        private readonly CancellationTokenSource _cancellation = new();
+        private readonly Dictionary<string, List<string>> _workerSlotsByEndpoint = new(StringComparer.Ordinal);
+        private RunServerBus? _observer;
+        private SharedEstimationWorkerPool? _pool;
+        private Task? _task;
+        private bool _completed;
+        private SharedEstimationProgress? _progress;
+        private SharedEstimationCompletion? _completion;
+
+        public RemoteJob(RemoteSharedEstimationRegistry registry,
+            RunServerBus observer, SharedEstimationCoordinatorRequest request)
+        {
+            _registry = registry;
+            _observer = observer;
+            _extraDlls = observer.ExtraDlls.ToArray();
+            _request = request;
+        }
+
+        public string RunId => _request.Run.RunId;
+
+        public void Start()
+        {
+            _task = Task.Run(Execute, CancellationToken.None);
+        }
+
+        public void Detach(RunServerBus observer)
+        {
+            lock (_sync)
+            {
+                if (ReferenceEquals(_observer, observer))
+                    _observer = null;
+            }
+        }
+
+        public void Attach(RunServerBus observer)
+        {
+            lock (_sync)
+                _observer = observer;
+        }
+
+        public SharedEstimationJobSnapshot GetSnapshot()
+        {
+            lock (_sync)
+            {
+                var registeredWorkerIds = _pool?.WorkerIds.ToHashSet(StringComparer.Ordinal)
+                    ?? new HashSet<string>(StringComparer.Ordinal);
+                var readyWorkerIds = _pool?.Coordinator.ReadyWorkerIds
+                    .Where(registeredWorkerIds.Contains)
+                    .ToArray() ?? Array.Empty<string>();
+                return new SharedEstimationJobSnapshot(RunId,
+                    _completed ? SharedEstimationJobState.Completed : SharedEstimationJobState.Running,
+                    _progress, _completion, readyWorkerIds,
+                    Path.GetFileName(_request.Run.WorkingDirectory.TrimEnd(Path.DirectorySeparatorChar,
+                        Path.AltDirectorySeparatorChar)),
+                    _request.Run.WorkingDirectory,
+                    Convert.ToHexString(SHA256.HashData(_request.Run.ModelSystem)),
+                    _request.Parameters?.ToArray(), _request.Run.ProjectId, _request.Run.ModelSystemId,
+                    _request.Run.OwnerUserId,
+                    GetConfiguredWorkerCounts());
+            }
+        }
+
+        private IReadOnlyDictionary<string, int> GetConfiguredWorkerCounts()
+        {
+            var counts = _request.Workers.ToDictionary(worker => worker.WorkerId,
+                worker => worker.ConcurrentRuns, StringComparer.Ordinal);
+            if (_request.UseCoordinatorAsWorker)
+                counts["coordinator"] = _request.CoordinatorConcurrentRuns;
+            return counts;
+        }
+
+        public SharedEstimationWorkerControlAcknowledgement ChangeWorker(
+            SharedEstimationWorkerEndpoint worker, bool add)
+        {
+            lock (_sync)
+            {
+                if (_completed || _pool is null)
+                    return new(RunId, worker.WorkerId, add, false, "The remote estimation job is no longer active.", 0);
+                var activeWorkerIds = _pool.WorkerIds.ToHashSet(StringComparer.Ordinal);
+                var hasExistingSlots = _workerSlotsByEndpoint.TryGetValue(worker.WorkerId, out var existingSlots);
+                if (add && hasExistingSlots && existingSlots!.Any(activeWorkerIds.Contains))
+                    return new(RunId, worker.WorkerId, true, false, "The worker is already active.", _pool.WorkerCount);
+                if (!add && (!hasExistingSlots || !existingSlots!.Any(activeWorkerIds.Contains)))
+                    return new(RunId, worker.WorkerId, false, false, "The worker is not active.", _pool.WorkerCount);
+                if (!add && _pool.WorkerCount - existingSlots!.Count(activeWorkerIds.Contains) < 1)
+                    return new(RunId, worker.WorkerId, false, false, "At least one worker must remain active.", _pool.WorkerCount);
+
+                bool succeeded;
+                string? error;
+                if (add)
+                {
+                    succeeded = AddWorkerSlots(_pool, worker, out error);
+                }
+                else
+                {
+                    succeeded = RemoveWorkerSlots(_pool, worker.WorkerId, out error);
+                }
+                return new(RunId, worker.WorkerId, add, succeeded,
+                    succeeded ? null : error, _pool.WorkerCount);
+            }
+        }
+
+        public void Cancel(string reason)
+        {
+            lock (_sync)
+            {
+                if (_completed)
+                    return;
+                _cancellation.Cancel();
+                _pool?.CancelRun(reason);
+            }
+        }
+
+        public void MarkCompleted()
+        {
+            lock (_sync)
+            {
+                _completed = true;
+                _pool = null;
+                _cancellation.Dispose();
+            }
+        }
+
+        private void Execute()
+        {
+            SharedEstimationCompletion completion;
+            SharedEstimationWorkerPool? pool = null;
+            try
+            {
+                ReportStatus("Coordinator is preparing the estimation.");
+                if (_request.Workers.Count == 0)
+                {
+                    if (!_request.UseCoordinatorAsWorker)
+                        throw new InvalidOperationException("A remote estimation coordinator requires at least one worker.");
+                }
+                if (_request.LowerBounds.Count != _request.UpperBounds.Count ||
+                    _request.LowerBounds.Count != _request.InitialValues.Count)
+                    throw new InvalidOperationException("The remote estimation parameter bounds are inconsistent.");
+
+                var config = EstimationAlgorithmConfig.Create(_request.AlgorithmId)
+                    ?? throw new InvalidOperationException($"Unknown estimation algorithm '{_request.AlgorithmId}'.");
+                var configError = config.ApplyParameters(_request.AlgorithmParameters);
+                if (configError is not null)
+                    throw new InvalidOperationException(configError);
+
+                pool = new SharedEstimationWorkerPool();
+                pool.WorkerPreparationFailed += OnWorkerPreparationFailed;
+                lock (_sync)
+                    _pool = pool;
+                if (_request.UseCoordinatorAsWorker)
+                {
+                    if (_request.CoordinatorConcurrentRuns < 1 ||
+                        _request.CoordinatorConcurrentRuns > SharedEstimationWorkerEndpoint.MaximumConcurrentRuns)
+                        throw new InvalidOperationException("The coordinator concurrent-run count is outside the supported range.");
+                    for (var slotIndex = 0; slotIndex < _request.CoordinatorConcurrentRuns; slotIndex++)
+                    {
+                        var workerId = slotIndex == 0 ? "coordinator" : $"coordinator#run-{slotIndex + 1}";
+                        if (!SharedEstimationLocalWorker.TryCreate(workerId,
+                            _request.Run, _extraDlls, out var localWorker, out var localWorkerError))
+                            throw new InvalidOperationException(localWorkerError ?? "Unable to prepare the coordinator worker.");
+                        if (!pool.Coordinator.AddWorker(localWorker!, out var addLocalError))
+                        {
+                            localWorker!.Dispose();
+                            throw new InvalidOperationException(addLocalError ?? "Unable to add the coordinator worker.");
+                        }
+                    }
+                    ReportStatus($"Coordinator is participating with {_request.CoordinatorConcurrentRuns} worker run(s).");
+                }
+                foreach (var worker in _request.Workers)
+                {
+                    if (!AddWorkerSlots(pool, worker, out var workerError))
+                    {
+                        ReportStatus($"Unable to connect to worker '{worker.EndpointId}': " +
+                            (workerError ?? "connection failed; estimation will continue without it."));
+                        continue;
+                    }
+                    ReportStatus($"Connected to worker '{worker.EndpointId}'.");
+                }
+
+                var overrides = _request.Workers
+                    .SelectMany(worker => worker.CreateWorkerSlots())
+                    .Where(worker => worker.BasicParameterOverrides is { Count: > 0 })
+                    .ToDictionary(worker => worker.WorkerId,
+                        worker => worker.BasicParameterOverrides!, StringComparer.Ordinal);
+                if (!pool.StartRun(_request.Run, out var startError, overrides))
+                    throw new InvalidOperationException(startError ?? "Unable to start shared estimation workers.");
+                ReportStatus($"Estimation started with {pool.WorkerCount} worker(s).");
+
+                var algorithm = config.CreateAlgorithm(_request.LowerBounds.Count,
+                    _request.LowerBounds.ToArray(), _request.UpperBounds.ToArray(), _request.InitialValues.ToArray(),
+                    _request.IsMaximize);
+                var runner = new SharedEstimationCoordinatorRun(
+                    _request.Run.RunId, algorithm, pool.Coordinator, _request.IsMaximize,
+                    Path.Combine(_request.Run.WorkingDirectory, "estimation_report.csv"),
+                    (_request.Parameters ?? Array.Empty<SharedEstimationParameterMetadata>())
+                        .Select(parameter => parameter.Name).ToArray());
+                completion = runner.Execute(
+                    progress: progress =>
+                    {
+                        try
+                        {
+                            RunServerBus? observer;
+                            lock (_sync)
+                            {
+                                _progress = progress;
+                                observer = _observer;
+                            }
+                            observer?.SendSharedEstimationProgress(progress);
+                        }
+                        catch (IOException) { }
+                        catch (ObjectDisposedException) { }
+                    },
+                    cancellationToken: _cancellation.Token);
+            }
+            catch (Exception exception)
+            {
+                completion = new SharedEstimationCompletion(_request.Run.RunId, false, double.MaxValue,
+                    Array.Empty<double>(), 0, 0, exception.Message);
+            }
+            finally
+            {
+                if (pool is not null)
+                    pool.WorkerPreparationFailed -= OnWorkerPreparationFailed;
+                pool?.Dispose();
+                lock (_sync)
+                    _pool = null;
+            }
+
+            PersistCompletion(_request.Run, completion);
+            try
+            {
+                RunServerBus? observer;
+                lock (_sync)
+                {
+                    _completion = completion;
+                    observer = _observer;
+                }
+                ReportStatus(completion.Succeeded
+                    ? $"Estimation completed after {completion.TotalEvaluations} fitness test(s)."
+                    : $"Estimation failed: {completion.FailureReason ?? "Unknown error."}");
+                observer?.SendSharedEstimationCompletion(completion);
+            }
+            catch (IOException) { }
+            catch (ObjectDisposedException) { }
+
+            _registry.Complete(this);
+        }
+
+        private void ReportStatus(string message)
+        {
+            RunServerBus? observer;
+            lock (_sync)
+                observer = _observer;
+            try
+            {
+                observer?.SendSharedEstimationStatus(new SharedEstimationStatus(RunId, message));
+            }
+            catch (IOException) { }
+            catch (ObjectDisposedException) { }
+        }
+
+        private void OnWorkerPreparationFailed(string reason)
+        {
+            ReportStatus(reason);
+            Cancel(reason);
+        }
+
+        private bool AddWorkerSlots(SharedEstimationWorkerPool pool,
+            SharedEstimationWorkerEndpoint worker, out string? error)
+        {
+            error = null;
+            if (worker.ConcurrentRuns < 1 ||
+                worker.ConcurrentRuns > SharedEstimationWorkerEndpoint.MaximumConcurrentRuns)
+            {
+                error = $"Concurrent runs must be between 1 and {SharedEstimationWorkerEndpoint.MaximumConcurrentRuns}.";
+                return false;
+            }
+
+            var addedWorkerIds = new List<string>(worker.ConcurrentRuns);
+            foreach (var slot in worker.CreateWorkerSlots())
+            {
+                if (!pool.AddWorker(slot.WorkerId, slot.EndpointId, slot.Address, slot.Port,
+                        slot.Token, slot.CertificateFingerprint, out error))
+                {
+                    foreach (var addedWorkerId in addedWorkerIds)
+                        pool.RemoveWorker(addedWorkerId, out _);
+                    return false;
+                }
+                addedWorkerIds.Add(slot.WorkerId);
+            }
+
+            lock (_sync)
+            {
+                if (_completed || !ReferenceEquals(_pool, pool))
+                {
+                    foreach (var addedWorkerId in addedWorkerIds)
+                        pool.RemoveWorker(addedWorkerId, out _);
+                    error = "The remote estimation job is no longer active.";
+                    return false;
+                }
+                _workerSlotsByEndpoint[worker.WorkerId] = addedWorkerIds;
+            }
+            return true;
+        }
+
+        private bool RemoveWorkerSlots(SharedEstimationWorkerPool pool, string workerId, out string? error)
+        {
+            error = null;
+            if (!_workerSlotsByEndpoint.TryGetValue(workerId, out var workerIds))
+            {
+                error = "The worker is not active.";
+                return false;
+            }
+
+            var succeeded = true;
+            foreach (var slotWorkerId in workerIds.ToArray())
+            {
+                if (pool.RemoveWorker(slotWorkerId, out var removeError))
+                    workerIds.Remove(slotWorkerId);
+                else
+                {
+                    error ??= removeError;
+                    succeeded = false;
+                }
+            }
+            if (workerIds.Count == 0)
+                _workerSlotsByEndpoint.Remove(workerId);
+            return succeeded;
+        }
+
+        private static void PersistCompletion(SharedEstimationRunRequest request,
+            SharedEstimationCompletion completion)
+        {
+            try
+            {
+                Directory.CreateDirectory(request.WorkingDirectory);
+                var target = Path.Combine(request.WorkingDirectory, "estimation-completion.json");
+                var temporary = target + ".tmp";
+                File.WriteAllBytes(temporary, JsonSerializer.SerializeToUtf8Bytes(completion));
+                File.Move(temporary, target, true);
+            }
+            catch
+            {
+            }
+        }
+    }
+}
diff --git a/src/XTMF2/Bus/Optimization/SharedEstimationCoordinator.cs b/src/XTMF2/Bus/Optimization/SharedEstimationCoordinator.cs
new file mode 100644
index 00000000..b84f5d4f
--- /dev/null
+++ b/src/XTMF2/Bus/Optimization/SharedEstimationCoordinator.cs
@@ -0,0 +1,398 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using XTMF2.Bus;
+
+namespace XTMF2.Bus.Optimization;
+
+public sealed class SharedEstimationCoordinator : IDisposable
+{
+    private readonly object _gate = new();
+    private readonly Dictionary<string, WorkerSlot> _workers = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, PendingEvaluation> _pending = new(StringComparer.Ordinal);
+    private readonly List<EvaluationBatch> _batches = [];
+    private string? _lastAssignedWorkerId;
+    private bool _disposed;
+
+    public event Action<string>? WorkerRemoved;
+
+    public int ActiveWorkerCount
+    {
+        get
+        {
+            lock (_gate)
+                return _workers.Values.Count(slot => slot.IsReady);
+        }
+    }
+
+    public IReadOnlyList<string> ReadyWorkerIds
+    {
+        get
+        {
+            lock (_gate)
+                return _workers.Where(pair => pair.Value.IsReady)
+                    .Select(pair => pair.Key)
+                    .ToArray();
+        }
+    }
+
+    public bool AddWorker(ISharedEstimationWorker worker, out string? error, bool isReady = true)
+    {
+        ArgumentNullException.ThrowIfNull(worker);
+        error = null;
+        List<Dispatch> dispatches;
+        List<(EvaluationBatch Batch, SharedEstimationEvaluationResult Result)> completed = [];
+        lock (_gate)
+        {
+            ThrowIfDisposed();
+            if (_workers.ContainsKey(worker.WorkerId))
+            {
+                error = $"A worker with ID '{worker.WorkerId}' is already registered.";
+                return false;
+            }
+
+            var slot = new WorkerSlot(worker, isReady);
+            _workers.Add(worker.WorkerId, slot);
+            worker.ResultReceived += OnWorkerResultReceived;
+            worker.Disconnected += OnWorkerDisconnected;
+            dispatches = BuildDispatchesLocked();
+        }
+
+        SendDispatches(dispatches);
+        return true;
+    }
+
+    public bool SetWorkerReady(string workerId, bool isReady, out string? error)
+    {
+        error = null;
+        List<Dispatch> dispatches;
+        lock (_gate)
+        {
+            ThrowIfDisposed();
+            if (!_workers.TryGetValue(workerId, out var slot))
+            {
+                error = $"Worker '{workerId}' is not registered.";
+                return false;
+            }
+
+            slot.IsReady = isReady;
+            if (!isReady && slot.AssignedCandidateId is { } candidateId)
+            {
+                if (_pending.TryGetValue(candidateId, out var pending))
+                    pending.AssignedWorkerId = null;
+                slot.AssignedCandidateId = null;
+            }
+            dispatches = isReady ? BuildDispatchesLocked() : [];
+        }
+
+        SendDispatches(dispatches);
+        return true;
+    }
+
+    public bool RemoveWorker(string workerId, out string? error)
+    {
+        error = null;
+        WorkerSlot? slot;
+        List<Dispatch> dispatches;
+        lock (_gate)
+        {
+            ThrowIfDisposed();
+            if (!_workers.Remove(workerId, out slot))
+            {
+                error = $"Worker '{workerId}' is not registered.";
+                return false;
+            }
+
+            Unsubscribe(slot);
+            RequeueWorkerJobsLocked(workerId);
+            dispatches = BuildDispatchesLocked();
+        }
+
+        slot.Worker.Dispose();
+        WorkerRemoved?.Invoke(workerId);
+        SendDispatches(dispatches);
+        return true;
+    }
+
+    public Task<IReadOnlyList<SharedEstimationEvaluationResult>> EvaluateAsync(
+        IReadOnlyList<SharedEstimationCandidate> candidates,
+        CancellationToken cancellationToken = default,
+        Action<string, SharedEstimationCandidate, SharedEstimationEvaluationResult>? evaluationCompleted = null)
+    {
+        ArgumentNullException.ThrowIfNull(candidates);
+        if (candidates.Count == 0)
+            return Task.FromResult<IReadOnlyList<SharedEstimationEvaluationResult>>([]);
+        if (cancellationToken.IsCancellationRequested)
+            return Task.FromCanceled<IReadOnlyList<SharedEstimationEvaluationResult>>(cancellationToken);
+
+        var batch = new EvaluationBatch(candidates, evaluationCompleted);
+        List<Dispatch> dispatches;
+        List<(Action<SharedEstimationEvaluationResult>? Callback, SharedEstimationEvaluationResult Result)> completed = [];
+        lock (_gate)
+        {
+            ThrowIfDisposed();
+            foreach (var candidate in candidates)
+            {
+                if (_pending.ContainsKey(candidate.CandidateId))
+                    throw new ArgumentException($"Candidate ID '{candidate.CandidateId}' is already active.", nameof(candidates));
+            }
+
+            _batches.Add(batch);
+            foreach (var candidate in candidates)
+                _pending.Add(candidate.CandidateId, new PendingEvaluation(batch, candidate));
+            dispatches = BuildDispatchesLocked();
+        }
+
+        batch.Cancellation = cancellationToken.Register(() => CancelBatch(batch));
+        SendDispatches(dispatches);
+        return batch.Completion.Task;
+    }
+
+    public void Dispose()
+    {
+        WorkerSlot[] workers;
+        lock (_gate)
+        {
+            if (_disposed)
+                return;
+            _disposed = true;
+            foreach (var batch in _batches)
+            {
+                batch.Cancellation.Dispose();
+                batch.Completion.TrySetCanceled();
+            }
+            _pending.Clear();
+            _batches.Clear();
+            workers = _workers.Values.ToArray();
+            _workers.Clear();
+            foreach (var slot in workers)
+                Unsubscribe(slot);
+        }
+
+        foreach (var slot in workers)
+            slot.Worker.Dispose();
+    }
+
+    private void OnWorkerResultReceived(object? sender, SharedEstimationEvaluationResult result)
+    {
+        if (sender is not ISharedEstimationWorker worker)
+            return;
+
+        List<Dispatch> dispatches;
+        List<(EvaluationBatch Batch, string WorkerId, SharedEstimationCandidate Candidate,
+            SharedEstimationEvaluationResult Result)> completed = [];
+        lock (_gate)
+        {
+            if (_disposed || !_workers.ContainsKey(worker.WorkerId))
+                return;
+
+            if (_workers.TryGetValue(worker.WorkerId, out var assignedSlot)
+                && assignedSlot.AssignedCandidateId == result.CandidateId)
+                assignedSlot.AssignedCandidateId = null;
+
+            if (_pending.TryGetValue(result.CandidateId, out var pending)
+                && pending.AssignedWorkerId == worker.WorkerId)
+            {
+                _pending.Remove(result.CandidateId);
+                pending.Batch.Results[result.CandidateId] = result;
+                pending.Batch.PendingProgressCallbacks++;
+                completed.Add((pending.Batch, worker.WorkerId, pending.Candidate, result));
+            }
+            dispatches = BuildDispatchesLocked();
+        }
+
+        foreach (var item in completed)
+        {
+            try
+            {
+                item.Batch.EvaluationCompleted?.Invoke(item.WorkerId, item.Candidate, item.Result);
+            }
+            catch (Exception)
+            {
+            }
+            finally
+            {
+                lock (_gate)
+                {
+                    item.Batch.PendingProgressCallbacks--;
+                    TryCompleteBatchLocked(item.Batch);
+                }
+            }
+        }
+
+        SendDispatches(dispatches);
+    }
+
+    private void OnWorkerDisconnected(object? sender, EventArgs e)
+    {
+        if (sender is ISharedEstimationWorker worker)
+            RemoveWorkerAfterDisconnect(worker);
+    }
+
+    private void RemoveWorkerAfterDisconnect(ISharedEstimationWorker worker)
+    {
+        WorkerSlot? slot;
+        List<Dispatch> dispatches;
+        lock (_gate)
+        {
+            if (_disposed || !_workers.TryGetValue(worker.WorkerId, out slot)
+                || !ReferenceEquals(slot.Worker, worker))
+            {
+                slot = null;
+                dispatches = [];
+            }
+            else
+            {
+                _workers.Remove(worker.WorkerId);
+                Unsubscribe(slot);
+                RequeueWorkerJobsLocked(worker.WorkerId);
+                dispatches = BuildDispatchesLocked();
+            }
+        }
+
+        if (slot is null)
+        {
+            worker.Dispose();
+            return;
+        }
+
+        slot.Worker.Dispose();
+        WorkerRemoved?.Invoke(worker.WorkerId);
+        SendDispatches(dispatches);
+    }
+
+    private List<Dispatch> BuildDispatchesLocked()
+    {
+        var dispatches = new List<Dispatch>();
+        var workers = _workers.Values.ToArray();
+        if (workers.Length == 0)
+            return dispatches;
+
+        int startIndex = Array.FindIndex(workers,
+            slot => slot.Worker.WorkerId == _lastAssignedWorkerId);
+        startIndex = (startIndex + 1) % workers.Length;
+        var unassigned = _pending.Values.Where(pending => pending.AssignedWorkerId is null).ToArray();
+        int candidateIndex = 0;
+        for (int offset = 0; offset < workers.Length && candidateIndex < unassigned.Length; offset++)
+        {
+            var slot = workers[(startIndex + offset) % workers.Length];
+            if (!slot.IsReady || slot.AssignedCandidateId is not null)
+                continue;
+
+            var pending = unassigned[candidateIndex++];
+            pending.AssignedWorkerId = slot.Worker.WorkerId;
+            slot.AssignedCandidateId = pending.Candidate.CandidateId;
+            _lastAssignedWorkerId = slot.Worker.WorkerId;
+            dispatches.Add(new Dispatch(slot.Worker, pending.Candidate));
+        }
+        return dispatches;
+    }
+
+    private void SendDispatches(IReadOnlyList<Dispatch> dispatches)
+    {
+        foreach (var dispatch in dispatches)
+            _ = Task.Run(() => SendDispatch(dispatch));
+    }
+
+    private void SendDispatch(Dispatch dispatch)
+    {
+        lock (_gate)
+        {
+            if (_disposed
+                || !_workers.TryGetValue(dispatch.Worker.WorkerId, out var slot)
+                || !ReferenceEquals(slot.Worker, dispatch.Worker)
+                || slot.AssignedCandidateId != dispatch.Candidate.CandidateId)
+                return;
+        }
+
+        bool sent;
+        try
+        {
+            sent = dispatch.Worker.SendCandidate(dispatch.Candidate, out _);
+        }
+        catch (Exception exception) when (exception is IOException or ObjectDisposedException or InvalidOperationException)
+        {
+            sent = false;
+        }
+        if (!sent)
+            RemoveWorkerAfterDisconnect(dispatch.Worker);
+    }
+
+    private void RequeueWorkerJobsLocked(string workerId)
+    {
+        foreach (var pending in _pending.Values.ToArray())
+        {
+            if (pending.AssignedWorkerId != workerId)
+                continue;
+
+            pending.AssignedWorkerId = null;
+        }
+    }
+
+    private void CancelBatch(EvaluationBatch batch)
+    {
+        lock (_gate)
+        {
+            if (batch.Completion.Task.IsCompleted)
+                return;
+            foreach (var candidate in batch.Candidates)
+                _pending.Remove(candidate.CandidateId);
+            _batches.Remove(batch);
+            batch.Completion.TrySetCanceled();
+        }
+    }
+
+    private void TryCompleteBatchLocked(EvaluationBatch batch)
+    {
+        if (batch.Results.Count != batch.Candidates.Count || batch.PendingProgressCallbacks != 0)
+            return;
+        _batches.Remove(batch);
+        batch.Cancellation.Dispose();
+        batch.Completion.TrySetResult(batch.Candidates
+            .Select(candidate => batch.Results[candidate.CandidateId])
+            .ToArray());
+    }
+
+    private void Unsubscribe(WorkerSlot slot)
+    {
+        slot.Worker.ResultReceived -= OnWorkerResultReceived;
+        slot.Worker.Disconnected -= OnWorkerDisconnected;
+    }
+
+    private void ThrowIfDisposed()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+    }
+
+    private sealed class WorkerSlot(ISharedEstimationWorker worker, bool isReady)
+    {
+        public ISharedEstimationWorker Worker { get; } = worker;
+        public bool IsReady { get; set; } = isReady;
+        public string? AssignedCandidateId { get; set; }
+    }
+
+    private sealed class PendingEvaluation(EvaluationBatch batch, SharedEstimationCandidate candidate)
+    {
+        public EvaluationBatch Batch { get; } = batch;
+        public SharedEstimationCandidate Candidate { get; } = candidate;
+        public string? AssignedWorkerId { get; set; }
+    }
+
+    private sealed class EvaluationBatch(
+        IReadOnlyList<SharedEstimationCandidate> candidates,
+        Action<string, SharedEstimationCandidate, SharedEstimationEvaluationResult>? evaluationCompleted)
+    {
+        public IReadOnlyList<SharedEstimationCandidate> Candidates { get; } = candidates;
+        public Action<string, SharedEstimationCandidate, SharedEstimationEvaluationResult>? EvaluationCompleted { get; } = evaluationCompleted;
+        public int PendingProgressCallbacks { get; set; }
+        public Dictionary<string, SharedEstimationEvaluationResult> Results { get; } = new(StringComparer.Ordinal);
+        public TaskCompletionSource<IReadOnlyList<SharedEstimationEvaluationResult>> Completion { get; } =
+            new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public CancellationTokenRegistration Cancellation { get; set; }
+    }
+
+    private sealed record Dispatch(ISharedEstimationWorker Worker, SharedEstimationCandidate Candidate);
+}
diff --git a/src/XTMF2/Bus/Optimization/SharedEstimationCoordinatorRun.cs b/src/XTMF2/Bus/Optimization/SharedEstimationCoordinatorRun.cs
new file mode 100644
index 00000000..03a12597
--- /dev/null
+++ b/src/XTMF2/Bus/Optimization/SharedEstimationCoordinatorRun.cs
@@ -0,0 +1,212 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using XTMF2.Bus;
+
+namespace XTMF2.Bus.Optimization;
+
+/// <summary>
+/// Adapts an initialized estimation algorithm to the shared worker coordinator.
+/// </summary>
+public sealed class SharedEstimationCoordinatorRun
+{
+    private readonly SharedEstimationCoordinator _coordinator;
+    private readonly IEstimationAlgorithm _algorithm;
+    private readonly string _runId;
+    private readonly bool _isMaximize;
+    private readonly string? _reportPath;
+    private readonly IReadOnlyList<string> _parameterNames;
+    private readonly object _progressSync = new();
+    private readonly Dictionary<string, int> _evaluationsByWorker = new(StringComparer.Ordinal);
+    private long _nextBatchId;
+    private long _nextCandidateId;
+    private int _evaluationsCompleted;
+    private int _fitnessTestsThisIteration;
+    private int _iterations;
+    private int _currentIteration;
+    private Action<SharedEstimationProgress>? _progressCallback;
+    private double _lastReportedFitness;
+    private double[] _bestObservedParameters = [];
+    private bool _hasObservedFitness;
+    private string? _failureReason;
+    private CancellationToken _cancellationToken;
+
+    public SharedEstimationCoordinatorRun(
+        string runId,
+        IEstimationAlgorithm algorithm,
+        SharedEstimationCoordinator coordinator,
+        bool isMaximize = false,
+        string? reportPath = null,
+        IReadOnlyList<string>? parameterNames = null)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(runId);
+        ArgumentNullException.ThrowIfNull(algorithm);
+        ArgumentNullException.ThrowIfNull(coordinator);
+        _runId = runId;
+        _algorithm = algorithm;
+        _coordinator = coordinator;
+        _isMaximize = isMaximize;
+        _reportPath = reportPath;
+        _parameterNames = parameterNames ?? Array.Empty<string>();
+    }
+
+    public SharedEstimationCompletion Execute(
+        Action<SharedEstimationProgress>? progress = null,
+        Func<bool>? shouldCancel = null,
+        CancellationToken cancellationToken = default)
+    {
+        _cancellationToken = cancellationToken;
+        _fitnessTestsThisIteration = 0;
+        _evaluationsByWorker.Clear();
+        _bestObservedParameters = [];
+        _currentIteration = 1;
+        _lastReportedFitness = _algorithm.BestFitness;
+        if (!double.IsFinite(_lastReportedFitness))
+            _lastReportedFitness = _isMaximize ? double.MinValue : double.MaxValue;
+        _hasObservedFitness = false;
+        _progressCallback = progress;
+        EstimationEvaluationReportWriter? report = null;
+        try
+        {
+            if (_reportPath is not null)
+            {
+                report = new EstimationEvaluationReportWriter(_reportPath, _algorithm.Name, _parameterNames);
+                _reportWriter = report;
+            }
+            _algorithm.RunBatch(
+                fitnessEvaluator: EvaluateSingle,
+                batchFitnessEvaluator: EvaluateBatch,
+                progressCallback: (iteration, bestFitness) =>
+                {
+                    lock (_progressSync)
+                    {
+                        _iterations = Math.Max(_iterations, iteration);
+                        if (double.IsFinite(bestFitness))
+                        {
+                            _lastReportedFitness = bestFitness;
+                            _bestObservedParameters = (double[])_algorithm.BestParameters.Clone();
+                            _hasObservedFitness = true;
+                        }
+                        progress?.Invoke(CreateProgress(iteration));
+                        _fitnessTestsThisIteration = 0;
+                        _currentIteration = iteration + 1;
+                    }
+                },
+                shouldCancel: shouldCancel);
+
+            return new SharedEstimationCompletion(
+                _runId,
+                _failureReason is null,
+                _algorithm.BestFitness,
+                _algorithm.BestParameters,
+                _evaluationsCompleted,
+                _iterations,
+                _failureReason);
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            return new SharedEstimationCompletion(
+                _runId,
+                false,
+                _algorithm.BestFitness,
+                _algorithm.BestParameters,
+                _evaluationsCompleted,
+                _iterations,
+                "Shared estimation was cancelled.");
+        }
+        catch (Exception exception)
+        {
+            _failureReason ??= exception.Message;
+            return new SharedEstimationCompletion(
+                _runId,
+                false,
+                _algorithm.BestFitness,
+                _algorithm.BestParameters,
+                _evaluationsCompleted,
+                _iterations,
+                _failureReason);
+        }
+        finally
+        {
+            _reportWriter = null;
+            report?.Dispose();
+        }
+    }
+
+    private double EvaluateSingle(double[] parameters)
+        => EvaluateBatch([parameters])[0];
+
+    private IReadOnlyList<double> EvaluateBatch(IReadOnlyList<double[]> parameters)
+    {
+        if (parameters.Count == 0)
+            return Array.Empty<double>();
+
+        var batchId = Interlocked.Increment(ref _nextBatchId);
+        var candidates = parameters.Select(values => new SharedEstimationCandidate(
+            _runId,
+            batchId,
+            $"{_runId}:{Interlocked.Increment(ref _nextCandidateId)}",
+            values)).ToArray();
+
+        var results = _coordinator.EvaluateAsync(candidates, _cancellationToken, OnEvaluationCompleted)
+            .GetAwaiter().GetResult();
+        var fitnesses = new double[results.Count];
+        for (int i = 0; i < results.Count; i++)
+        {
+            if (results[i].Error is not null || !double.IsFinite(results[i].Fitness))
+            {
+                _failureReason ??= results[i].Error ?? "A worker returned a non-finite fitness value.";
+                fitnesses[i] = _isMaximize ? double.MinValue : double.MaxValue;
+            }
+            else
+            {
+                fitnesses[i] = results[i].Fitness;
+            }
+        }
+        return fitnesses;
+    }
+
+    private void OnEvaluationCompleted(
+        string workerId, SharedEstimationCandidate candidate, SharedEstimationEvaluationResult result)
+    {
+        lock (_progressSync)
+        {
+            _evaluationsCompleted++;
+            _fitnessTestsThisIteration++;
+            _evaluationsByWorker[workerId] = _evaluationsByWorker.GetValueOrDefault(workerId) + 1;
+            try
+            {
+                _reportWriter?.Write(_currentIteration, candidate.Parameters, result.Fitness);
+            }
+            catch (IOException exception)
+            {
+                _failureReason ??= $"Unable to write the estimation report: {exception.Message}";
+            }
+            if (result.Error is not null || !double.IsFinite(result.Fitness))
+            {
+                _failureReason ??= result.Error ?? "A worker returned a non-finite fitness value.";
+            }
+            else if (!_hasObservedFitness ||
+                     (_isMaximize ? result.Fitness > _lastReportedFitness : result.Fitness < _lastReportedFitness))
+            {
+                _lastReportedFitness = result.Fitness;
+                _bestObservedParameters = candidate.Parameters.ToArray();
+                _hasObservedFitness = true;
+            }
+
+            _progressCallback?.Invoke(CreateProgress(_currentIteration));
+        }
+    }
+
+    private SharedEstimationProgress CreateProgress(int iteration)
+        => new(_runId, iteration, _hasObservedFitness ? _lastReportedFitness : double.NaN,
+            _evaluationsCompleted, 0,
+            _coordinator.ActiveWorkerCount, _fitnessTestsThisIteration,
+            new Dictionary<string, int>(_evaluationsByWorker),
+            (double[])_bestObservedParameters.Clone(),
+            _coordinator.ReadyWorkerIds);
+
+    private EstimationEvaluationReportWriter? _reportWriter;
+}
\ No newline at end of file
diff --git a/src/XTMF2/Bus/Optimization/SharedEstimationLocalWorker.cs b/src/XTMF2/Bus/Optimization/SharedEstimationLocalWorker.cs
new file mode 100644
index 00000000..dae280d3
--- /dev/null
+++ b/src/XTMF2/Bus/Optimization/SharedEstimationLocalWorker.cs
@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using XTMF2.Bus;
+
+namespace XTMF2.Bus.Optimization;
+
+/// <summary>Evaluates shared-estimation candidates in a dedicated Run process.</summary>
+public sealed class SharedEstimationLocalWorker : ISharedEstimationWorker
+{
+    private readonly SharedEstimationWorkerProcess _workerProcess;
+    private bool _disposed;
+
+    private SharedEstimationLocalWorker(string workerId, SharedEstimationWorkerProcess workerProcess)
+    {
+        WorkerId = workerId;
+        _workerProcess = workerProcess;
+    }
+
+    public string WorkerId { get; }
+
+    public event EventHandler<SharedEstimationEvaluationResult>? ResultReceived;
+
+    public event EventHandler? Disconnected
+    {
+        add { }
+        remove { }
+    }
+
+    public static bool TryCreate(
+        string workerId,
+        XTMFRuntime runtime,
+        SharedEstimationRunRequest request,
+        [NotNullWhen(true)] out SharedEstimationLocalWorker? worker,
+        [NotNullWhen(false)] out string? error)
+    {
+        ArgumentNullException.ThrowIfNull(runtime);
+        var pathComparison = OperatingSystem.IsWindows()
+            ? StringComparison.OrdinalIgnoreCase
+            : StringComparison.Ordinal;
+        var coreAssemblyPath = Path.GetFullPath(typeof(RunServerBus).Assembly.Location);
+        var extraDlls = runtime.SystemConfiguration.Modules.LoadedModuleTypes
+            .Select(moduleType => moduleType.Assembly)
+            .Where(assembly => !assembly.IsDynamic)
+            .Select(assembly => assembly.Location)
+            .Where(path => !string.IsNullOrWhiteSpace(path)
+                && !string.Equals(Path.GetFullPath(path), coreAssemblyPath, pathComparison))
+            .Distinct(pathComparison == StringComparison.OrdinalIgnoreCase
+                ? StringComparer.OrdinalIgnoreCase
+                : StringComparer.Ordinal)
+            .ToArray();
+        return TryCreate(workerId, request, extraDlls, out worker, out error);
+    }
+
+    public static bool TryCreate(
+        string workerId,
+        SharedEstimationRunRequest request,
+        IReadOnlyList<string> extraDlls,
+        [NotNullWhen(true)] out SharedEstimationLocalWorker? worker,
+        [NotNullWhen(false)] out string? error)
+    {
+        worker = null;
+        if (string.IsNullOrWhiteSpace(workerId))
+        {
+            error = "A coordinator worker ID is required.";
+            return false;
+        }
+        if (!SharedEstimationWorkerProcess.TryStart(request, extraDlls, out var workerProcess, out error))
+        {
+            error ??= "Unable to start the coordinator estimation worker process.";
+            return false;
+        }
+
+        worker = new SharedEstimationLocalWorker(workerId, workerProcess!);
+        error = null;
+        return true;
+    }
+
+    public bool SendCandidate(SharedEstimationCandidate candidate, out string? error)
+    {
+        if (_disposed)
+        {
+            error = "The coordinator worker has been disposed.";
+            return false;
+        }
+
+        var result = _workerProcess.Evaluate(candidate);
+        ResultReceived?.Invoke(this, result);
+        error = null;
+        return true;
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+            return;
+        _disposed = true;
+        _workerProcess.Dispose();
+    }
+}
diff --git a/src/XTMF2/Bus/Optimization/SharedEstimationProtocol.cs b/src/XTMF2/Bus/Optimization/SharedEstimationProtocol.cs
new file mode 100644
index 00000000..2b7f5702
--- /dev/null
+++ b/src/XTMF2/Bus/Optimization/SharedEstimationProtocol.cs
@@ -0,0 +1,1166 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using XTMF2.Bus;
+
+namespace XTMF2.Bus.Optimization;
+
+public enum SharedEstimationMessageType
+{
+    StartRun = 0,
+    AddWorker = 1,
+    RemoveWorker = 2,
+    EvaluateCandidate = 3,
+    EvaluationResult = 4,
+    Progress = 5,
+    Complete = 6,
+    Cancel = 7,
+    StartCoordinator = 8,
+    QueryJobs = 9,
+    JobSnapshots = 10,
+    AddCoordinatorWorker = 11,
+    RemoveCoordinatorWorker = 12,
+    WorkerControlAcknowledgement = 13,
+    Status = 14,
+    QueryRemoteRuns = 15,
+    RemoteRunSnapshots = 16,
+    GetRemoteRunArtifacts = 17,
+    RemoteRunArtifacts = 18,
+    AcknowledgeRemoteRun = 19,
+    QueryServerActivity = 20,
+    ServerActivitySnapshots = 21,
+    DeleteRemoteRun = 22,
+    RemoteRunDeleted = 23,
+    WorkerReady = 24
+}
+
+public enum SharedEstimationJobState
+{
+    Running = 0,
+    Completed = 1
+}
+
+public enum RunServerActivityState
+{
+    Running = 0,
+    Queued = 1
+}
+
+public sealed record RunServerActivity(
+    string RunId,
+    string RunName,
+    string Kind,
+    RunServerActivityState State,
+    string Status,
+    int QueuePosition = 0,
+    int Iteration = 0,
+    double Fitness = double.NaN,
+    int ActiveWorkers = 0,
+    int EvaluationsCompleted = 0,
+    int EvaluationsPending = 0);
+
+public sealed record RunServerActivityResponse(string RequestId, IReadOnlyList<RunServerActivity> Activities);
+
+public sealed record RemoteRunDeletionResponse(string RequestId, string RunId, bool Deleted, string? Error)
+{
+    public bool IsDeletedOrNotFound => Deleted ||
+        string.Equals(Error, "The remote run was not found.", StringComparison.Ordinal);
+}
+
+public sealed record SharedEstimationParameterMetadata(int NodeIndex, string Name, double Min, double Max);
+
+public sealed record SharedEstimationJobSnapshot(
+    string RunId,
+    SharedEstimationJobState State,
+    SharedEstimationProgress? Progress,
+    SharedEstimationCompletion? Completion,
+    IReadOnlyList<string>? ActiveWorkerIds = null,
+    string RunName = "",
+    string WorkingDirectory = "",
+    string ModelSystemHash = "",
+    IReadOnlyList<SharedEstimationParameterMetadata>? Parameters = null,
+    Guid? ProjectId = null,
+    Guid? ModelSystemId = null,
+    Guid? OwnerUserId = null,
+    IReadOnlyDictionary<string, int>? ConfiguredWorkerCounts = null);
+
+public sealed record SharedEstimationWorkerControlAcknowledgement(
+    string RunId,
+    string WorkerId,
+    bool Add,
+    bool Succeeded,
+    string? Error,
+    int ActiveWorkerCount);
+
+public sealed record SharedEstimationStatus(string RunId, string Message);
+
+public sealed record SharedEstimationWorkerReady(string RunId, bool Succeeded, string? Error);
+
+public sealed record SharedEstimationRunRequest(
+    string RunId,
+    string WorkingDirectory,
+    string StartToExecute,
+    byte[] ModelSystem,
+    IReadOnlyDictionary<int, string>? BasicParameterOverrides = null,
+    Guid? ProjectId = null,
+    Guid? ModelSystemId = null,
+    Guid? OwnerUserId = null,
+    int WorkerSlotCount = 1);
+
+public sealed record SharedEstimationWorkerRegistration(
+    string RunId,
+    string WorkerId,
+    string EndpointId);
+
+public sealed record SharedEstimationWorkerEndpoint(
+    string WorkerId,
+    string EndpointId,
+    string Address,
+    int Port,
+    string Token,
+    string CertificateFingerprint,
+    IReadOnlyDictionary<int, string>? BasicParameterOverrides = null,
+    int ConcurrentRuns = 1)
+{
+    public const int MaximumConcurrentRuns = 32;
+
+    public IReadOnlyList<SharedEstimationWorkerEndpoint> CreateWorkerSlots()
+    {
+        if (ConcurrentRuns < 1 || ConcurrentRuns > MaximumConcurrentRuns)
+            throw new ArgumentOutOfRangeException(nameof(ConcurrentRuns));
+        return Enumerable.Range(0, ConcurrentRuns)
+            .Select(slotIndex => this with
+            {
+                WorkerId = slotIndex == 0 ? WorkerId : $"{WorkerId}#run-{slotIndex + 1}",
+                ConcurrentRuns = 1
+            })
+            .ToArray();
+    }
+}
+
+public sealed record SharedEstimationCoordinatorRequest(
+    SharedEstimationRunRequest Run,
+    IReadOnlyList<SharedEstimationWorkerEndpoint> Workers,
+    string AlgorithmId,
+    IReadOnlyList<AlgorithmParameterDescriptor> AlgorithmParameters,
+    IReadOnlyList<double> LowerBounds,
+    IReadOnlyList<double> UpperBounds,
+    IReadOnlyList<double> InitialValues,
+    bool IsMaximize,
+    bool UseCoordinatorAsWorker = true,
+    IReadOnlyList<SharedEstimationParameterMetadata>? Parameters = null,
+    int CoordinatorConcurrentRuns = 1);
+
+public sealed record SharedEstimationCandidate(
+    string RunId,
+    long BatchId,
+    string CandidateId,
+    IReadOnlyList<double> Parameters);
+
+public sealed record SharedEstimationEvaluationResult(
+    string RunId,
+    long BatchId,
+    string CandidateId,
+    double Fitness,
+    string? Error,
+    string? ModuleName,
+    Guid? ElementId);
+
+public sealed record SharedEstimationProgress(
+    string RunId,
+    int Iteration,
+    double BestFitness,
+    int EvaluationsCompleted,
+    int EvaluationsPending,
+    int ActiveWorkers,
+    int FitnessTestsThisIteration = 0,
+    IReadOnlyDictionary<string, int>? EvaluationsByWorker = null,
+    IReadOnlyList<double>? BestParameters = null,
+    IReadOnlyList<string>? ActiveWorkerIds = null);
+
+public sealed record SharedEstimationCompletion(
+    string RunId,
+    bool Succeeded,
+    double BestFitness,
+    IReadOnlyList<double> BestParameters,
+    int TotalEvaluations,
+    int Iterations,
+    string? FailureReason);
+
+public static class SharedEstimationProtocol
+{
+    public const int Version = 1;
+    private const int MaxCollectionLength = 1_000_000;
+    private const int MaxServerActivities = 10_000;
+
+    public static void WriteHeader(BinaryWriter writer, SharedEstimationMessageType messageType)
+    {
+        writer.Write(Version);
+        writer.Write((int)messageType);
+    }
+
+    public static void WriteCoordinatorRequest(BinaryWriter writer, SharedEstimationCoordinatorRequest request)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.StartCoordinator);
+        WriteRunRequestPayload(writer, request.Run);
+        WriteCount(writer, request.Workers.Count);
+        foreach (var worker in request.Workers)
+        {
+            WriteRequiredString(writer, worker.WorkerId);
+            WriteRequiredString(writer, worker.EndpointId);
+            WriteRequiredString(writer, worker.Address);
+            writer.Write(worker.Port);
+            WriteRequiredString(writer, worker.Token);
+            WriteRequiredString(writer, worker.CertificateFingerprint);
+            WriteOverrides(writer, worker.BasicParameterOverrides);
+            WriteConcurrentRuns(writer, worker.ConcurrentRuns);
+        }
+        WriteRequiredString(writer, request.AlgorithmId);
+        WriteCount(writer, request.AlgorithmParameters.Count);
+        foreach (var parameter in request.AlgorithmParameters)
+        {
+            WriteRequiredString(writer, parameter.Key);
+            WriteRequiredString(writer, parameter.Label);
+            WriteRequiredString(writer, parameter.Hint);
+            WriteRequiredString(writer, parameter.Value);
+        }
+        WriteDoubles(writer, request.LowerBounds);
+        WriteDoubles(writer, request.UpperBounds);
+        WriteDoubles(writer, request.InitialValues);
+        writer.Write(request.IsMaximize);
+        writer.Write(request.UseCoordinatorAsWorker);
+        WriteConcurrentRuns(writer, request.CoordinatorConcurrentRuns);
+        var parameterMetadata = request.Parameters ?? Array.Empty<SharedEstimationParameterMetadata>();
+        WriteCount(writer, parameterMetadata.Count);
+        foreach (var parameter in parameterMetadata)
+        {
+            if (parameter.NodeIndex < 0)
+                throw new ArgumentOutOfRangeException(nameof(request), "Parameter node indices must be non-negative.");
+            writer.Write(parameter.NodeIndex);
+            WriteRequiredString(writer, parameter.Name);
+            writer.Write(parameter.Min);
+            writer.Write(parameter.Max);
+        }
+    }
+
+    public static SharedEstimationCoordinatorRequest ReadCoordinatorRequest(BinaryReader reader)
+    {
+        var (_, messageType) = ReadHeader(reader);
+        if (messageType != SharedEstimationMessageType.StartCoordinator)
+            throw new InvalidDataException($"Expected {SharedEstimationMessageType.StartCoordinator} message but received {messageType}.");
+        return ReadCoordinatorRequestPayload(reader);
+    }
+
+    internal static SharedEstimationCoordinatorRequest ReadCoordinatorRequestPayload(BinaryReader reader)
+    {
+        var run = new SharedEstimationRunRequest(
+            ReadRequiredString(reader), ReadRequiredString(reader), ReadRequiredString(reader),
+            ReadBytes(reader), ReadOverrides(reader),
+            ReadOptionalGuid(reader), ReadOptionalGuid(reader), ReadOptionalGuid(reader), ReadConcurrentRuns(reader));
+        var workers = new List<SharedEstimationWorkerEndpoint>(ReadCount(reader));
+        for (int i = 0; i < workers.Capacity; i++)
+        {
+            var workerId = ReadRequiredString(reader);
+            var endpointId = ReadRequiredString(reader);
+            var address = ReadRequiredString(reader);
+            var port = reader.ReadInt32();
+            var token = ReadRequiredString(reader);
+            var fingerprint = ReadRequiredString(reader);
+            var overrides = ReadOverrides(reader);
+            workers.Add(new SharedEstimationWorkerEndpoint(
+                workerId, endpointId, address, port, token, fingerprint, overrides, ReadConcurrentRuns(reader)));
+        }
+        var algorithmId = ReadRequiredString(reader);
+        var parameters = new List<AlgorithmParameterDescriptor>(ReadCount(reader));
+        for (int i = 0; i < parameters.Capacity; i++)
+        {
+            parameters.Add(new AlgorithmParameterDescriptor
+            {
+                Key = ReadRequiredString(reader),
+                Label = ReadRequiredString(reader),
+                Hint = ReadRequiredString(reader),
+                Value = ReadRequiredString(reader)
+            });
+        }
+        var lowerBounds = ReadDoubles(reader);
+        var upperBounds = ReadDoubles(reader);
+        var initialValues = ReadDoubles(reader);
+        var isMaximize = reader.ReadBoolean();
+        var useCoordinatorAsWorker = reader.ReadBoolean();
+        var coordinatorConcurrentRuns = ReadConcurrentRuns(reader);
+        var metadataCount = ReadCount(reader);
+        var values = new SharedEstimationParameterMetadata[metadataCount];
+        for (var index = 0; index < metadataCount; index++)
+        {
+            var nodeIndex = reader.ReadInt32();
+            if (nodeIndex < 0)
+                throw new InvalidDataException("Parameter node indices must be non-negative.");
+            values[index] = new SharedEstimationParameterMetadata(nodeIndex, ReadRequiredString(reader),
+                reader.ReadDouble(), reader.ReadDouble());
+        }
+        return new SharedEstimationCoordinatorRequest(run, workers, algorithmId, parameters,
+            lowerBounds, upperBounds, initialValues, isMaximize, useCoordinatorAsWorker, values,
+            coordinatorConcurrentRuns);
+    }
+
+    public static (int Version, SharedEstimationMessageType MessageType) ReadHeader(BinaryReader reader)
+    {
+        int version = reader.ReadInt32();
+        var messageType = (SharedEstimationMessageType)reader.ReadInt32();
+        if (version != Version)
+            throw new InvalidDataException($"Unsupported shared estimation protocol version: {version}.");
+        if (!Enum.IsDefined(messageType))
+            throw new InvalidDataException($"Unknown shared estimation message type: {(int)messageType}.");
+        return (version, messageType);
+    }
+
+    public static void WriteRunRequest(BinaryWriter writer, SharedEstimationRunRequest request)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.StartRun);
+        WriteRequiredString(writer, request.RunId);
+        WriteRequiredString(writer, request.WorkingDirectory);
+        WriteRequiredString(writer, request.StartToExecute);
+        WriteBytes(writer, request.ModelSystem);
+        var overrides = request.BasicParameterOverrides;
+        WriteCount(writer, overrides?.Count ?? 0);
+        if (overrides is not null)
+        {
+            foreach (var pair in overrides)
+            {
+                if (pair.Key < 0)
+                    throw new ArgumentOutOfRangeException(nameof(request), "Override node indices must be non-negative.");
+                writer.Write(pair.Key);
+                WriteRequiredString(writer, pair.Value);
+            }
+        }
+        WriteOptionalGuid(writer, request.ProjectId);
+        WriteOptionalGuid(writer, request.ModelSystemId);
+        WriteOptionalGuid(writer, request.OwnerUserId);
+        WriteConcurrentRuns(writer, request.WorkerSlotCount);
+    }
+
+    private static void WriteRunRequestPayload(BinaryWriter writer, SharedEstimationRunRequest request)
+    {
+        WriteRequiredString(writer, request.RunId);
+        WriteRequiredString(writer, request.WorkingDirectory);
+        WriteRequiredString(writer, request.StartToExecute);
+        WriteBytes(writer, request.ModelSystem);
+        WriteOverrides(writer, request.BasicParameterOverrides);
+        WriteOptionalGuid(writer, request.ProjectId);
+        WriteOptionalGuid(writer, request.ModelSystemId);
+        WriteOptionalGuid(writer, request.OwnerUserId);
+        WriteConcurrentRuns(writer, request.WorkerSlotCount);
+    }
+
+    private static void WriteOverrides(BinaryWriter writer, IReadOnlyDictionary<int, string>? overrides)
+    {
+        WriteCount(writer, overrides?.Count ?? 0);
+        if (overrides is null) return;
+        foreach (var pair in overrides)
+        {
+            writer.Write(pair.Key);
+            WriteRequiredString(writer, pair.Value);
+        }
+    }
+
+    private static void WriteConcurrentRuns(BinaryWriter writer, int concurrentRuns)
+    {
+        if (concurrentRuns < 1 || concurrentRuns > SharedEstimationWorkerEndpoint.MaximumConcurrentRuns)
+            throw new ArgumentOutOfRangeException(nameof(concurrentRuns),
+                $"Concurrent runs must be between 1 and {SharedEstimationWorkerEndpoint.MaximumConcurrentRuns}.");
+        writer.Write(concurrentRuns);
+    }
+
+    private static int ReadConcurrentRuns(BinaryReader reader)
+    {
+        var concurrentRuns = reader.ReadInt32();
+        if (concurrentRuns < 1 || concurrentRuns > SharedEstimationWorkerEndpoint.MaximumConcurrentRuns)
+            throw new InvalidDataException("The RunServer concurrent-run count is outside the supported range.");
+        return concurrentRuns;
+    }
+
+    public static SharedEstimationRunRequest ReadRunRequest(BinaryReader reader)
+    {
+        var (_, messageType) = ReadHeader(reader);
+        if (messageType != SharedEstimationMessageType.StartRun)
+            throw new InvalidDataException($"Expected {SharedEstimationMessageType.StartRun} message but received {messageType}.");
+        return ReadRunRequestPayload(reader);
+    }
+
+    internal static SharedEstimationRunRequest ReadRunRequestPayload(BinaryReader reader)
+    {
+        return new SharedEstimationRunRequest(
+            ReadRequiredString(reader),
+            ReadRequiredString(reader),
+            ReadRequiredString(reader),
+            ReadBytes(reader),
+            ReadOverrides(reader), ReadOptionalGuid(reader), ReadOptionalGuid(reader), ReadOptionalGuid(reader),
+            ReadConcurrentRuns(reader));
+    }
+
+    public static void WriteWorkerRegistration(BinaryWriter writer, SharedEstimationWorkerRegistration registration,
+        bool remove)
+    {
+        WriteHeader(writer, remove
+            ? SharedEstimationMessageType.RemoveWorker
+            : SharedEstimationMessageType.AddWorker);
+        WriteRequiredString(writer, registration.RunId);
+        WriteRequiredString(writer, registration.WorkerId);
+        WriteRequiredString(writer, registration.EndpointId);
+    }
+
+    public static SharedEstimationWorkerRegistration ReadWorkerRegistration(BinaryReader reader, bool remove)
+    {
+        ReadExpectedHeader(reader, remove
+            ? SharedEstimationMessageType.RemoveWorker
+            : SharedEstimationMessageType.AddWorker);
+        return ReadWorkerRegistrationPayload(reader);
+    }
+
+    internal static SharedEstimationWorkerRegistration ReadWorkerRegistrationPayload(BinaryReader reader)
+    {
+        return new SharedEstimationWorkerRegistration(
+            ReadRequiredString(reader),
+            ReadRequiredString(reader),
+            ReadRequiredString(reader));
+    }
+
+    public static void WriteCoordinatorWorkerRequest(BinaryWriter writer, string runId,
+        SharedEstimationWorkerEndpoint worker, bool remove)
+    {
+        WriteHeader(writer, remove
+            ? SharedEstimationMessageType.RemoveCoordinatorWorker
+            : SharedEstimationMessageType.AddCoordinatorWorker);
+        WriteRequiredString(writer, runId);
+        WriteRequiredString(writer, worker.WorkerId);
+        WriteRequiredString(writer, worker.EndpointId);
+        WriteRequiredString(writer, worker.Address);
+        writer.Write(worker.Port);
+        WriteRequiredString(writer, worker.Token);
+        WriteRequiredString(writer, worker.CertificateFingerprint);
+        WriteOverrides(writer, worker.BasicParameterOverrides);
+        WriteConcurrentRuns(writer, worker.ConcurrentRuns);
+    }
+
+    public static (string RunId, SharedEstimationWorkerEndpoint Worker) ReadCoordinatorWorkerRequest(BinaryReader reader, bool remove)
+    {
+        ReadExpectedHeader(reader, remove
+            ? SharedEstimationMessageType.RemoveCoordinatorWorker
+            : SharedEstimationMessageType.AddCoordinatorWorker);
+        return ReadCoordinatorWorkerRequestPayload(reader);
+    }
+
+    internal static (string RunId, SharedEstimationWorkerEndpoint Worker) ReadCoordinatorWorkerRequestPayload(BinaryReader reader)
+        => (ReadRequiredString(reader), new SharedEstimationWorkerEndpoint(ReadRequiredString(reader), ReadRequiredString(reader), ReadRequiredString(reader),
+            reader.ReadInt32(), ReadRequiredString(reader), ReadRequiredString(reader), ReadOverrides(reader), ReadConcurrentRuns(reader)));
+
+    public static void WriteWorkerControlAcknowledgement(BinaryWriter writer,
+        SharedEstimationWorkerControlAcknowledgement acknowledgement)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.WorkerControlAcknowledgement);
+        WriteRequiredString(writer, acknowledgement.RunId);
+        WriteRequiredString(writer, acknowledgement.WorkerId);
+        writer.Write(acknowledgement.Add);
+        writer.Write(acknowledgement.Succeeded);
+        WriteOptionalString(writer, acknowledgement.Error);
+        writer.Write(acknowledgement.ActiveWorkerCount);
+    }
+
+    public static SharedEstimationWorkerControlAcknowledgement ReadWorkerControlAcknowledgement(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.WorkerControlAcknowledgement);
+        return ReadWorkerControlAcknowledgementPayload(reader);
+    }
+
+    internal static SharedEstimationWorkerControlAcknowledgement ReadWorkerControlAcknowledgementPayload(BinaryReader reader)
+        => new(ReadRequiredString(reader), ReadRequiredString(reader), reader.ReadBoolean(), reader.ReadBoolean(),
+            ReadOptionalString(reader), reader.ReadInt32());
+
+    public static void WriteStatus(BinaryWriter writer, SharedEstimationStatus status)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.Status);
+        WriteRequiredString(writer, status.RunId);
+        WriteRequiredString(writer, status.Message);
+    }
+
+    public static SharedEstimationStatus ReadStatus(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.Status);
+        return ReadStatusPayload(reader);
+    }
+
+    internal static SharedEstimationStatus ReadStatusPayload(BinaryReader reader)
+        => new(ReadRequiredString(reader), ReadRequiredString(reader));
+
+    public static void WriteWorkerReady(BinaryWriter writer, SharedEstimationWorkerReady readiness)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.WorkerReady);
+        WriteRequiredString(writer, readiness.RunId);
+        writer.Write(readiness.Succeeded);
+        WriteOptionalString(writer, readiness.Error);
+    }
+
+    public static SharedEstimationWorkerReady ReadWorkerReady(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.WorkerReady);
+        return ReadWorkerReadyPayload(reader);
+    }
+
+    internal static SharedEstimationWorkerReady ReadWorkerReadyPayload(BinaryReader reader)
+        => new(ReadRequiredString(reader), reader.ReadBoolean(), ReadOptionalString(reader));
+
+    public static void WriteCandidate(BinaryWriter writer, SharedEstimationCandidate candidate)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.EvaluateCandidate);
+        WriteRequiredString(writer, candidate.RunId);
+        writer.Write(candidate.BatchId);
+        WriteRequiredString(writer, candidate.CandidateId);
+        WriteDoubles(writer, candidate.Parameters);
+    }
+
+    public static SharedEstimationCandidate ReadCandidate(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.EvaluateCandidate);
+        return ReadCandidatePayload(reader);
+    }
+
+    internal static SharedEstimationCandidate ReadCandidatePayload(BinaryReader reader)
+        => new(ReadRequiredString(reader), reader.ReadInt64(), ReadRequiredString(reader), ReadDoubles(reader));
+
+    private static IReadOnlyDictionary<int, string>? ReadOverrides(BinaryReader reader)
+    {
+        int count = ReadCount(reader);
+        if (count == 0)
+            return null;
+
+        var overrides = new Dictionary<int, string>(count);
+        for (int i = 0; i < count; i++)
+        {
+            int nodeIndex = reader.ReadInt32();
+            if (nodeIndex < 0 || !overrides.TryAdd(nodeIndex, ReadRequiredString(reader)))
+                throw new InvalidDataException("Shared estimation contains an invalid parameter override.");
+        }
+        return overrides;
+    }
+
+    public static void WriteResult(BinaryWriter writer, SharedEstimationEvaluationResult result)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.EvaluationResult);
+        WriteRequiredString(writer, result.RunId);
+        writer.Write(result.BatchId);
+        WriteRequiredString(writer, result.CandidateId);
+        writer.Write(result.Fitness);
+        WriteOptionalString(writer, result.Error);
+        WriteOptionalString(writer, result.ModuleName);
+        writer.Write(result.ElementId?.ToString() ?? string.Empty);
+    }
+
+    public static SharedEstimationEvaluationResult ReadResult(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.EvaluationResult);
+        return ReadResultPayload(reader);
+    }
+
+    internal static SharedEstimationEvaluationResult ReadResultPayload(BinaryReader reader)
+    {
+        var runId = ReadRequiredString(reader);
+        var batchId = reader.ReadInt64();
+        var candidateId = ReadRequiredString(reader);
+        var fitness = reader.ReadDouble();
+        var error = ReadOptionalString(reader);
+        var moduleName = ReadOptionalString(reader);
+        var elementIdText = reader.ReadString();
+        return new SharedEstimationEvaluationResult(runId, batchId, candidateId, fitness, error, moduleName,
+            Guid.TryParse(elementIdText, out var elementId) ? elementId : null);
+    }
+
+    public static void WriteProgress(BinaryWriter writer, SharedEstimationProgress progress)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.Progress);
+        WriteProgressPayload(writer, progress);
+    }
+
+    private static void WriteProgressPayload(BinaryWriter writer, SharedEstimationProgress progress)
+    {
+        WriteRequiredString(writer, progress.RunId);
+        writer.Write(progress.Iteration);
+        writer.Write(progress.BestFitness);
+        writer.Write(progress.EvaluationsCompleted);
+        writer.Write(progress.EvaluationsPending);
+        writer.Write(progress.ActiveWorkers);
+        writer.Write(progress.FitnessTestsThisIteration);
+        var workerCounts = progress.EvaluationsByWorker ?? new Dictionary<string, int>();
+        WriteCount(writer, workerCounts.Count);
+        foreach (var workerCount in workerCounts)
+        {
+            WriteRequiredString(writer, workerCount.Key);
+            writer.Write(workerCount.Value);
+        }
+        WriteDoubles(writer, progress.BestParameters ?? Array.Empty<double>());
+        var activeWorkers = progress.ActiveWorkerIds ?? Array.Empty<string>();
+        WriteCount(writer, activeWorkers.Count);
+        foreach (var workerId in activeWorkers)
+            WriteRequiredString(writer, workerId);
+    }
+
+    public static SharedEstimationProgress ReadProgress(BinaryReader reader)
+    {
+        var (_, messageType) = ReadHeader(reader);
+        if (messageType != SharedEstimationMessageType.Progress)
+            throw new InvalidDataException($"Expected {SharedEstimationMessageType.Progress} message but received {messageType}.");
+        return ReadProgressPayload(reader);
+    }
+
+    internal static SharedEstimationProgress ReadProgressPayload(BinaryReader reader)
+    {
+        var runId = ReadRequiredString(reader);
+        var iteration = reader.ReadInt32();
+        var bestFitness = reader.ReadDouble();
+        var evaluationsCompleted = reader.ReadInt32();
+        var evaluationsPending = reader.ReadInt32();
+        var activeWorkers = reader.ReadInt32();
+        var fitnessTestsThisIteration = reader.ReadInt32();
+        var count = ReadCount(reader);
+        var workerCounts = new Dictionary<string, int>(count, StringComparer.Ordinal);
+        for (int i = 0; i < count; i++)
+            workerCounts.Add(ReadRequiredString(reader), reader.ReadInt32());
+        var bestParameters = ReadDoubles(reader);
+        var activeWorkerIds = new string[ReadCount(reader)];
+        for (var index = 0; index < activeWorkerIds.Length; index++)
+            activeWorkerIds[index] = ReadRequiredString(reader);
+        return new SharedEstimationProgress(runId, iteration, bestFitness, evaluationsCompleted,
+            evaluationsPending, activeWorkers, fitnessTestsThisIteration, workerCounts, bestParameters,
+            activeWorkerIds);
+    }
+
+    public static void WriteCompletion(BinaryWriter writer, SharedEstimationCompletion completion)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.Complete);
+        WriteCompletionPayload(writer, completion);
+    }
+
+    private static void WriteCompletionPayload(BinaryWriter writer, SharedEstimationCompletion completion)
+    {
+        WriteRequiredString(writer, completion.RunId);
+        writer.Write(completion.Succeeded);
+        writer.Write(completion.BestFitness);
+        WriteDoubles(writer, completion.BestParameters);
+        writer.Write(completion.TotalEvaluations);
+        writer.Write(completion.Iterations);
+        WriteOptionalString(writer, completion.FailureReason);
+    }
+
+    public static SharedEstimationCompletion ReadCompletion(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.Complete);
+        return ReadCompletionPayload(reader);
+    }
+
+    internal static SharedEstimationCompletion ReadCompletionPayload(BinaryReader reader)
+    {
+        return new SharedEstimationCompletion(
+            ReadRequiredString(reader),
+            reader.ReadBoolean(),
+            reader.ReadDouble(),
+            ReadDoubles(reader),
+            reader.ReadInt32(),
+            reader.ReadInt32(),
+            ReadOptionalString(reader));
+    }
+
+    public static void WriteCancel(BinaryWriter writer, string runId, string? reason)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.Cancel);
+        WriteRequiredString(writer, runId);
+        WriteOptionalString(writer, reason);
+    }
+
+    public static (string RunId, string? Reason) ReadCancel(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.Cancel);
+        return ReadCancelPayload(reader);
+    }
+
+    internal static (string RunId, string? Reason) ReadCancelPayload(BinaryReader reader)
+    {
+        return (ReadRequiredString(reader), ReadOptionalString(reader));
+    }
+
+    public static void WriteQueryJobs(BinaryWriter writer)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.QueryJobs);
+    }
+
+    public static void ReadQueryJobs(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.QueryJobs);
+    }
+
+    public static void WriteJobSnapshots(BinaryWriter writer, IReadOnlyList<SharedEstimationJobSnapshot> snapshots)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.JobSnapshots);
+        WriteCount(writer, snapshots.Count);
+        foreach (var snapshot in snapshots)
+        {
+            WriteRequiredString(writer, snapshot.RunId);
+            writer.Write((int)snapshot.State);
+            writer.Write(snapshot.Progress is not null);
+            if (snapshot.Progress is not null)
+                WriteProgressPayload(writer, snapshot.Progress);
+            writer.Write(snapshot.Completion is not null);
+            if (snapshot.Completion is not null)
+                WriteCompletionPayload(writer, snapshot.Completion);
+            WriteRequiredString(writer, snapshot.RunName);
+            WriteRequiredString(writer, snapshot.WorkingDirectory);
+            WriteRequiredString(writer, snapshot.ModelSystemHash);
+            var workers = snapshot.ActiveWorkerIds ?? Array.Empty<string>();
+            WriteCount(writer, workers.Count);
+            foreach (var workerId in workers)
+                WriteRequiredString(writer, workerId);
+            var metadata = snapshot.Parameters ?? Array.Empty<SharedEstimationParameterMetadata>();
+            WriteCount(writer, metadata.Count);
+            foreach (var parameter in metadata)
+            {
+                writer.Write(parameter.NodeIndex);
+                WriteRequiredString(writer, parameter.Name);
+                writer.Write(parameter.Min);
+                writer.Write(parameter.Max);
+            }
+            WriteOptionalGuid(writer, snapshot.ProjectId);
+            WriteOptionalGuid(writer, snapshot.ModelSystemId);
+            WriteOptionalGuid(writer, snapshot.OwnerUserId);
+            var configuredWorkerCounts = snapshot.ConfiguredWorkerCounts ??
+                new Dictionary<string, int>();
+            WriteCount(writer, configuredWorkerCounts.Count);
+            foreach (var workerCount in configuredWorkerCounts.OrderBy(pair => pair.Key, StringComparer.Ordinal))
+            {
+                WriteRequiredString(writer, workerCount.Key);
+                writer.Write(workerCount.Value);
+            }
+        }
+    }
+
+    public static IReadOnlyList<SharedEstimationJobSnapshot> ReadJobSnapshots(BinaryReader reader)
+    {
+        var (_, messageType) = ReadHeader(reader);
+        if (messageType != SharedEstimationMessageType.JobSnapshots)
+            throw new InvalidDataException($"Expected {SharedEstimationMessageType.JobSnapshots} message but received {messageType}.");
+        return ReadJobSnapshotsPayload(reader);
+    }
+
+    internal static IReadOnlyList<SharedEstimationJobSnapshot> ReadJobSnapshotsPayload(BinaryReader reader)
+    {
+        var snapshots = new List<SharedEstimationJobSnapshot>(ReadCount(reader));
+        for (int i = 0; i < snapshots.Capacity; i++)
+        {
+            var runId = ReadRequiredString(reader);
+            var state = (SharedEstimationJobState)reader.ReadInt32();
+            if (!Enum.IsDefined(state))
+                throw new InvalidDataException($"Unknown shared estimation job state: {(int)state}.");
+            var progress = reader.ReadBoolean() ? ReadProgressPayload(reader) : null;
+            var completion = reader.ReadBoolean() ? ReadCompletionPayload(reader) : null;
+            var runName = ReadRequiredString(reader);
+            var workingDirectory = ReadRequiredString(reader);
+            var modelSystemHash = ReadRequiredString(reader);
+            var workerIds = new string[ReadCount(reader)];
+            for (var workerIndex = 0; workerIndex < workerIds.Length; workerIndex++)
+                workerIds[workerIndex] = ReadRequiredString(reader);
+            var metadata = new SharedEstimationParameterMetadata[ReadCount(reader)];
+            for (var parameterIndex = 0; parameterIndex < metadata.Length; parameterIndex++)
+            {
+                var nodeIndex = reader.ReadInt32();
+                if (nodeIndex < 0)
+                    throw new InvalidDataException("Parameter node indices must be non-negative.");
+                metadata[parameterIndex] = new SharedEstimationParameterMetadata(nodeIndex,
+                    ReadRequiredString(reader), reader.ReadDouble(), reader.ReadDouble());
+            }
+            var projectId = ReadOptionalGuid(reader);
+            var modelSystemId = ReadOptionalGuid(reader);
+            var ownerUserId = ReadOptionalGuid(reader);
+            var configuredWorkerCounts = new Dictionary<string, int>(StringComparer.Ordinal);
+            var workerCount = ReadCount(reader);
+            for (var workerIndex = 0; workerIndex < workerCount; workerIndex++)
+            {
+                var workerId = ReadRequiredString(reader);
+                var count = reader.ReadInt32();
+                if (count < 1 || count > 32)
+                    throw new InvalidDataException("Configured worker counts must be between 1 and 32.");
+                configuredWorkerCounts.Add(workerId, count);
+            }
+            snapshots.Add(new SharedEstimationJobSnapshot(runId, state, progress, completion,
+                workerIds, runName, workingDirectory, modelSystemHash, metadata, projectId, modelSystemId,
+                ownerUserId, configuredWorkerCounts));
+        }
+        return snapshots;
+    }
+
+    public static void WriteQueryRemoteRuns(BinaryWriter writer)
+        => WriteHeader(writer, SharedEstimationMessageType.QueryRemoteRuns);
+
+    public static void ReadQueryRemoteRuns(BinaryReader reader)
+        => ReadExpectedHeader(reader, SharedEstimationMessageType.QueryRemoteRuns);
+
+    public static void WriteRemoteRunSnapshots(BinaryWriter writer, IReadOnlyList<RemoteRunSnapshot> snapshots)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.RemoteRunSnapshots);
+        WriteCount(writer, snapshots.Count);
+        foreach (var snapshot in snapshots)
+        {
+            WriteRequiredString(writer, snapshot.RunId);
+            WriteRequiredString(writer, snapshot.RunName);
+            writer.Write((int)snapshot.RunMode);
+            WriteRequiredString(writer, snapshot.WorkingDirectory);
+            WriteRequiredString(writer, snapshot.StartToExecute);
+            WriteRequiredString(writer, snapshot.ModelSystemHash);
+            writer.Write((int)snapshot.State);
+            WriteRequiredString(writer, snapshot.Status);
+            writer.Write(snapshot.Iteration);
+            writer.Write(snapshot.Fitness);
+            WriteRemoteRunValues(writer, snapshot.ProgressParameters);
+            writer.Write(snapshot.OptimizationResults is not null);
+            if (snapshot.OptimizationResults is not null)
+                WriteRemoteRunValues(writer, snapshot.OptimizationResults);
+            WriteOptionalString(writer, snapshot.ErrorMessage);
+            WriteOptionalString(writer, snapshot.ErrorStack);
+            writer.Write(snapshot.ArtifactsAvailable);
+            writer.Write(snapshot.UpdatedAt.UtcTicks);
+            WriteOptionalGuid(writer, snapshot.ProjectId);
+            WriteOptionalGuid(writer, snapshot.ModelSystemId);
+            WriteOptionalGuid(writer, snapshot.OwnerUserId);
+        }
+    }
+
+    public static IReadOnlyList<RemoteRunSnapshot> ReadRemoteRunSnapshots(BinaryReader reader)
+    {
+        var (_, messageType) = ReadHeader(reader);
+        if (messageType != SharedEstimationMessageType.RemoteRunSnapshots)
+            throw new InvalidDataException($"Expected {SharedEstimationMessageType.RemoteRunSnapshots} message but received {messageType}.");
+
+        return ReadRemoteRunSnapshotsPayload(reader);
+    }
+
+    internal static IReadOnlyList<RemoteRunSnapshot> ReadRemoteRunSnapshotsPayload(BinaryReader reader)
+    {
+        int count = ReadCount(reader);
+        var snapshots = new List<RemoteRunSnapshot>(count);
+        for (int i = 0; i < count; i++)
+        {
+            var runId = ReadRequiredString(reader);
+            var runName = ReadRequiredString(reader);
+            var runMode = (RunMode)reader.ReadInt32();
+            if (!Enum.IsDefined(runMode))
+                throw new InvalidDataException($"Unknown remote run mode: {(int)runMode}.");
+            var workingDirectory = ReadRequiredString(reader);
+            var startToExecute = ReadRequiredString(reader);
+            var modelSystemHash = ReadRequiredString(reader);
+            var state = (RemoteRunState)reader.ReadInt32();
+            if (!Enum.IsDefined(state))
+                throw new InvalidDataException($"Unknown remote run state: {(int)state}.");
+            var status = ReadRequiredString(reader);
+            var iteration = reader.ReadInt32();
+            if (iteration < 0)
+                throw new InvalidDataException("Remote run iteration cannot be negative.");
+            var fitness = reader.ReadDouble();
+            var progress = ReadRemoteRunValues(reader);
+            var optimization = reader.ReadBoolean() ? ReadRemoteRunValues(reader) : null;
+            var errorMessage = ReadOptionalString(reader);
+            var errorStack = ReadOptionalString(reader);
+            var artifactsAvailable = reader.ReadBoolean();
+            var updatedAt = new DateTimeOffset(reader.ReadInt64(), TimeSpan.Zero);
+            var projectId = ReadOptionalGuid(reader);
+            var modelSystemId = ReadOptionalGuid(reader);
+            var ownerUserId = ReadOptionalGuid(reader);
+            snapshots.Add(new RemoteRunSnapshot(runId, runName, runMode, workingDirectory,
+                startToExecute, modelSystemHash, state, status, iteration, fitness,
+                progress, optimization, errorMessage, errorStack, artifactsAvailable, updatedAt,
+                projectId, modelSystemId, ownerUserId));
+        }
+        return snapshots;
+    }
+
+    public static void WriteGetRemoteRunArtifacts(BinaryWriter writer, string runId)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.GetRemoteRunArtifacts);
+        WriteRequiredString(writer, runId);
+    }
+
+    public static string ReadGetRemoteRunArtifacts(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.GetRemoteRunArtifacts);
+        return ReadGetRemoteRunArtifactsPayload(reader);
+    }
+
+    internal static string ReadGetRemoteRunArtifactsPayload(BinaryReader reader)
+        => ReadRequiredString(reader);
+
+    public static void WriteRemoteRunArtifacts(BinaryWriter writer, string runId, byte[]? archive, string? error = null)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.RemoteRunArtifacts);
+        WriteRequiredString(writer, runId);
+        writer.Write(archive is not null);
+        if (archive is not null)
+            WriteBytes(writer, archive);
+        WriteOptionalString(writer, error);
+    }
+
+    public static RemoteRunArtifactsResponse ReadRemoteRunArtifacts(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.RemoteRunArtifacts);
+        return ReadRemoteRunArtifactsPayload(reader);
+    }
+
+    internal static RemoteRunArtifactsResponse ReadRemoteRunArtifactsPayload(BinaryReader reader)
+    {
+        var runId = ReadRequiredString(reader);
+        var archive = reader.ReadBoolean() ? ReadBytes(reader) : null;
+        return new RemoteRunArtifactsResponse(runId, archive, ReadOptionalString(reader));
+    }
+
+    public static void WriteAcknowledgeRemoteRun(BinaryWriter writer, string runId)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.AcknowledgeRemoteRun);
+        WriteRequiredString(writer, runId);
+    }
+
+    public static string ReadAcknowledgeRemoteRun(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.AcknowledgeRemoteRun);
+        return ReadAcknowledgeRemoteRunPayload(reader);
+    }
+
+    internal static string ReadAcknowledgeRemoteRunPayload(BinaryReader reader)
+        => ReadRequiredString(reader);
+
+    public static void WriteDeleteRemoteRun(BinaryWriter writer, string requestId, string runId)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.DeleteRemoteRun);
+        WriteRequiredString(writer, requestId);
+        WriteRequiredString(writer, runId);
+    }
+
+    public static (string RequestId, string RunId) ReadDeleteRemoteRun(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.DeleteRemoteRun);
+        return ReadDeleteRemoteRunPayload(reader);
+    }
+
+    internal static (string RequestId, string RunId) ReadDeleteRemoteRunPayload(BinaryReader reader)
+        => (ReadRequiredString(reader), ReadRequiredString(reader));
+
+    public static void WriteRemoteRunDeleted(BinaryWriter writer, RemoteRunDeletionResponse response)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.RemoteRunDeleted);
+        WriteRequiredString(writer, response.RequestId);
+        WriteRequiredString(writer, response.RunId);
+        writer.Write(response.Deleted);
+        WriteOptionalString(writer, response.Error);
+    }
+
+    public static RemoteRunDeletionResponse ReadRemoteRunDeleted(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.RemoteRunDeleted);
+        return ReadRemoteRunDeletedPayload(reader);
+    }
+
+    internal static RemoteRunDeletionResponse ReadRemoteRunDeletedPayload(BinaryReader reader)
+        => new(ReadRequiredString(reader), ReadRequiredString(reader), reader.ReadBoolean(), ReadOptionalString(reader));
+
+    public static void WriteQueryServerActivity(BinaryWriter writer, string requestId)
+    {
+        WriteHeader(writer, SharedEstimationMessageType.QueryServerActivity);
+        WriteRequiredString(writer, requestId);
+    }
+
+    public static string ReadQueryServerActivity(BinaryReader reader)
+    {
+        ReadExpectedHeader(reader, SharedEstimationMessageType.QueryServerActivity);
+        return ReadQueryServerActivityPayload(reader);
+    }
+
+    public static string ReadQueryServerActivityPayload(BinaryReader reader)
+        => ReadRequiredString(reader);
+
+    public static void WriteServerActivitySnapshots(BinaryWriter writer, string requestId,
+        IReadOnlyList<RunServerActivity> activities)
+    {
+        if (activities.Count > MaxServerActivities)
+            throw new ArgumentOutOfRangeException(nameof(activities), $"Activity response cannot exceed {MaxServerActivities} entries.");
+
+        WriteHeader(writer, SharedEstimationMessageType.ServerActivitySnapshots);
+        WriteRequiredString(writer, requestId);
+        writer.Write(activities.Count);
+        foreach (var activity in activities)
+        {
+            WriteRequiredString(writer, activity.RunId);
+            WriteRequiredString(writer, activity.RunName);
+            WriteRequiredString(writer, activity.Kind);
+            writer.Write((int)activity.State);
+            WriteOptionalString(writer, activity.Status);
+            writer.Write(activity.QueuePosition);
+            writer.Write(activity.Iteration);
+            writer.Write(activity.Fitness);
+            writer.Write(activity.ActiveWorkers);
+            writer.Write(activity.EvaluationsCompleted);
+            writer.Write(activity.EvaluationsPending);
+        }
+    }
+
+    public static RunServerActivityResponse ReadServerActivitySnapshots(BinaryReader reader)
+    {
+        var (_, messageType) = ReadHeader(reader);
+        if (messageType != SharedEstimationMessageType.ServerActivitySnapshots)
+            throw new InvalidDataException($"Expected {SharedEstimationMessageType.ServerActivitySnapshots} message but received {messageType}.");
+        return ReadServerActivitySnapshotsPayload(reader);
+    }
+
+    internal static RunServerActivityResponse ReadServerActivitySnapshotsPayload(BinaryReader reader)
+    {
+        var requestId = ReadRequiredString(reader);
+        int count = reader.ReadInt32();
+        if (count < 0 || count > MaxServerActivities)
+            throw new InvalidDataException($"Invalid RunServer activity count: {count}.");
+        var activities = new RunServerActivity[count];
+        for (int i = 0; i < count; i++)
+        {
+            var runId = ReadRequiredString(reader);
+            var runName = ReadRequiredString(reader);
+            var kind = ReadRequiredString(reader);
+            var state = (RunServerActivityState)reader.ReadInt32();
+            if (!Enum.IsDefined(state))
+                throw new InvalidDataException($"Unknown RunServer activity state: {(int)state}.");
+            var status = ReadOptionalString(reader) ?? string.Empty;
+            int queuePosition = reader.ReadInt32();
+            int iteration = reader.ReadInt32();
+            double fitness = reader.ReadDouble();
+            int activeWorkers = reader.ReadInt32();
+            int evaluationsCompleted = reader.ReadInt32();
+            int evaluationsPending = reader.ReadInt32();
+            if (queuePosition < 0 || iteration < 0 || activeWorkers < 0 ||
+                evaluationsCompleted < 0 || evaluationsPending < 0)
+                throw new InvalidDataException("RunServer activity counters cannot be negative.");
+            activities[i] = new RunServerActivity(runId, runName, kind, state, status,
+                queuePosition, iteration, fitness, activeWorkers, evaluationsCompleted, evaluationsPending);
+        }
+        return new RunServerActivityResponse(requestId, activities);
+    }
+
+    private static void WriteRemoteRunValues(BinaryWriter writer, IReadOnlyList<RemoteRunParameterValue> values)
+    {
+        WriteCount(writer, values.Count);
+        foreach (var value in values)
+        {
+            if (value.NodeIndex < 0)
+                throw new ArgumentOutOfRangeException(nameof(values), "Remote run parameter indices must be non-negative.");
+            writer.Write(value.NodeIndex);
+            writer.Write(value.Value);
+        }
+    }
+
+    private static IReadOnlyList<RemoteRunParameterValue> ReadRemoteRunValues(BinaryReader reader)
+    {
+        int count = ReadCount(reader);
+        var values = new RemoteRunParameterValue[count];
+        for (int i = 0; i < count; i++)
+        {
+            int nodeIndex = reader.ReadInt32();
+            if (nodeIndex < 0)
+                throw new InvalidDataException("Remote run parameter indices must be non-negative.");
+            values[i] = new RemoteRunParameterValue(nodeIndex, reader.ReadDouble());
+        }
+        return values;
+    }
+
+    private static void ReadExpectedHeader(BinaryReader reader, SharedEstimationMessageType expected)
+    {
+        var (_, actual) = ReadHeader(reader);
+        if (actual != expected)
+            throw new InvalidDataException($"Expected {expected} message but received {actual}.");
+    }
+
+    private static void WriteRequiredString(BinaryWriter writer, string value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+            throw new ArgumentException("Protocol strings must not be empty.", nameof(value));
+        writer.Write(value);
+    }
+
+    private static string ReadRequiredString(BinaryReader reader)
+    {
+        var value = reader.ReadString();
+        if (string.IsNullOrWhiteSpace(value))
+            throw new InvalidDataException("Protocol strings must not be empty.");
+        return value;
+    }
+
+    private static void WriteOptionalString(BinaryWriter writer, string? value)
+        => writer.Write(value ?? string.Empty);
+
+    private static string? ReadOptionalString(BinaryReader reader)
+    {
+        var value = reader.ReadString();
+        return value.Length == 0 ? null : value;
+    }
+
+    private static void WriteOptionalGuid(BinaryWriter writer, Guid? value)
+    {
+        writer.Write(value.HasValue);
+        if (value.HasValue)
+            writer.Write(value.Value.ToByteArray());
+    }
+
+    private static Guid? ReadOptionalGuid(BinaryReader reader)
+    {
+        if (!reader.ReadBoolean())
+            return null;
+        var bytes = reader.ReadBytes(16);
+        return bytes.Length == 16
+            ? new Guid(bytes)
+            : throw new EndOfStreamException("The shared estimation identity was truncated.");
+    }
+
+    private static void WriteBytes(BinaryWriter writer, byte[] bytes)
+    {
+        WriteCount(writer, bytes.Length);
+        writer.Write(bytes);
+    }
+
+    private static byte[] ReadBytes(BinaryReader reader)
+    {
+        int count = ReadCount(reader);
+        return reader.ReadBytes(count) is { Length: var actual } bytes && actual == count
+            ? bytes
+            : throw new EndOfStreamException("The shared estimation payload was truncated.");
+    }
+
+    private static void WriteDoubles(BinaryWriter writer, IReadOnlyList<double> values)
+    {
+        WriteCount(writer, values.Count);
+        for (int i = 0; i < values.Count; i++)
+            writer.Write(values[i]);
+    }
+
+    private static IReadOnlyList<double> ReadDoubles(BinaryReader reader)
+    {
+        int count = ReadCount(reader);
+        var values = new double[count];
+        for (int i = 0; i < count; i++)
+            values[i] = reader.ReadDouble();
+        return values;
+    }
+
+    private static void WriteCount(BinaryWriter writer, int count)
+    {
+        if (count < 0 || count > MaxCollectionLength)
+            throw new ArgumentOutOfRangeException(nameof(count));
+        writer.Write(count);
+    }
+
+    private static int ReadCount(BinaryReader reader)
+    {
+        int count = reader.ReadInt32();
+        if (count < 0 || count > MaxCollectionLength)
+            throw new InvalidDataException($"Invalid shared estimation collection length: {count}.");
+        return count;
+    }
+}
diff --git a/src/XTMF2/Bus/Optimization/SharedEstimationWorker.cs b/src/XTMF2/Bus/Optimization/SharedEstimationWorker.cs
new file mode 100644
index 00000000..88e1af06
--- /dev/null
+++ b/src/XTMF2/Bus/Optimization/SharedEstimationWorker.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using XTMF2.Bus;
+
+namespace XTMF2.Bus.Optimization;
+
+public interface ISharedEstimationWorker : IDisposable
+{
+    string WorkerId { get; }
+
+    event EventHandler<SharedEstimationEvaluationResult>? ResultReceived;
+
+    event EventHandler? Disconnected;
+
+    bool SendCandidate(SharedEstimationCandidate candidate, out string? error);
+}
diff --git a/src/XTMF2/Bus/Optimization/SharedEstimationWorkerConnection.cs b/src/XTMF2/Bus/Optimization/SharedEstimationWorkerConnection.cs
new file mode 100644
index 00000000..88e2c6f3
--- /dev/null
+++ b/src/XTMF2/Bus/Optimization/SharedEstimationWorkerConnection.cs
@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+using XTMF2.Bus;
+using XTMF2.Editing;
+
+namespace XTMF2.Bus.Optimization;
+
+public sealed class SharedEstimationWorkerConnection : ISharedEstimationWorker
+{
+    private bool _disposed;
+    private int _disconnected;
+    private readonly bool _ownsBus;
+
+    private SharedEstimationWorkerConnection(string workerId, string endpointId, HostBus bus, bool ownsBus)
+    {
+        WorkerId = workerId;
+        EndpointId = endpointId;
+        Bus = bus;
+        _ownsBus = ownsBus;
+        Bus.SharedEstimationResultAvailable += OnResultReceived;
+        Bus.SharedEstimationWorkerReadyAvailable += OnWorkerReady;
+        Bus.Disconnected += OnDisconnected;
+    }
+
+    public string WorkerId { get; }
+
+    public string EndpointId { get; }
+
+    public HostBus Bus { get; }
+
+    internal bool IsDisconnected => Volatile.Read(ref _disconnected) != 0;
+
+    public event EventHandler<SharedEstimationEvaluationResult>? ResultReceived;
+
+    public event EventHandler<SharedEstimationWorkerReady>? WorkerReadyReceived;
+
+    public event EventHandler? Disconnected;
+
+    public static bool TryConnect(
+        string workerId,
+        string endpointId,
+        string address,
+        int port,
+        string token,
+        string certificateFingerprint,
+        [NotNullWhen(true)] out SharedEstimationWorkerConnection? connection,
+        [NotNullWhen(false)] out string? error,
+        int timeoutMilliseconds = 5000)
+    {
+        connection = null;
+        if (string.IsNullOrWhiteSpace(workerId))
+        {
+            error = "A worker ID is required.";
+            return false;
+        }
+        if (string.IsNullOrWhiteSpace(endpointId))
+        {
+            error = "A worker endpoint ID is required.";
+            return false;
+        }
+
+        if (!CreateStreams.CreateSecureTcpClient(address, port, token, certificateFingerprint,
+            out var stream, out error, timeoutMilliseconds))
+            return false;
+
+        try
+        {
+            connection = new SharedEstimationWorkerConnection(workerId, endpointId, new HostBus(stream, true), true);
+            return true;
+        }
+        catch (Exception ex) when (ex is IOException or InvalidOperationException)
+        {
+            stream.Dispose();
+            error = ex.Message;
+            return false;
+        }
+    }
+
+    internal static SharedEstimationWorkerConnection Attach(
+        string workerId, string endpointId, HostBus bus)
+        => new(workerId, endpointId, bus, false);
+
+    public void Dispose()
+    {
+        if (_disposed)
+            return;
+        _disposed = true;
+        Bus.SharedEstimationResultAvailable -= OnResultReceived;
+        Bus.SharedEstimationWorkerReadyAvailable -= OnWorkerReady;
+        Bus.Disconnected -= OnDisconnected;
+        if (_ownsBus)
+            Bus.Dispose();
+    }
+
+    public bool SendCandidate(SharedEstimationCandidate candidate, out string? error)
+    {
+        try
+        {
+            var sent = Bus.SendSharedEstimationCandidate(candidate, out CommandError? commandError);
+            error = commandError?.Message;
+            return sent;
+        }
+        catch (Exception exception) when (exception is IOException or ObjectDisposedException or InvalidOperationException)
+        {
+            error = exception.Message;
+            return false;
+        }
+    }
+
+    private void OnResultReceived(object? sender, SharedEstimationEvaluationResult result)
+        => ResultReceived?.Invoke(this, result);
+
+    private void OnWorkerReady(object? sender, SharedEstimationWorkerReady readiness)
+        => WorkerReadyReceived?.Invoke(this, readiness);
+
+    private void OnDisconnected(object? sender, EventArgs e)
+    {
+        Interlocked.Exchange(ref _disconnected, 1);
+        Disconnected?.Invoke(this, e);
+    }
+}
diff --git a/src/XTMF2/Bus/Optimization/SharedEstimationWorkerParticipant.cs b/src/XTMF2/Bus/Optimization/SharedEstimationWorkerParticipant.cs
new file mode 100644
index 00000000..95f7f939
--- /dev/null
+++ b/src/XTMF2/Bus/Optimization/SharedEstimationWorkerParticipant.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using XTMF2.Bus;
+
+namespace XTMF2.Bus.Optimization;
+
+public sealed class SharedEstimationWorkerParticipant
+{
+    private readonly RunContext _context;
+
+    private SharedEstimationWorkerParticipant(RunContext context)
+    {
+        _context = context;
+    }
+
+    public static bool TryCreate(
+        XTMFRuntime runtime,
+        SharedEstimationRunRequest request,
+        [NotNullWhen(true)] out SharedEstimationWorkerParticipant? participant,
+        [NotNullWhen(false)] out RunError? error)
+    {
+        participant = null;
+        if (!RunContext.CreateRunContext(runtime, request.RunId, request.ModelSystem,
+            request.WorkingDirectory, request.StartToExecute, RunMode.Estimation, out var context,
+            request.BasicParameterOverrides))
+        {
+            error = new RunError(RunErrorType.Validation,
+                "Unable to create the shared-estimation run context.", null, string.Empty);
+            return false;
+        }
+
+        if (!context.PrepareSharedEstimationWorker(out error))
+            return false;
+
+        participant = new SharedEstimationWorkerParticipant(context);
+        return true;
+    }
+
+    public SharedEstimationEvaluationResult Evaluate(SharedEstimationCandidate candidate)
+        => _context.EvaluateSharedEstimationCandidate(candidate);
+
+}
diff --git a/src/XTMF2/Bus/Optimization/SharedEstimationWorkerPool.cs b/src/XTMF2/Bus/Optimization/SharedEstimationWorkerPool.cs
new file mode 100644
index 00000000..6ba4fee5
--- /dev/null
+++ b/src/XTMF2/Bus/Optimization/SharedEstimationWorkerPool.cs
@@ -0,0 +1,340 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using XTMF2.Bus;
+
+namespace XTMF2.Bus.Optimization;
+
+/// <summary>
+/// Owns the shared-estimation coordinator and its authenticated worker connections.
+/// </summary>
+public sealed class SharedEstimationWorkerPool : IDisposable
+{
+    private readonly object _sync = new();
+    private readonly Dictionary<string, SharedEstimationWorkerConnection> _connections =
+        new(StringComparer.Ordinal);
+    private readonly HashSet<string> _awaitingReadiness = new(StringComparer.Ordinal);
+    private bool _disposed;
+    private bool _preparationFailureReported;
+    private SharedEstimationRunRequest? _activeRun;
+    private IReadOnlyDictionary<string, IReadOnlyDictionary<int, string>>? _activeOverrides;
+
+    public SharedEstimationWorkerPool()
+    {
+        Coordinator = new SharedEstimationCoordinator();
+        Coordinator.WorkerRemoved += OnWorkerRemoved;
+    }
+
+    public SharedEstimationCoordinator Coordinator { get; }
+
+    public event Action<string>? WorkerPreparationFailed;
+
+    public int WorkerCount => Coordinator.ActiveWorkerCount;
+
+    public IReadOnlyList<string> WorkerIds
+    {
+        get
+        {
+            lock (_sync)
+                return _connections.Keys.ToArray();
+        }
+    }
+
+    public bool AddExistingWorker(
+        string workerId,
+        string endpointId,
+        HostBus bus,
+        out string? error)
+    {
+        ArgumentNullException.ThrowIfNull(bus);
+        var connection = SharedEstimationWorkerConnection.Attach(workerId, endpointId, bus);
+        return RegisterConnection(connection, out error);
+    }
+
+    public bool AddWorker(
+        string workerId,
+        string endpointId,
+        string address,
+        int port,
+        string token,
+        string certificateFingerprint,
+        out string? error,
+        int timeoutMilliseconds = 5000)
+    {
+        lock (_sync)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            if (_connections.ContainsKey(workerId))
+            {
+                error = $"A worker with ID '{workerId}' is already registered.";
+                return false;
+            }
+        }
+
+        if (!SharedEstimationWorkerConnection.TryConnect(
+                workerId, endpointId, address, port, token, certificateFingerprint,
+                out var connection, out error, timeoutMilliseconds))
+            return false;
+
+        return RegisterConnection(connection!, out error);
+    }
+
+    public bool RemoveWorker(string workerId, out string? error)
+    {
+        SharedEstimationWorkerConnection? connection;
+        lock (_sync)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            if (!_connections.Remove(workerId, out connection))
+            {
+                error = $"Worker '{workerId}' is not registered.";
+                return false;
+            }
+            connection.WorkerReadyReceived -= OnWorkerReadyReceived;
+            _awaitingReadiness.Remove(workerId);
+        }
+
+        if (_activeRun is not null)
+            connection.Bus.CancelSharedEstimation(_activeRun.RunId, "Worker removed.", out _);
+        var removed = Coordinator.RemoveWorker(workerId, out error);
+        if (!removed)
+            connection.Dispose();
+        return removed;
+    }
+
+    public bool StartRun(
+        SharedEstimationRunRequest request,
+        out string? error,
+        IReadOnlyDictionary<string, IReadOnlyDictionary<int, string>>? overridesByWorker = null)
+    {
+        List<SharedEstimationWorkerConnection> connections;
+        lock (_sync)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            if (_activeRun is not null)
+            {
+                error = "A shared-estimation run is already active.";
+                return false;
+            }
+            _activeRun = request;
+            _activeOverrides = overridesByWorker;
+            _preparationFailureReported = false;
+            connections = [.. _connections.Values];
+            _awaitingReadiness.Clear();
+            foreach (var connection in connections)
+            {
+                _awaitingReadiness.Add(connection.WorkerId);
+                Coordinator.SetWorkerReady(connection.WorkerId, false, out _);
+            }
+        }
+
+        var failedEndpointIds = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var connection in connections)
+        {
+            bool started;
+            try
+            {
+                started = connection.Bus.StartSharedEstimation(CreateWorkerRequest(connection.WorkerId), out _);
+            }
+            catch (Exception exception) when (exception is IOException or ObjectDisposedException
+                or InvalidOperationException or ArgumentException)
+            {
+                started = false;
+            }
+            if (!started)
+            {
+                failedEndpointIds.Add(connection.EndpointId);
+                lock (_sync)
+                    _awaitingReadiness.Remove(connection.WorkerId);
+                Coordinator.RemoveWorker(connection.WorkerId, out _);
+            }
+        }
+
+        foreach (var endpointId in failedEndpointIds)
+        {
+            foreach (var connection in connections.Where(connection => connection.EndpointId == endpointId))
+            {
+                connection.Bus.CancelSharedEstimation(request.RunId,
+                    "A worker slot on this RunServer failed to start.", out _);
+                Coordinator.RemoveWorker(connection.WorkerId, out _);
+            }
+        }
+
+        error = null;
+        return true;
+    }
+
+    private bool RegisterConnection(SharedEstimationWorkerConnection connection, out string? error)
+    {
+        var registered = false;
+        lock (_sync)
+        {
+            if (_disposed)
+            {
+                error = "The worker pool has been disposed.";
+            }
+            else if (_connections.ContainsKey(connection.WorkerId))
+            {
+                error = $"A worker with ID '{connection.WorkerId}' is already registered.";
+            }
+            else
+            {
+                _connections.Add(connection.WorkerId, connection);
+                connection.WorkerReadyReceived += OnWorkerReadyReceived;
+                if (_activeRun is not null)
+                    _awaitingReadiness.Add(connection.WorkerId);
+                if (!Coordinator.AddWorker(connection, out error, isReady: _activeRun is null))
+                {
+                    _connections.Remove(connection.WorkerId);
+                    _awaitingReadiness.Remove(connection.WorkerId);
+                    connection.WorkerReadyReceived -= OnWorkerReadyReceived;
+                }
+                else if (_activeRun is not null &&
+                         !connection.Bus.StartSharedEstimation(CreateWorkerRequest(connection.WorkerId), out var commandError))
+                {
+                    _awaitingReadiness.Remove(connection.WorkerId);
+                    Coordinator.RemoveWorker(connection.WorkerId, out _);
+                    error = commandError?.Message ?? "Unable to start the active shared-estimation run.";
+                }
+                else if (connection.IsDisconnected || !_connections.ContainsKey(connection.WorkerId))
+                {
+                    Coordinator.RemoveWorker(connection.WorkerId, out _);
+                    error = "The worker disconnected while being added.";
+                }
+                else
+                {
+                    registered = true;
+                    error = null;
+                }
+            }
+        }
+
+        if (!registered)
+            connection.Dispose();
+        return registered;
+    }
+
+    private void OnWorkerReadyReceived(object? sender, SharedEstimationWorkerReady readiness)
+    {
+        if (sender is not SharedEstimationWorkerConnection connection)
+            return;
+
+        bool removeWorker = false;
+        lock (_sync)
+        {
+            if (!_connections.TryGetValue(connection.WorkerId, out var registered)
+                || !ReferenceEquals(registered, connection)
+                || _activeRun?.RunId != readiness.RunId)
+                return;
+            _awaitingReadiness.Remove(connection.WorkerId);
+
+            if (readiness.Succeeded)
+                Coordinator.SetWorkerReady(connection.WorkerId, true, out _);
+            else
+                removeWorker = true;
+        }
+
+        if (removeWorker)
+        {
+            ReportPreparationFailureIfNoWorkers(readiness.Error
+                ?? $"Worker '{connection.WorkerId}' failed to prepare for shared estimation.");
+            Coordinator.RemoveWorker(connection.WorkerId, out _);
+        }
+    }
+
+    private void ReportPreparationFailureIfNoWorkers(string reason)
+    {
+        bool failed;
+        lock (_sync)
+        {
+            failed = _activeRun is not null && !_preparationFailureReported
+                && _awaitingReadiness.Count == 0 && Coordinator.ActiveWorkerCount == 0;
+            if (failed)
+                _preparationFailureReported = true;
+        }
+        if (failed)
+            WorkerPreparationFailed?.Invoke(reason);
+    }
+
+    public void CancelRun(string? reason = null)
+    {
+        SharedEstimationRunRequest? activeRun;
+        SharedEstimationWorkerConnection[] connections;
+        lock (_sync)
+        {
+            if (_disposed)
+                return;
+            activeRun = _activeRun;
+            connections = [.. _connections.Values];
+            _activeRun = null;
+            _activeOverrides = null;
+            _awaitingReadiness.Clear();
+        }
+
+        if (activeRun is null)
+            return;
+        foreach (var connection in connections)
+            connection.Bus.CancelSharedEstimation(activeRun.RunId, reason, out _);
+    }
+
+    public void Dispose()
+    {
+        SharedEstimationRunRequest? activeRun;
+        SharedEstimationWorkerConnection[] connections;
+        lock (_sync)
+        {
+            if (_disposed)
+                return;
+            _disposed = true;
+            activeRun = _activeRun;
+            connections = _connections.Values.ToArray();
+            _activeRun = null;
+            _activeOverrides = null;
+            _awaitingReadiness.Clear();
+            foreach (var connection in _connections.Values)
+                connection.WorkerReadyReceived -= OnWorkerReadyReceived;
+            _connections.Clear();
+        }
+
+        if (activeRun is not null)
+        {
+            foreach (var connection in connections)
+                connection.Bus.CancelSharedEstimation(activeRun.RunId, "Shared estimation worker released.", out _);
+        }
+        Coordinator.Dispose();
+    }
+
+    private void OnWorkerRemoved(string workerId)
+    {
+        lock (_sync)
+        {
+            if (_connections.Remove(workerId, out var connection))
+            {
+                _awaitingReadiness.Remove(workerId);
+                connection.WorkerReadyReceived -= OnWorkerReadyReceived;
+            }
+        }
+        ReportPreparationFailureIfNoWorkers($"Worker '{workerId}' was removed before becoming ready.");
+    }
+
+    private SharedEstimationRunRequest CreateWorkerRequest(string workerId)
+    {
+        lock (_sync)
+        {
+            if (_activeRun is null)
+                throw new InvalidOperationException("There is no active shared-estimation run.");
+
+            if (!_connections.TryGetValue(workerId, out var worker))
+                return _activeRun;
+            var slotCount = _connections.Values.Count(connection => connection.EndpointId == worker.EndpointId);
+            IReadOnlyDictionary<int, string>? overrides = null;
+            _activeOverrides?.TryGetValue(workerId, out overrides);
+            return _activeRun with
+            {
+                BasicParameterOverrides = overrides ?? _activeRun.BasicParameterOverrides,
+                WorkerSlotCount = Math.Max(1, slotCount)
+            };
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/XTMF2/Bus/Optimization/SharedEstimationWorkerProcess.cs b/src/XTMF2/Bus/Optimization/SharedEstimationWorkerProcess.cs
new file mode 100644
index 00000000..81448925
--- /dev/null
+++ b/src/XTMF2/Bus/Optimization/SharedEstimationWorkerProcess.cs
@@ -0,0 +1,237 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using XTMF2.Bus;
+
+namespace XTMF2.Bus.Optimization;
+
+internal sealed class SharedEstimationWorkerProcess : IDisposable
+{
+    private const string WorkerDirectoriesName = ".xtmf-estimation-workers";
+    private readonly string _runId;
+    private readonly string _workerDirectory;
+    private readonly string _workerDirectoriesRoot;
+    private readonly Process _process;
+    private readonly Stream _stream;
+    private readonly BinaryReader _reader;
+    private readonly BinaryWriter _writer;
+    private readonly object _requestSync = new();
+    private readonly object _writeSync = new();
+    private int _disposed;
+
+    private SharedEstimationWorkerProcess(string runId, string workerDirectory,
+        string workerDirectoriesRoot, Process process, Stream stream)
+    {
+        _runId = runId;
+        _workerDirectory = workerDirectory;
+        _workerDirectoriesRoot = workerDirectoriesRoot;
+        _process = process;
+        _stream = stream;
+        _reader = new BinaryReader(stream, Encoding.UTF8, true);
+        _writer = new BinaryWriter(stream, Encoding.UTF8, true);
+    }
+
+    internal static bool TryStart(SharedEstimationRunRequest request, IReadOnlyList<string> extraDlls,
+        out SharedEstimationWorkerProcess? worker, out string? error)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+        ArgumentNullException.ThrowIfNull(extraDlls);
+        worker = null;
+        error = null;
+        Process? process = null;
+        Stream? stream = null;
+        var workerDirectoriesRoot = Path.Combine(Path.GetFullPath(request.WorkingDirectory),
+            WorkerDirectoriesName);
+        var workerDirectory = Path.Combine(workerDirectoriesRoot, Guid.NewGuid().ToString("N"));
+        try
+        {
+            var runAssemblyDirectory = Path.GetDirectoryName(typeof(RunServerBus).Assembly.Location)!;
+            var runAssemblyPath = Path.Combine(runAssemblyDirectory, "XTMF2.Run.dll");
+            if (!File.Exists(runAssemblyPath))
+                throw new FileNotFoundException("Unable to locate the XTMF2.Run worker executable.", runAssemblyPath);
+
+            if (!CreateStreams.CreateNewTcpHost("127.0.0.1", 0, out stream, out _, out error, port =>
+                {
+                    var startInfo = new ProcessStartInfo
+                    {
+                        FileName = "dotnet",
+                        UseShellExecute = false,
+                        CreateNoWindow = OperatingSystem.IsWindows(),
+                        WorkingDirectory = runAssemblyDirectory
+                    };
+                    startInfo.ArgumentList.Add(runAssemblyPath);
+                    startInfo.ArgumentList.Add("-runID");
+                    startInfo.ArgumentList.Add(request.RunId);
+                    foreach (var extraDll in extraDlls.Distinct(StringComparer.Ordinal))
+                    {
+                        startInfo.ArgumentList.Add("-loadDLL");
+                        startInfo.ArgumentList.Add(extraDll);
+                    }
+                    startInfo.ArgumentList.Add("-sharedEstimationWorker");
+                    startInfo.ArgumentList.Add("-tcp");
+                    startInfo.ArgumentList.Add("127.0.0.1");
+                    startInfo.ArgumentList.Add(port.ToString(System.Globalization.CultureInfo.InvariantCulture));
+                    process = Process.Start(startInfo)
+                        ?? throw new InvalidOperationException("Unable to start the XTMF2.Run worker process.");
+                }, timeoutMilliseconds: 15000))
+                throw new IOException(error ?? "Unable to connect to the XTMF2.Run worker process.");
+
+            var candidateWorker = new SharedEstimationWorkerProcess(request.RunId,
+                workerDirectory, workerDirectoriesRoot, process!, stream!);
+            SharedEstimationProtocol.WriteRunRequest(candidateWorker._writer,
+                request with { WorkingDirectory = workerDirectory });
+            candidateWorker._writer.Flush();
+            var readiness = SharedEstimationProtocol.ReadWorkerReady(candidateWorker._reader);
+            if (readiness.RunId != request.RunId || !readiness.Succeeded)
+            {
+                error = readiness.Error ?? "The XTMF2.Run worker rejected its start request.";
+                candidateWorker.Dispose();
+                return false;
+            }
+
+            worker = candidateWorker;
+            return true;
+        }
+        catch (Exception exception) when (exception is IOException or InvalidOperationException
+            or System.ComponentModel.Win32Exception or ArgumentException or ObjectDisposedException)
+        {
+            error = exception.Message;
+            stream?.Dispose();
+            if (process is not null)
+            {
+                try
+                {
+                    if (!process.HasExited)
+                        process.Kill(entireProcessTree: true);
+                }
+                catch (Exception killException) when (killException is InvalidOperationException
+                    or System.ComponentModel.Win32Exception or NotSupportedException)
+                {
+                }
+                process.Dispose();
+            }
+            DeleteWorkerDirectories(workerDirectory, workerDirectoriesRoot);
+            return false;
+        }
+    }
+
+    internal SharedEstimationEvaluationResult Evaluate(SharedEstimationCandidate candidate)
+    {
+        if (Volatile.Read(ref _disposed) != 0)
+            return CreateError(candidate, "The estimation worker process is no longer running.");
+
+        lock (_requestSync)
+        {
+            try
+            {
+                lock (_writeSync)
+                {
+                    ObjectDisposedException.ThrowIf(Volatile.Read(ref _disposed) != 0, this);
+                    SharedEstimationProtocol.WriteCandidate(_writer, candidate);
+                    _writer.Flush();
+                }
+
+                var result = SharedEstimationProtocol.ReadResult(_reader);
+                if (result.RunId != candidate.RunId || result.CandidateId != candidate.CandidateId ||
+                    result.BatchId != candidate.BatchId)
+                    throw new InvalidDataException("The worker process returned a result for a different candidate.");
+                return result;
+            }
+            catch (Exception exception) when (exception is IOException or InvalidOperationException
+                or ObjectDisposedException or ArgumentException)
+            {
+                StopProcess();
+                return CreateError(candidate, exception.Message);
+            }
+        }
+    }
+
+    private static SharedEstimationEvaluationResult CreateError(SharedEstimationCandidate candidate, string message)
+        => new(candidate.RunId, candidate.BatchId, candidate.CandidateId, double.NaN, message, null, null);
+
+    private void StopProcess()
+    {
+        if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            return;
+        try
+        {
+            if (!_process.HasExited)
+            {
+                _process.Kill(entireProcessTree: true);
+                _process.WaitForExit();
+            }
+        }
+        catch (Exception exception) when (exception is InvalidOperationException
+            or System.ComponentModel.Win32Exception or NotSupportedException)
+        {
+        }
+        _stream.Dispose();
+        _reader.Dispose();
+        _writer.Dispose();
+        _process.Dispose();
+        DeleteWorkerDirectories(_workerDirectory, _workerDirectoriesRoot);
+    }
+
+    public void Dispose()
+    {
+        if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            return;
+        try
+        {
+            lock (_writeSync)
+            {
+                SharedEstimationProtocol.WriteCancel(_writer, _runId, "Worker slot released.");
+                _writer.Flush();
+            }
+            if (!_process.WaitForExit(1000))
+            {
+                _process.Kill(entireProcessTree: true);
+                _process.WaitForExit();
+            }
+        }
+        catch (Exception exception) when (exception is IOException or InvalidOperationException
+            or System.ComponentModel.Win32Exception or ObjectDisposedException or NotSupportedException)
+        {
+            try
+            {
+                if (!_process.HasExited)
+                {
+                    _process.Kill(entireProcessTree: true);
+                    _process.WaitForExit();
+                }
+            }
+            catch (Exception killException) when (killException is InvalidOperationException
+                or System.ComponentModel.Win32Exception or NotSupportedException)
+            {
+            }
+        }
+        finally
+        {
+            _stream.Dispose();
+            _reader.Dispose();
+            _writer.Dispose();
+            _process.Dispose();
+            DeleteWorkerDirectories(_workerDirectory, _workerDirectoriesRoot);
+        }
+    }
+
+    private static void DeleteWorkerDirectories(string workerDirectory, string workerDirectoriesRoot)
+    {
+        try
+        {
+            if (Directory.Exists(workerDirectory))
+                Directory.Delete(workerDirectory, recursive: true);
+            if (Directory.Exists(workerDirectoriesRoot) &&
+                !Directory.EnumerateFileSystemEntries(workerDirectoriesRoot).Any())
+                Directory.Delete(workerDirectoriesRoot);
+        }
+        catch (Exception exception) when (exception is IOException or UnauthorizedAccessException
+            or ArgumentException or NotSupportedException)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/XTMF2/Bus/Optimization/SharedEstimationWorkerSession.cs b/src/XTMF2/Bus/Optimization/SharedEstimationWorkerSession.cs
new file mode 100644
index 00000000..d7a94ef7
--- /dev/null
+++ b/src/XTMF2/Bus/Optimization/SharedEstimationWorkerSession.cs
@@ -0,0 +1,354 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Threading.Channels;
+using XTMF2.Bus;
+
+namespace XTMF2.Bus.Optimization;
+
+/// <summary>
+/// Binds shared-estimation protocol events on a RunServerBus to a prepared worker participant.
+/// </summary>
+public sealed class SharedEstimationWorkerSession : IDisposable
+{
+    private readonly RunServerBus _bus;
+    private readonly object _sync = new();
+    private SharedEstimationWorkerProcess? _workerProcess;
+    private string? _runId;
+    private RunError? _preparationError;
+    private bool _disposed;
+    private long? _activeBatchId;
+    private string? _processingRunId;
+    private Scheduler.ReservationLease? _reservation;
+    private readonly List<Scheduler.ReservationLease> _reservationsToReleaseWhenIdle = new();
+    private TaskCompletionSource<bool>? _assignmentReady;
+    private bool _evaluatingCandidate;
+    private readonly Channel<SharedEstimationCandidate> _candidateQueue = Channel.CreateUnbounded<SharedEstimationCandidate>();
+
+    internal SharedEstimationWorkerSession(RunServerBus bus)
+    {
+        _bus = bus;
+        _bus.SharedEstimationRunRequested += OnRunRequested;
+        _bus.SharedEstimationCandidateReceived += OnCandidateReceived;
+        _bus.SharedEstimationCancellationRequested += OnCancellationRequested;
+        _ = Task.Run(ProcessCandidateQueueAsync);
+    }
+
+    private void OnRunRequested(object sender, SharedEstimationRunRequest request)
+    {
+        Console.WriteLine($"RunServer estimation run issued: {request.RunId}");
+        Console.Out.Flush();
+
+        Scheduler.ReservationLease reservation;
+        try
+        {
+            reservation = _bus.ReserveSharedEstimationWorker(request);
+        }
+        catch (Exception exception)
+        {
+            _bus.SendStatusMessage(request.RunId,
+                $"[Estimation] Unable to queue worker: {exception.Message}");
+            return;
+        }
+        Scheduler.ReservationLease? previousReservation;
+        SharedEstimationWorkerProcess? previousWorkerProcess;
+        var ready = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        lock (_sync)
+        {
+            if (_disposed)
+            {
+                reservation.Dispose();
+                return;
+            }
+            previousReservation = _reservation;
+            previousWorkerProcess = _workerProcess;
+            _runId = request.RunId;
+            _workerProcess = null;
+            _preparationError = null;
+            _reservation = reservation;
+            _assignmentReady = ready;
+            reservation.SetCancellationHandler(() => ClearAssignment(request.RunId, reservation));
+        }
+        previousWorkerProcess?.Dispose();
+        if (previousReservation is not null)
+            ReleaseOrDefer(previousReservation);
+
+        _ = PrepareWhenScheduled(request, reservation, ready);
+
+        _bus.SendStatusMessage(request.RunId,
+            "[Estimation] Worker queued with the RunServer model-system runs.");
+    }
+
+    private async Task PrepareWhenScheduled(SharedEstimationRunRequest request,
+        Scheduler.ReservationLease reservation, TaskCompletionSource<bool> ready)
+    {
+        try
+        {
+            await reservation.Started.ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+            ready.TrySetResult(false);
+            return;
+        }
+
+        SharedEstimationWorkerProcess? workerProcess = null;
+        RunError? error = null;
+        try
+        {
+            if (!SharedEstimationWorkerProcess.TryStart(request, _bus.ExtraDlls,
+                    out workerProcess, out var processError))
+                error = new RunError(RunErrorType.Validation,
+                    processError ?? "Unable to start the estimation worker process.", null, string.Empty);
+        }
+        catch (Exception exception)
+        {
+            error = new RunError(RunErrorType.Validation, exception.Message, null, exception.StackTrace);
+        }
+
+        lock (_sync)
+        {
+            if (_disposed || !ReferenceEquals(_reservation, reservation))
+            {
+                workerProcess?.Dispose();
+                reservation.Dispose();
+                ready.TrySetResult(false);
+                return;
+            }
+            _workerProcess = workerProcess;
+            _preparationError = error;
+        }
+        ready.TrySetResult(true);
+        try
+        {
+            _bus.SendSharedEstimationWorkerReady(new SharedEstimationWorkerReady(
+                request.RunId, workerProcess is not null && error is null, error?.Message));
+        }
+        catch (Exception exception) when (exception is System.IO.IOException or ObjectDisposedException
+            or InvalidOperationException or ArgumentException)
+        {
+        }
+        if (error is not null)
+        {
+            _bus.SendStatusMessage(request.RunId, $"[Estimation] Worker preparation failed: {error.Message}");
+            ClearAssignment(request.RunId, reservation);
+        }
+        else
+            _bus.SendStatusMessage(request.RunId, "[Estimation] Worker has the RunServer execution slot.");
+    }
+
+    private void OnCandidateReceived(object sender, SharedEstimationCandidate candidate)
+    {
+        _candidateQueue.Writer.TryWrite(candidate);
+    }
+
+    public IReadOnlyList<RunServerActivity> GetActiveActivities()
+    {
+        lock (_sync)
+        {
+            var activityRunId = _processingRunId ?? _runId;
+            if (_disposed || activityRunId is null)
+                return Array.Empty<RunServerActivity>();
+            var isEvaluating = _activeBatchId.HasValue;
+            return
+            [
+                new RunServerActivity(activityRunId, "Shared estimation worker", "Shared estimation worker",
+                    RunServerActivityState.Running,
+                    isEvaluating
+                        ? $"Evaluating candidate, batch {_activeBatchId}."
+                        : "Worker has the RunServer execution slot.",
+                    ActiveWorkers: 1,
+                    EvaluationsPending: isEvaluating ? 1 : 0)
+            ];
+        }
+    }
+
+    private async Task ProcessCandidateQueueAsync()
+    {
+        await foreach (var candidate in _candidateQueue.Reader.ReadAllAsync())
+        {
+            ProcessCandidate(candidate);
+        }
+    }
+
+    private void ProcessCandidate(SharedEstimationCandidate candidate)
+    {
+        Task<bool>? readyTask;
+        Scheduler.ReservationLease? assignmentReservation;
+        string? assignmentRunId;
+        lock (_sync)
+        {
+            readyTask = _assignmentReady?.Task;
+            assignmentReservation = _reservation;
+            assignmentRunId = _runId;
+            _processingRunId = candidate.RunId;
+            _activeBatchId = candidate.BatchId;
+        }
+        try
+        {
+            var preparationCompleted = readyTask is not null && readyTask.GetAwaiter().GetResult();
+            bool isReady;
+            SharedEstimationWorkerProcess? activeWorkerProcess;
+            RunError? preparationError;
+            string? runId;
+            lock (_sync)
+            {
+                if (_disposed)
+                    return;
+                isReady = preparationCompleted
+                    && assignmentReservation is not null
+                    && ReferenceEquals(_reservation, assignmentReservation)
+                    && _runId == assignmentRunId;
+                activeWorkerProcess = _workerProcess;
+                preparationError = _preparationError;
+                runId = assignmentRunId;
+            }
+
+            SharedEstimationEvaluationResult result;
+            if (!isReady || runId is null || candidate.RunId != runId)
+            {
+                result = CreateError(candidate, "No matching shared-estimation run is active.", null, null);
+            }
+            else if (preparationError is not null)
+            {
+                result = CreateError(candidate, preparationError.Message ?? "Worker preparation failed.",
+                    preparationError.ModuleName, preparationError.ElementId);
+            }
+            else if (activeWorkerProcess is null)
+            {
+                result = CreateError(candidate, "The shared-estimation worker is not prepared.", null, null);
+            }
+            else
+            {
+                bool shouldEvaluate;
+                lock (_sync)
+                {
+                    shouldEvaluate = _runId == candidate.RunId;
+                    if (shouldEvaluate)
+                        _evaluatingCandidate = true;
+                }
+                if (!shouldEvaluate)
+                {
+                    result = CreateError(candidate, "The shared-estimation assignment was removed.", null, null);
+                }
+                else
+                {
+                    try
+                    {
+                        result = activeWorkerProcess.Evaluate(candidate);
+                    }
+                    finally
+                    {
+                        Scheduler.ReservationLease[] release;
+                        lock (_sync)
+                        {
+                            _evaluatingCandidate = false;
+                            release = _reservationsToReleaseWhenIdle.ToArray();
+                            _reservationsToReleaseWhenIdle.Clear();
+                        }
+                        foreach (var reservation in release)
+                            reservation.Dispose();
+                    }
+                }
+            }
+
+            _bus.SendSharedEstimationResult(result);
+        }
+        finally
+        {
+            lock (_sync)
+            {
+                if (_processingRunId == candidate.RunId)
+                {
+                    _processingRunId = null;
+                    _activeBatchId = null;
+                }
+            }
+        }
+    }
+
+    private void OnCancellationRequested(object sender, string runId, string? reason)
+    {
+        Scheduler.ReservationLease? reservation;
+        lock (_sync)
+            reservation = _runId == runId ? _reservation : null;
+        if (reservation is null)
+            ClearAssignment(runId);
+        else
+            reservation.CancelGroup();
+    }
+
+    private void ReleaseOrDefer(Scheduler.ReservationLease reservation)
+    {
+        lock (_sync)
+        {
+            if (_evaluatingCandidate)
+            {
+                _reservationsToReleaseWhenIdle.Add(reservation);
+                return;
+            }
+        }
+        reservation.Dispose();
+    }
+
+    private void ClearAssignment(string runId, Scheduler.ReservationLease? expectedReservation = null)
+    {
+        Scheduler.ReservationLease? release = null;
+        SharedEstimationWorkerProcess? workerProcess = null;
+        lock (_sync)
+        {
+            if (!_disposed && _runId == runId
+                && (expectedReservation is null || ReferenceEquals(_reservation, expectedReservation)))
+            {
+                _runId = null;
+                workerProcess = _workerProcess;
+                _workerProcess = null;
+                _preparationError = null;
+                _assignmentReady?.TrySetResult(false);
+                _assignmentReady = null;
+                release = _reservation;
+                _reservation = null;
+                _activeBatchId = null;
+            }
+        }
+        workerProcess?.Dispose();
+        if (release is not null)
+            ReleaseOrDefer(release);
+    }
+
+    private static SharedEstimationEvaluationResult CreateError(
+        SharedEstimationCandidate candidate, string message, string? moduleName, Guid? elementId)
+        => new(candidate.RunId, candidate.BatchId, candidate.CandidateId, double.NaN,
+            message, moduleName, elementId);
+
+    public void Dispose()
+    {
+        Scheduler.ReservationLease? release;
+        SharedEstimationWorkerProcess? workerProcess;
+        lock (_sync)
+        {
+            if (_disposed)
+                return;
+            _disposed = true;
+            _runId = null;
+            workerProcess = _workerProcess;
+            _workerProcess = null;
+            _preparationError = null;
+            _activeBatchId = null;
+            _processingRunId = null;
+            _assignmentReady?.TrySetResult(false);
+            _assignmentReady = null;
+            release = _reservation;
+            _reservation = null;
+        }
+
+        workerProcess?.Dispose();
+        if (release is not null)
+            ReleaseOrDefer(release);
+
+        _candidateQueue.Writer.TryComplete();
+        _bus.SharedEstimationRunRequested -= OnRunRequested;
+        _bus.SharedEstimationCandidateReceived -= OnCandidateReceived;
+        _bus.SharedEstimationCancellationRequested -= OnCancellationRequested;
+    }
+}
\ No newline at end of file
diff --git a/src/XTMF2/Bus/RemoteRunRegistry.cs b/src/XTMF2/Bus/RemoteRunRegistry.cs
new file mode 100644
index 00000000..413be4c6
--- /dev/null
+++ b/src/XTMF2/Bus/RemoteRunRegistry.cs
@@ -0,0 +1,552 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text.Json;
+using System.Threading.Tasks;
+using XTMF2.Bus.Optimization;
+
+namespace XTMF2.Bus;
+
+public enum RemoteRunState
+{
+    Running,
+    Completed,
+    Failed,
+    Interrupted
+}
+
+public sealed record RemoteRunParameterValue(int NodeIndex, double Value);
+
+public sealed record RemoteRunArtifactsResponse(string RunId, byte[]? Archive, string? Error);
+
+public sealed record RemoteRunSnapshot(
+    string RunId,
+    string RunName,
+    RunMode RunMode,
+    string WorkingDirectory,
+    string StartToExecute,
+    string ModelSystemHash,
+    RemoteRunState State,
+    string Status,
+    int Iteration,
+    double Fitness,
+    IReadOnlyList<RemoteRunParameterValue> ProgressParameters,
+    IReadOnlyList<RemoteRunParameterValue>? OptimizationResults,
+    string? ErrorMessage,
+    string? ErrorStack,
+    bool ArtifactsAvailable,
+    DateTimeOffset UpdatedAt,
+    Guid? ProjectId = null,
+    Guid? ModelSystemId = null,
+    Guid? OwnerUserId = null);
+
+/// <summary>
+/// Owns remote run scheduling and retained run state for the lifetime of the RunServer process.
+/// </summary>
+public sealed class RemoteRunRegistry : IDisposable
+{
+    private static readonly JsonSerializerOptions SnapshotJsonOptions = new()
+    {
+        NumberHandling = System.Text.Json.Serialization.JsonNumberHandling.AllowNamedFloatingPointLiterals
+    };
+
+    private readonly object _sync = new();
+    private readonly Dictionary<string, RemoteRunJob> _jobs = new(StringComparer.Ordinal);
+    private readonly Scheduler _scheduler;
+    private readonly string _storageDirectory;
+    private bool _disposed;
+
+    public bool IsIdle => _scheduler.IsIdle;
+
+    public void BeginDrain()
+        => _scheduler.BeginDrain();
+
+    public void EndDrain()
+        => _scheduler.EndDrain();
+
+    public RemoteRunRegistry(string? storageDirectory = null)
+    {
+        _storageDirectory = storageDirectory ?? Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "XTMF2", "RemoteRuns");
+        Directory.CreateDirectory(_storageDirectory);
+        _scheduler = new Scheduler(runLocal: false);
+        LoadPersistedJobs();
+    }
+
+    public bool Submit(RunServerBus observer, RunContext context, string runName,
+        RunMode runMode, string workingDirectory, string startToExecute, byte[] modelSystem,
+        Guid? projectId = null, Guid? modelSystemId = null, Guid? ownerUserId = null)
+    {
+        ArgumentNullException.ThrowIfNull(observer);
+        ArgumentNullException.ThrowIfNull(context);
+
+        var initial = new RemoteRunSnapshot(context.ID, runName, runMode, workingDirectory,
+            startToExecute, Convert.ToHexString(SHA256.HashData(modelSystem)), RemoteRunState.Running,
+            "Run submitted.", 0, double.NaN, Array.Empty<RemoteRunParameterValue>(), null,
+            null, null, false, DateTimeOffset.UtcNow, projectId, modelSystemId, ownerUserId);
+        RemoteRunJob job;
+        lock (_sync)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            if (!_scheduler.IsAcceptingWork)
+                return false;
+            if (_jobs.ContainsKey(context.ID))
+                return false;
+            job = new RemoteRunJob(this, observer, context, initial);
+            _jobs.Add(context.ID, job);
+            job.Persist();
+        }
+
+        _scheduler.Run(context, job);
+        return true;
+    }
+
+    internal Scheduler.ReservationLease ReserveWorkerSlot(RunContext context, int expectedSlotCount)
+        => _scheduler.ReserveGroup(context.ID, context, expectedSlotCount);
+
+    public void Attach(RunServerBus observer)
+    {
+        lock (_sync)
+        {
+            foreach (var job in _jobs.Values)
+                job.Attach(observer);
+        }
+    }
+
+    public void Detach(RunServerBus observer)
+    {
+        lock (_sync)
+        {
+            foreach (var job in _jobs.Values)
+                job.Detach(observer);
+        }
+    }
+
+    public IReadOnlyList<RemoteRunSnapshot> GetSnapshots()
+    {
+        lock (_sync)
+            return _jobs.Values.Select(job => job.GetSnapshot()).ToArray();
+    }
+
+    public IReadOnlyList<RunServerActivity> GetActiveActivities()
+    {
+        lock (_sync)
+        {
+            return _scheduler.GetInventory()
+                .Select(item =>
+                {
+                    if (item.IsReservation)
+                        return new RunServerActivity(item.Context.ID, "Shared estimation worker",
+                            "Shared estimation worker",
+                            item.IsRunning ? RunServerActivityState.Running : RunServerActivityState.Queued,
+                            item.IsRunning ? "Worker has the RunServer execution slot." : "Waiting in the RunServer queue.",
+                            item.QueuePosition, ActiveWorkers: item.IsRunning ? 1 : 0);
+                    var snapshot = _jobs[item.Context.ID].GetSnapshot();
+                    return new RunServerActivity(snapshot.RunId, snapshot.RunName,
+                        snapshot.RunMode.ToString(),
+                        item.IsRunning ? RunServerActivityState.Running : RunServerActivityState.Queued,
+                        snapshot.Status, item.QueuePosition, snapshot.Iteration, snapshot.Fitness);
+                })
+                .ToArray();
+        }
+    }
+
+    public bool TryReadArtifacts(string runId, out byte[]? archive)
+    {
+        RemoteRunJob? job;
+        string path;
+        lock (_sync)
+        {
+            if (!_jobs.TryGetValue(runId, out job))
+            {
+                archive = null;
+                return false;
+            }
+            path = GetArtifactPath(runId);
+        }
+
+        try
+        {
+            if (!File.Exists(path))
+            {
+                var snapshot = job.GetSnapshot();
+                if (snapshot.State == RemoteRunState.Running || !IsPrivateRunDirectory(runId, snapshot.WorkingDirectory) ||
+                    !Directory.Exists(snapshot.WorkingDirectory))
+                {
+                    archive = null;
+                    return false;
+                }
+
+                var temporary = path + ".tmp";
+                if (File.Exists(temporary))
+                    File.Delete(temporary);
+                ZipFile.CreateFromDirectory(snapshot.WorkingDirectory, temporary, CompressionLevel.Fastest, false);
+                File.Move(temporary, path, true);
+                job.SetArtifactsAvailable();
+            }
+            archive = File.ReadAllBytes(path);
+            return true;
+        }
+        catch (Exception exception) when (exception is IOException or UnauthorizedAccessException)
+        {
+            archive = null;
+            return false;
+        }
+    }
+
+    public bool AcknowledgeReceived(string runId)
+    {
+        RemoteRunJob? job;
+        lock (_sync)
+        {
+            if (!_jobs.TryGetValue(runId, out job) || job.GetSnapshot().State == RemoteRunState.Running)
+                return false;
+        }
+
+        job.AcknowledgeReceived();
+        try { File.Delete(GetArtifactPath(runId)); } catch (IOException) { }
+        return true;
+    }
+
+    private static bool IsPrivateRunDirectory(string runId, string workingDirectory)
+    {
+        if (string.IsNullOrWhiteSpace(runId) || runId is "." or ".." ||
+            runId.Contains(Path.DirectorySeparatorChar) || runId.Contains(Path.AltDirectorySeparatorChar) ||
+            runId.Contains('\\'))
+            return false;
+        try
+        {
+            var actual = Path.GetFullPath(workingDirectory);
+            var expected = Path.GetFullPath(Path.Combine(Path.GetTempPath(), "XTMF2", "Runs", runId));
+            var comparison = OperatingSystem.IsWindows()
+                ? StringComparison.OrdinalIgnoreCase
+                : StringComparison.Ordinal;
+            if (!string.Equals(actual, expected, comparison))
+                return false;
+            if (File.Exists(actual))
+                return false;
+            return !Directory.Exists(actual) ||
+                (File.GetAttributes(actual) & FileAttributes.ReparsePoint) == 0;
+        }
+        catch (Exception exception) when (exception is ArgumentException or IOException or UnauthorizedAccessException or NotSupportedException)
+        {
+            return false;
+        }
+    }
+
+    public bool DeleteRun(string runId, out string? error)
+    {
+        error = null;
+        lock (_sync)
+        {
+            if (!_jobs.TryGetValue(runId, out var job))
+            {
+                error = "The remote run was not found.";
+                return false;
+            }
+
+            var snapshot = job.GetSnapshot();
+            if (snapshot.State == RemoteRunState.Running)
+            {
+                error = "A running remote job cannot be deleted.";
+                return false;
+            }
+
+            if (string.IsNullOrWhiteSpace(runId) || runId is "." or ".." ||
+                runId.Contains(Path.DirectorySeparatorChar) || runId.Contains(Path.AltDirectorySeparatorChar) ||
+                runId.Contains('\\'))
+            {
+                error = "The remote run ID is invalid.";
+                return false;
+            }
+
+            if (!IsPrivateRunDirectory(runId, snapshot.WorkingDirectory))
+            {
+                error = "The remote run directory is outside the RunServer's private run workspace.";
+                return false;
+            }
+
+            try
+            {
+                if (Directory.Exists(snapshot.WorkingDirectory))
+                    Directory.Delete(snapshot.WorkingDirectory, recursive: true);
+
+                File.Delete(GetArtifactPath(runId));
+                File.Delete(GetArtifactPath(runId) + ".tmp");
+                File.Delete(GetManifestPath(runId));
+                _jobs.Remove(runId);
+                return true;
+            }
+            catch (Exception exception) when (exception is IOException or UnauthorizedAccessException)
+            {
+                error = $"Unable to remove the remote run files: {exception.Message}";
+                return false;
+            }
+        }
+    }
+
+    public void Cancel(string runId)
+    {
+        lock (_sync)
+        {
+            if (_jobs.TryGetValue(runId, out var job))
+                job.Cancel();
+        }
+    }
+
+    public bool Kill(string runId)
+        => _scheduler.Kill(runId);
+
+    public void Dispose()
+    {
+        lock (_sync)
+        {
+            if (_disposed)
+                return;
+            _disposed = true;
+        }
+        _scheduler.Dispose();
+    }
+
+    private string GetManifestPath(string runId)
+        => Path.Combine(_storageDirectory, $"{Convert.ToHexString(SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(runId)))}.json");
+
+    private string GetArtifactPath(string runId)
+        => Path.Combine(_storageDirectory, $"{Convert.ToHexString(SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(runId)))}.zip");
+
+    private void LoadPersistedJobs()
+    {
+        foreach (var path in Directory.EnumerateFiles(_storageDirectory, "*.json"))
+        {
+            try
+            {
+                var snapshot = JsonSerializer.Deserialize<RemoteRunSnapshot>(File.ReadAllBytes(path), SnapshotJsonOptions);
+                if (snapshot is null)
+                    continue;
+                if (snapshot.State == RemoteRunState.Running)
+                {
+                    snapshot = snapshot with
+                    {
+                        State = RemoteRunState.Interrupted,
+                        Status = "RunServer restarted; saved run details restored. The run did not resume.",
+                        UpdatedAt = DateTimeOffset.UtcNow
+                    };
+                    File.WriteAllBytes(path, JsonSerializer.SerializeToUtf8Bytes(snapshot, SnapshotJsonOptions));
+                }
+                _jobs[snapshot.RunId] = new RemoteRunJob(this, snapshot);
+            }
+            catch (Exception exception) when (exception is IOException or JsonException or UnauthorizedAccessException)
+            {
+            }
+        }
+    }
+
+    private sealed class RemoteRunJob : IRunOutputSink
+    {
+        private readonly RemoteRunRegistry _registry;
+        private readonly object _sync = new();
+        private readonly RunContext? _context;
+        private readonly RunServerBus? _bridgeBus;
+        private readonly IReadOnlyList<string> _extraDlls;
+        private RemoteRunSnapshot _snapshot;
+        private RunServerBus? _observer;
+
+        public RemoteRunJob(RemoteRunRegistry registry, RunServerBus observer,
+            RunContext context, RemoteRunSnapshot snapshot)
+        {
+            _registry = registry;
+            _observer = observer;
+            _bridgeBus = observer;
+            _extraDlls = observer.ExtraDlls.ToArray();
+            _context = context;
+            _snapshot = snapshot;
+        }
+
+        public RemoteRunJob(RemoteRunRegistry registry, RemoteRunSnapshot snapshot)
+        {
+            _registry = registry;
+            _extraDlls = Array.Empty<string>();
+            _snapshot = snapshot;
+        }
+
+        public IReadOnlyList<string> ExtraDlls => _extraDlls;
+
+        public RemoteRunSnapshot GetSnapshot()
+        {
+            lock (_sync)
+                return _snapshot with
+                {
+                    ProgressParameters = _snapshot.ProgressParameters.ToArray(),
+                    OptimizationResults = _snapshot.OptimizationResults?.ToArray()
+                };
+        }
+
+        public void Attach(RunServerBus observer)
+        {
+            lock (_sync)
+                _observer = observer;
+        }
+
+        public void Detach(RunServerBus observer)
+        {
+            lock (_sync)
+            {
+                if (ReferenceEquals(_observer, observer))
+                    _observer = null;
+            }
+        }
+
+        public void Cancel()
+            => _context?.RequestCancelRun(_snapshot.RunId);
+
+        public void AcknowledgeReceived()
+            => Update(snapshot => snapshot with
+            {
+                Status = "Completion received by a GUI; remote output remains available.",
+                UpdatedAt = DateTimeOffset.UtcNow
+            });
+
+        public void SetArtifactsAvailable()
+            => Update(snapshot => snapshot with { ArtifactsAvailable = true, UpdatedAt = DateTimeOffset.UtcNow });
+
+        public Task StartProcessingRequestFromRun(string id, Stream clientToRunStream)
+        {
+            if (_bridgeBus is null)
+                throw new IOException("The RunServer session is unavailable to bridge this run.");
+            return _bridgeBus.StartProcessingRequestFromRun(id, clientToRunStream, this);
+        }
+
+        public void ModelRunFailedValidation(string runId, string? error, string? moduleName = null, string? elementId = null)
+        {
+            Update(snapshot => snapshot with
+            {
+                State = RemoteRunState.Failed,
+                Status = error ?? "Run validation failed.",
+                ErrorMessage = error,
+                UpdatedAt = DateTimeOffset.UtcNow
+            });
+            Forward(observer => observer.ModelRunFailedValidation(runId, error, moduleName, elementId));
+        }
+
+        public void ModelRunFailed(string runId, string? message, string? stackTrace,
+            string? moduleName = null, string? elementId = null)
+        {
+            Update(snapshot => snapshot with
+            {
+                State = RemoteRunState.Failed,
+                Status = message ?? "Run failed.",
+                ErrorMessage = message,
+                ErrorStack = stackTrace,
+                UpdatedAt = DateTimeOffset.UtcNow
+            });
+            Forward(observer => observer.ModelRunFailed(runId, message, stackTrace, moduleName, elementId));
+        }
+
+        public void SendStatusMessage(string runId, string? message)
+        {
+            Update(snapshot => snapshot with { Status = message ?? string.Empty, UpdatedAt = DateTimeOffset.UtcNow });
+            Forward(observer => observer.SendStatusMessage(runId, message));
+        }
+
+        public void SendOptimizationResults(string runId, IReadOnlyList<(int nodeIndex, double value)> results)
+        {
+            var values = results.Select(item => new RemoteRunParameterValue(item.nodeIndex, item.value)).ToArray();
+            Update(snapshot => snapshot with { OptimizationResults = values, UpdatedAt = DateTimeOffset.UtcNow });
+            Forward(observer => observer.SendOptimizationResults(runId, results));
+        }
+
+        public void SendIterationProgress(string runId, int iteration, double fitness,
+            int fitnessTestsThisIteration, IReadOnlyList<(int nodeIndex, double value)> values)
+        {
+            var parameters = values.Select(item => new RemoteRunParameterValue(item.nodeIndex, item.value)).ToArray();
+            Update(snapshot => snapshot with
+            {
+                Iteration = iteration,
+                Fitness = fitness,
+                ProgressParameters = parameters,
+                UpdatedAt = DateTimeOffset.UtcNow
+            });
+            Forward(observer => observer.SendIterationProgress(runId, iteration, fitness,
+                fitnessTestsThisIteration, values));
+        }
+
+        public void ModelRunComplete(string runId)
+        {
+            Update(snapshot => snapshot with
+            {
+                State = RemoteRunState.Completed,
+                Status = "Run completed.",
+                UpdatedAt = DateTimeOffset.UtcNow
+            });
+            Forward(observer => observer.ModelRunComplete(runId));
+        }
+
+        public void SendRunArtifacts(string runId, string runDirectory)
+        {
+            var artifactPath = _registry.GetArtifactPath(runId);
+            try
+            {
+                if (Directory.Exists(runDirectory))
+                {
+                    var temporary = artifactPath + ".tmp";
+                    if (File.Exists(temporary))
+                        File.Delete(temporary);
+                    ZipFile.CreateFromDirectory(runDirectory, temporary, CompressionLevel.Fastest, false);
+                    File.Move(temporary, artifactPath, true);
+                    Update(snapshot => snapshot with { ArtifactsAvailable = true, UpdatedAt = DateTimeOffset.UtcNow });
+                }
+            }
+            catch (Exception exception) when (exception is IOException or UnauthorizedAccessException)
+            {
+                SendStatusMessage(runId, $"Run output archive could not be retained: {exception.Message}");
+            }
+            Forward(observer => observer.SendRunArtifacts(runId, runDirectory));
+        }
+
+        private void Update(Func<RemoteRunSnapshot, RemoteRunSnapshot> update)
+        {
+            RunServerBus? observer;
+            lock (_sync)
+            {
+                _snapshot = update(_snapshot);
+                observer = _observer;
+                Persist();
+            }
+            _ = observer;
+        }
+
+        private void Forward(Action<RunServerBus> send)
+        {
+            RunServerBus? observer;
+            lock (_sync)
+                observer = _observer;
+            if (observer is null)
+                return;
+            try
+            {
+                send(observer);
+            }
+            catch (Exception exception) when (exception is IOException or ObjectDisposedException)
+            {
+            }
+        }
+
+        public void Persist()
+        {
+            var snapshot = GetSnapshot();
+            var path = _registry.GetManifestPath(snapshot.RunId);
+            var temporary = path + ".tmp";
+            try
+            {
+                File.WriteAllBytes(temporary, JsonSerializer.SerializeToUtf8Bytes(snapshot, SnapshotJsonOptions));
+                File.Move(temporary, path, true);
+            }
+            catch (Exception exception) when (exception is IOException or UnauthorizedAccessException)
+            {
+            }
+        }
+    }
+}
diff --git a/src/XTMF2/Bus/RunBus.cs b/src/XTMF2/Bus/RunBus.cs
index 1f8da38c..0069029d 100644
--- a/src/XTMF2/Bus/RunBus.cs
+++ b/src/XTMF2/Bus/RunBus.cs
@@ -22,6 +22,7 @@ You should have received a copy of the GNU General Public License
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using XTMF2.Bus.Optimization;
 
 namespace XTMF2.Bus
 {
@@ -247,6 +248,69 @@ public void ProcessRequests()
             }
         }
 
+        public void ProcessSharedEstimationWorkerRequests()
+        {
+            using var reader = new BinaryReader(_toClient, Encoding.UTF8, true);
+            using var writer = new BinaryWriter(_toClient, Encoding.UTF8, true);
+            var request = SharedEstimationProtocol.ReadRunRequest(reader);
+            if (!SharedEstimationWorkerParticipant.TryCreate(_runtime, request,
+                    out var participant, out var error))
+            {
+                SharedEstimationProtocol.WriteWorkerReady(writer,
+                    new SharedEstimationWorkerReady(request.RunId, false, error?.Message));
+                writer.Flush();
+                return;
+            }
+
+            SharedEstimationProtocol.WriteWorkerReady(writer,
+                new SharedEstimationWorkerReady(request.RunId, true, null));
+            writer.Flush();
+
+            while (!_Exit)
+            {
+                SharedEstimationMessageType messageType;
+                try
+                {
+                    (_, messageType) = SharedEstimationProtocol.ReadHeader(reader);
+                }
+                catch (EndOfStreamException)
+                {
+                    _Exit = true;
+                    break;
+                }
+                switch (messageType)
+                {
+                    case SharedEstimationMessageType.EvaluateCandidate:
+                    {
+                        var candidate = SharedEstimationProtocol.ReadCandidatePayload(reader);
+                        SharedEstimationEvaluationResult result;
+                        try
+                        {
+                            result = participant!.Evaluate(candidate);
+                        }
+                        catch (Exception exception)
+                        {
+                            result = new SharedEstimationEvaluationResult(candidate.RunId,
+                                candidate.BatchId, candidate.CandidateId, double.NaN,
+                                exception.Message, null, null);
+                        }
+                        SharedEstimationProtocol.WriteResult(writer, result);
+                        writer.Flush();
+                        break;
+                    }
+                    case SharedEstimationMessageType.Cancel:
+                    {
+                        var (runId, _) = SharedEstimationProtocol.ReadCancelPayload(reader);
+                        if (runId == request.RunId)
+                            _Exit = true;
+                        break;
+                    }
+                    default:
+                        throw new InvalidDataException($"Unexpected shared-estimation worker message: {messageType}.");
+                }
+            }
+        }
+
         #region IDisposable Support
         private bool disposedValue = false; // To detect redundant calls
 
diff --git a/src/XTMF2/Bus/RunContext.cs b/src/XTMF2/Bus/RunContext.cs
index bcaf54c8..9bc6edd5 100644
--- a/src/XTMF2/Bus/RunContext.cs
+++ b/src/XTMF2/Bus/RunContext.cs
@@ -46,6 +46,7 @@ public sealed class RunContext
         /// The directory that this run will be executed in.
         /// </summary>
         private readonly string _currentWorkingDirectory;
+        private readonly IReadOnlyDictionary<int, string>? _basicParameterOverrides;
 
         internal string WorkingDirectory => _currentWorkingDirectory;
 
@@ -72,8 +73,18 @@ public sealed class RunContext
         /// <summary>The run mode; controls whether a single execution or an optimisation loop is performed.</summary>
         private RunMode _runMode = RunMode.Normal;
 
+        public RunMode Mode => _runMode;
+
         /// <summary>Set to true to request that the optimisation loop terminates after the current iteration.</summary>
         private volatile bool _cancelRequested;
+        private volatile bool _killRequested;
+        private readonly object _processSync = new();
+        private Process? _runProcess;
+
+        private List<Action<double>>? _sharedWorkerSetters;
+        private IAction? _sharedWorkerStart;
+        private Func<double>? _sharedWorkerFitnessReader;
+        private ModelSystem? _sharedWorkerModelSystem;
 
         /// <summary>
         /// Requests that the optimisation loop for this run terminates, if this run's ID matches.
@@ -84,7 +95,33 @@ internal void RequestCancelRun(string runId)
                 _cancelRequested = true;
         }
 
-        private RunContext(XTMFRuntime runtime, string id, byte[] modelSystem, string cwd, string start)
+        internal bool KillRequested => _killRequested;
+
+        internal void Kill()
+        {
+            _cancelRequested = true;
+            _killRequested = true;
+            lock (_processSync)
+                KillProcessIfRunning(_runProcess);
+        }
+
+        private static void KillProcessIfRunning(Process? process)
+        {
+            if (process is null)
+                return;
+            try
+            {
+                if (!process.HasExited)
+                    process.Kill(entireProcessTree: true);
+            }
+            catch (Exception exception) when (exception is InvalidOperationException or
+                System.ComponentModel.Win32Exception or NotSupportedException)
+            {
+            }
+        }
+
+        private RunContext(XTMFRuntime runtime, string id, byte[] modelSystem, string cwd, string start,
+            IReadOnlyDictionary<int, string>? basicParameterOverrides)
         {
             _runtime = runtime;
             ID = id;
@@ -92,6 +129,7 @@ private RunContext(XTMFRuntime runtime, string id, byte[] modelSystem, string cw
             _currentWorkingDirectory = cwd;
             HasExecuted = false;
             StartToExecute = start;
+            _basicParameterOverrides = basicParameterOverrides;
         }
 
         /// <summary>
@@ -106,9 +144,10 @@ private RunContext(XTMFRuntime runtime, string id, byte[] modelSystem, string cw
         /// <param name="context">The resulting context.</param>
         /// <returns>True if the model system was able to be processed, false otherwise.</returns>
         public static bool CreateRunContext(XTMFRuntime runtime, string id, byte[] modelSystem, string cwd,
-            string start, RunMode runMode, out RunContext context)
+            string start, RunMode runMode, out RunContext context,
+            IReadOnlyDictionary<int, string>? basicParameterOverrides = null)
         {
-            context = new RunContext(runtime, id, modelSystem, cwd, start) { _runMode = runMode };
+            context = new RunContext(runtime, id, modelSystem, cwd, start, basicParameterOverrides) { _runMode = runMode };
             return true;
         }
 
@@ -119,7 +158,109 @@ public static bool CreateRunContext(XTMFRuntime runtime, string id, byte[] model
             string start, out RunContext context)
             => CreateRunContext(runtime, id, modelSystem, cwd, start, RunMode.Normal, out context);
 
-        private (RunBus runBus, Task readerTask) CreateRunBusLocal(RunServerBus clientBus)
+        internal bool PrepareSharedEstimationWorker([System.Diagnostics.CodeAnalysis.NotNullWhen(false)] out RunError? error)
+        {
+            error = null;
+            if (!BuildAndValidateModelSystem(out var ms, out var start, out error))
+                return false;
+
+            var nodesByIndex = ms!.NodesByLoadIndex;
+            var nodeToIndex = nodesByIndex is null
+                ? new Dictionary<Node, int>()
+                : nodesByIndex.ToDictionary(kv => kv.Value, kv => kv.Key);
+            var setters = new List<Action<double>>();
+            foreach (var group in ms.EstimationGroups)
+                foreach (var entry in group.Parameters)
+                {
+                    if (!entry.IsEnabled || !nodeToIndex.ContainsKey(entry.Node))
+                        continue;
+                    if (BuildDoubleSetter(entry.Node) is { } setter)
+                        setters.Add(setter);
+                }
+
+            var fitnessReader = ms.EstimationFitnessNode is { } fitnessNode
+                ? BuildSignalReader(fitnessNode)
+                : null;
+            if (setters.Count == 0)
+            {
+                error = new RunError(RunErrorType.Validation,
+                    "Estimation requires at least one enabled estimation parameter.", null, string.Empty);
+                return false;
+            }
+            if (fitnessReader is null)
+            {
+                error = new RunError(RunErrorType.Validation,
+                    "Estimation requires a fitness node that returns a numeric value.", null, string.Empty);
+                return false;
+            }
+            if (start!.Module is not IAction modelStart)
+            {
+                error = new RunError(RunErrorType.Validation,
+                    "The configured start module does not implement IAction.", null, string.Empty);
+                return false;
+            }
+
+            _sharedWorkerModelSystem = ms;
+            _sharedWorkerSetters = setters;
+            _sharedWorkerStart = modelStart;
+            _sharedWorkerFitnessReader = fitnessReader;
+            return true;
+        }
+
+        internal SharedEstimationEvaluationResult EvaluateSharedEstimationCandidate(
+            SharedEstimationCandidate candidate)
+        {
+            if (_sharedWorkerSetters is null || _sharedWorkerStart is null
+                || _sharedWorkerFitnessReader is null || _sharedWorkerModelSystem is null)
+                return CreateWorkerError(candidate, "The shared-estimation worker is not prepared.", null, null);
+            if (candidate.Parameters.Count != _sharedWorkerSetters.Count)
+                return CreateWorkerError(candidate,
+                    $"Expected {_sharedWorkerSetters.Count} parameters but received {candidate.Parameters.Count}.", null, null);
+
+            lock (this)
+            {
+                using var loopRunBus = new RunBus(ID, _ => { }, _runtime);
+                var loopRun = new Run(ID, _modelSystem, StartToExecute, _runtime,
+                    _currentWorkingDirectory, RunMode.Estimation);
+                loopRunBus.CurrentRun = loopRun;
+                try
+                {
+                    using var workingDirectoryLease = SharedEstimationWorkingDirectoryLease.Acquire(
+                        _currentWorkingDirectory);
+                    for (int i = 0; i < _sharedWorkerSetters.Count; i++)
+                        _sharedWorkerSetters[i](candidate.Parameters[i]);
+                    _sharedWorkerStart.Invoke();
+                    return new SharedEstimationEvaluationResult(
+                        candidate.RunId, candidate.BatchId, candidate.CandidateId,
+                        _sharedWorkerFitnessReader(), null, null, null);
+                }
+                catch (Exception e)
+                {
+                    while (e.InnerException is Exception inner) e = inner;
+                    Guid? elementId = null;
+                    string? moduleName = null;
+                    if (e is XTMFRuntimeException xe)
+                    {
+                        if (!Run.TryResolveModelElementForRuntimeModule(_sharedWorkerModelSystem,
+                            xe.FailingModule, out moduleName, out elementId))
+                            moduleName = xe.FailingModule?.Name;
+                    }
+                    return CreateWorkerError(candidate, e.Message, moduleName, elementId);
+                }
+                finally
+                {
+                    if (ReferenceEquals(loopRunBus.CurrentRun, loopRun))
+                        loopRunBus.CurrentRun = null;
+                }
+            }
+        }
+
+        private static SharedEstimationEvaluationResult CreateWorkerError(
+            SharedEstimationCandidate candidate, string message, string? moduleName, Guid? elementId)
+            => new(candidate.RunId, candidate.BatchId, candidate.CandidateId,
+                double.MaxValue, message, moduleName, elementId);
+
+        private (RunBus runBus, Task readerTask) CreateRunBusLocal(IRunOutputSink clientBus)
         {
             string? error = null;
             Stream? clientToRunStream = null;
@@ -140,7 +281,7 @@ public static bool CreateRunContext(XTMFRuntime runtime, string id, byte[] model
             return (runBus!, readerTask!);
         }
 
-        private (Stream clientToRunStream, Process runProcess) CreateRunBusRemote(RunServerBus clientBus)
+        private (Stream clientToRunStream, Process runProcess) CreateRunBusRemote(IRunOutputSink clientBus)
         {
             string? error = null;
             Process? runProcess = null;
@@ -161,12 +302,18 @@ public static bool CreateRunContext(XTMFRuntime runtime, string id, byte[] model
                 };
                 runProcess.EnableRaisingEvents = true;
                 runProcess.Start();
+                lock (_processSync)
+                {
+                    _runProcess = runProcess;
+                    if (_killRequested)
+                        KillProcessIfRunning(runProcess);
+                }
             });
             clientBus.StartProcessingRequestFromRun(ID, clientToRunStream!);
             return (clientToRunStream!, runProcess!);
         }
 
-        private string GetExtraDlls(RunServerBus client)
+        private string GetExtraDlls(IRunOutputSink client)
         {
             var builder = new StringBuilder();
             foreach (var dll in client.ExtraDlls)
@@ -179,7 +326,7 @@ private string GetExtraDlls(RunServerBus client)
         }
 
 
-        public void RunInNewProcess(RunServerBus client)
+        internal void RunInNewProcess(IRunOutputSink client)
         {
             // Optimisation runs always orchestrate their loop in-process; only the individual
             // model-system executions within each iteration use the out-of-process runner
@@ -190,19 +337,30 @@ public void RunInNewProcess(RunServerBus client)
                 return;
             }
             (Stream stream, Process runProcess) = CreateRunBusRemote(client);
-            using var writer = new BinaryWriter(stream, Encoding.UTF8, false);
-            // Send the commend to start a run
-            writer.Write((int)1);
-            writer.Write(ID);
-            writer.Write(_currentWorkingDirectory);
-            writer.Write(StartToExecute);
-            writer.Write((int)_runMode);
-            writer.Write(_modelSystem.LongLength);
-            writer.Write(_modelSystem);
-            runProcess.WaitForExit();
+            try
+            {
+                using var writer = new BinaryWriter(stream, Encoding.UTF8, false);
+                writer.Write((int)1);
+                writer.Write(ID);
+                writer.Write(_currentWorkingDirectory);
+                writer.Write(StartToExecute);
+                writer.Write((int)_runMode);
+                writer.Write(_modelSystem.LongLength);
+                writer.Write(_modelSystem);
+                runProcess.WaitForExit();
+            }
+            finally
+            {
+                lock (_processSync)
+                {
+                    if (ReferenceEquals(_runProcess, runProcess))
+                        _runProcess = null;
+                }
+                runProcess.Dispose();
+            }
         }
 
-        public void RunInCurrentProcess(RunServerBus client)
+        internal void RunInCurrentProcess(IRunOutputSink client)
         {
             if (_runMode == RunMode.Estimation)
             {
@@ -253,7 +411,7 @@ public void RunInCurrentProcess(RunServerBus client)
         /// validated once; each Nelder-Mead evaluation updates module values directly
         /// and re-invokes the same <see cref="IAction"/> start module.
         /// </summary>
-        private void RunEstimationLoop(RunServerBus client)
+        private void RunEstimationLoop(IRunOutputSink client)
         {
             // Build, construct, and runtime-validate the model system once.
             if (!BuildAndValidateModelSystem(out var ms, out var start, out var buildError))
@@ -314,8 +472,15 @@ private void RunEstimationLoop(RunServerBus client)
             var algorithm = algorithmConfig.CreateAlgorithm(n, lower, upper, initial, isMaximize);
 
             int iterationCount = 0;
+            int fitnessTestsThisIteration = 0;
+            int currentIteration = 1;
+            double lastReportedFitness = double.NaN;
             RunError? firstRunError = null;
             double[]? latestValues = null;
+            using var report = new EstimationEvaluationReportWriter(
+                Path.Combine(_currentWorkingDirectory, "estimation_report.csv"),
+                algorithm.Name,
+                paramEntries.Select(parameter => parameter.entry.Node.Name ?? string.Empty).ToArray());
 
             var originalDir = Directory.GetCurrentDirectory();
             // Install a lightweight RunBus so modules inside the model system can forward
@@ -323,37 +488,52 @@ private void RunEstimationLoop(RunServerBus client)
             using var loopRunBus = new RunBus(ID, msg => client.SendStatusMessage(ID, msg), _runtime);
             var loopRun = new Run(ID, _modelSystem, StartToExecute, _runtime, _currentWorkingDirectory, RunMode.Estimation);
             loopRunBus.CurrentRun = loopRun;
+            double EvaluateCandidate(double[] values)
+            {
+                if (_cancelRequested) return double.MaxValue;
+                iterationCount++;
+                fitnessTestsThisIteration++;
+                for (int i = 0; i < paramEntries.Count; i++)
+                    paramEntries[i].setter(values[i]);
+                try
+                {
+                    modelStart.Invoke();
+                }
+                catch (Exception e)
+                {
+                    while (e.InnerException is Exception inner) e = inner;
+                    Guid? elementId = null;
+                    string? moduleName = null;
+                    if (e is XTMFRuntimeException xe)
+                    {
+                        if (!Run.TryResolveModelElementForRuntimeModule(ms, xe.FailingModule, out moduleName, out elementId))
+                            moduleName = xe.FailingModule?.Name;
+                    }
+                    firstRunError = new RunError(RunErrorType.Runtime, e.Message, moduleName, e.StackTrace, elementId);
+                    return double.MaxValue;
+                }
+                latestValues = (double[])values.Clone();
+                double fitness = fitnessReader();
+                report.Write(currentIteration, values, fitness);
+                lastReportedFitness = fitness;
+                var progressValues = paramEntries
+                    .Select((p, i) => (p.nodeIndex, latestValues?[i] ?? p.entry.NullHypothesis))
+                    .ToList();
+                client.SendIterationProgress(
+                    ID, currentIteration, lastReportedFitness, fitnessTestsThisIteration, progressValues);
+                return fitness;
+            }
             try
             {
                 Directory.SetCurrentDirectory(_currentWorkingDirectory);
-                algorithm.Run(
-                    fitnessEvaluator: values =>
+                algorithm.RunBatch(
+                    fitnessEvaluator: EvaluateCandidate,
+                    batchFitnessEvaluator: values =>
                     {
-                        if (_cancelRequested) return double.MaxValue;
-                        iterationCount++;
-                        // Apply the parameter vector directly to the already-constructed modules.
-                        for (int i = 0; i < paramEntries.Count; i++)
-                            paramEntries[i].setter(values[i]);
-                        try
-                        {
-                            modelStart.Invoke();
-                        }
-                        catch (Exception e)
-                        {
-                            while (e.InnerException is Exception inner) e = inner;
-                            Guid? elementId = null;
-                            string? moduleName = null;
-                            if (e is XTMFRuntimeException xe)
-                            {
-                                if (!Run.TryResolveModelElementForRuntimeModule(ms, xe.FailingModule, out moduleName, out elementId))
-                                    moduleName = xe.FailingModule?.Name;
-                            }
-                            firstRunError = new RunError(RunErrorType.Runtime, e.Message, moduleName, e.StackTrace, elementId);
-                            return double.MaxValue;
-                        }
-                        latestValues = (double[])values.Clone();
-                        double rawFitness = fitnessReader();
-                        return rawFitness;
+                        var fitnesses = new double[values.Count];
+                        for (int i = 0; i < values.Count; i++)
+                            fitnesses[i] = EvaluateCandidate(values[i]);
+                        return fitnesses;
                     },
                     progressCallback: (iter, fitness) =>
                     {
@@ -363,7 +543,10 @@ private void RunEstimationLoop(RunServerBus client)
                         var progressValues = paramEntries
                             .Select((p, i) => (p.nodeIndex, latestValues?[i] ?? p.entry.NullHypothesis))
                             .ToList();
-                        client.SendIterationProgress(ID, iter, fitness, progressValues);
+                        client.SendIterationProgress(ID, iter, fitness, fitnessTestsThisIteration, progressValues);
+                        fitnessTestsThisIteration = 0;
+                        currentIteration = iter + 1;
+                        lastReportedFitness = fitness;
                     },
                     shouldCancel: () => _cancelRequested);
             }
@@ -397,6 +580,7 @@ private void RunEstimationLoop(RunServerBus client)
             }
 
             // algorithm.BestFitness already returns the user-facing value.
+            report.Dispose();
             client.SendStatusMessage(ID,
                 $"[Estimation] converged after {iterationCount} evaluations. " +
                 $"Best fitness = {algorithm.BestFitness:G6}. ");
@@ -413,7 +597,7 @@ private void RunEstimationLoop(RunServerBus client)
         /// same <see cref="IAction"/> start module, and reads calibration target ratios
         /// directly from the already-constructed module instances.
         /// </summary>
-        private void RunCalibrationLoop(RunServerBus client)
+        private void RunCalibrationLoop(IRunOutputSink client)
         {
             // Build, construct, and runtime-validate the model system once.
             if (!BuildAndValidateModelSystem(out var ms, out var start, out var buildError))
@@ -530,7 +714,7 @@ private void RunCalibrationLoop(RunServerBus client)
                     var calibProgressValues = paramEntries
                         .Select((p, i) => (p.nodeIndex, current[i]))
                         .ToList();
-                    client.SendIterationProgress(ID, iter + 1, maxDelta, calibProgressValues);
+                    client.SendIterationProgress(ID, iter + 1, maxDelta, 1, calibProgressValues);
 
                     if (converged) break;
                 }
@@ -581,6 +765,7 @@ private bool BuildAndValidateModelSystem(
             }
 
             if (!ModelSystem.Load(msString, _runtime, out ms, ref errorMsg)
+                || !ApplyBasicParameterOverrides(ms, ref errorMsg)
                 || !ms!.Construct(_runtime, ref errorMsg, ref elementId)
                 || !ms!.Validate(ref moduleName, ref errorMsg, ref elementId))
             {
@@ -608,6 +793,40 @@ private bool BuildAndValidateModelSystem(
             return true;
         }
 
+        private bool ApplyBasicParameterOverrides(ModelSystem modelSystem, ref string? error)
+        {
+            if (_basicParameterOverrides is null)
+                return true;
+
+            if (modelSystem.NodesByLoadIndex is null)
+            {
+                error = "Unable to apply shared-estimation parameter overrides because node indices are unavailable.";
+                return false;
+            }
+
+            foreach (var pair in _basicParameterOverrides)
+            {
+                if (!modelSystem.NodesByLoadIndex.TryGetValue(pair.Key, out var node))
+                {
+                    error = $"Shared-estimation parameter override references unknown node index {pair.Key}.";
+                    return false;
+                }
+                if (node.Type is null || !node.Type.IsGenericType
+                    || node.Type.GetGenericTypeDefinition() != typeof(BasicParameter<>)
+                    || node.Type.GetGenericArguments()[0] != typeof(string))
+                {
+                    error = $"Shared-estimation parameter override node {pair.Key} is not a BasicParameter<string>.";
+                    return false;
+                }
+                if (!node.SetParameterValue(ParameterExpression.CreateParameter(pair.Value, typeof(string)), out var setError))
+                {
+                    error = setError?.Message ?? $"Unable to apply shared-estimation override for node {pair.Key}.";
+                    return false;
+                }
+            }
+            return true;
+        }
+
         private static bool FindStart(
             ModelSystem ms,
             List<string> startPath,
diff --git a/src/XTMF2/Bus/RunServerBus.cs b/src/XTMF2/Bus/RunServerBus.cs
index 41369533..d566f5fc 100644
--- a/src/XTMF2/Bus/RunServerBus.cs
+++ b/src/XTMF2/Bus/RunServerBus.cs
@@ -20,10 +20,14 @@ You should have received a copy of the GNU General Public License
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.IO.Compression;
+using System.Security.Cryptography;
+using System.Security;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using XTMF2.Bus.Optimization;
 
 namespace XTMF2.Bus
 {
@@ -31,15 +35,28 @@ namespace XTMF2.Bus
     /// Provides communication to the host and forwards communication
     /// to the Run.
     /// </summary>
-    public sealed class RunServerBus : IDisposable
+    public sealed class RunServerBus : IDisposable, IRunOutputSink
     {
         private readonly Stream _clientHost;
         private readonly bool _owner;
         private volatile bool _exit = false;
 
-        private readonly Scheduler _runScheduler;
+        private readonly Scheduler? _runScheduler;
+        private readonly RemoteRunRegistry? _remoteRunRegistry;
+        private Func<IReadOnlyList<RunServerActivity>>? _coordinatorActivityProvider;
+        private Func<IReadOnlyList<RunServerActivity>>? _workerActivityProvider;
+        private Action? _beginDeploymentDrain;
+        private Action? _cancelDeploymentDrain;
+        private Func<bool>? _isDeploymentIdle;
+        private Func<string, bool>? _activateDeployment;
+        private readonly object _deploymentSync = new();
+        private readonly HashSet<string> _deploymentRequests = new(StringComparer.Ordinal);
         private readonly List<string> _extraDlls;
         private readonly bool _usePrivateWorkspace;
+        private readonly bool _allowDeployment;
+        private string? _stagedDeploymentRoot;
+        private string? _stagedDeploymentRequestId;
+        private bool _deploymentIdle;
 
         /// <summary>
         /// The link to the XTMFRuntime
@@ -51,6 +68,33 @@ public sealed class RunServerBus : IDisposable
         /// </summary>
         public IReadOnlyList<string> ExtraDlls => _extraDlls;
 
+        IReadOnlyList<string> IRunOutputSink.ExtraDlls => _extraDlls;
+
+        Task IRunOutputSink.StartProcessingRequestFromRun(string id, Stream clientToRunStream)
+            => StartProcessingRequestFromRun(id, clientToRunStream);
+
+        void IRunOutputSink.ModelRunFailedValidation(string runId, string? error, string? moduleName, string? elementId)
+            => ModelRunFailedValidation(runId, error, moduleName, elementId);
+
+        void IRunOutputSink.ModelRunFailed(string runId, string? message, string? stackTrace, string? moduleName, string? elementId)
+            => ModelRunFailed(runId, message, stackTrace, moduleName, elementId);
+
+        void IRunOutputSink.SendStatusMessage(string runId, string? message)
+            => SendStatusMessage(runId, message);
+
+        void IRunOutputSink.SendOptimizationResults(string runId, IReadOnlyList<(int nodeIndex, double value)> results)
+            => SendOptimizationResults(runId, results);
+
+        void IRunOutputSink.SendIterationProgress(string runId, int iteration, double fitness,
+            int fitnessTestsThisIteration, IReadOnlyList<(int nodeIndex, double value)> values)
+            => SendIterationProgress(runId, iteration, fitness, fitnessTestsThisIteration, values);
+
+        void IRunOutputSink.ModelRunComplete(string runId)
+            => ModelRunComplete(runId);
+
+        void IRunOutputSink.SendRunArtifacts(string runId, string runDirectory)
+            => SendRunArtifacts(runId, runDirectory);
+
         /// <summary>
         /// Create the bus to interact with the host.
         /// </summary>
@@ -59,14 +103,18 @@ public sealed class RunServerBus : IDisposable
         /// <param name="runtime">The XTMFRuntime to work within.</param>
         /// <param name="extraDlls">Additional DLLs that the client should load.</param>
         /// <param name="runLocal">If true, the model system will be run within the same process as the GUI.  This is only intended for debugging purposes.</param>
-        public RunServerBus(Stream serverStream, bool streamOwner, XTMFRuntime runtime, List<string>? extraDlls = null, bool runLocal = false, bool usePrivateWorkspace = false)
+        public RunServerBus(Stream serverStream, bool streamOwner, XTMFRuntime runtime, List<string>? extraDlls = null,
+            bool runLocal = false, bool usePrivateWorkspace = false, RemoteRunRegistry? remoteRunRegistry = null,
+            bool allowDeployment = false)
         {
             Runtime = runtime;
-            _runScheduler = new Scheduler(this, runLocal);
+            _remoteRunRegistry = remoteRunRegistry;
+            _runScheduler = remoteRunRegistry is null ? new Scheduler(this, runLocal) : null;
             _clientHost = serverStream;
             _owner = streamOwner;
             _extraDlls = extraDlls ?? new List<string>();
             _usePrivateWorkspace = usePrivateWorkspace;
+            _allowDeployment = allowDeployment;
         }
 
         private void Dispose(bool managed)
@@ -74,7 +122,7 @@ private void Dispose(bool managed)
             if (managed)
             {
                 GC.SuppressFinalize(this);
-                _runScheduler.Dispose();
+                _runScheduler?.Dispose();
             }
             if (_owner)
             {
@@ -101,7 +149,9 @@ private enum In
             RunModelSystem = 1,
             CancelModelRun = 2,
             KillModelRun = 3,
-            KillClient = 4
+            KillClient = 4,
+            SharedEstimationMessage = 5,
+            DeploymentMessage = 6
         }
 
         private enum Out
@@ -117,7 +167,57 @@ private enum Out
             ClientReportedStatus = 8,
             ClientOptimizationResults = 9,
             ClientIterationProgress = 10,
-            ClientRunArtifacts = 11
+            ClientRunArtifacts = 11,
+            SharedEstimationMessage = 12,
+            DeploymentMessage = 13
+        }
+
+        public event Action<object, SharedEstimationRunRequest>? SharedEstimationRunRequested;
+
+        public event Action<object, SharedEstimationCoordinatorRequest>? SharedEstimationCoordinatorRequested;
+
+        public event Action<object, SharedEstimationWorkerRegistration, bool>? SharedEstimationWorkerRequested;
+
+        public event Action<object, SharedEstimationCandidate>? SharedEstimationCandidateReceived;
+
+        public event Action<object, string, string?>? SharedEstimationCancellationRequested;
+
+        public event Action<object>? SharedEstimationJobsQueryRequested;
+
+        public event Action<object, string, SharedEstimationWorkerEndpoint, bool>? SharedEstimationCoordinatorWorkerRequested;
+
+        /// <summary>
+        /// Attach this RunServer as a worker for shared-estimation requests received from its host.
+        /// </summary>
+        public SharedEstimationWorkerSession AttachSharedEstimationWorker()
+            => new(this);
+
+        internal Scheduler.ReservationLease ReserveSharedEstimationWorker(SharedEstimationRunRequest request)
+        {
+            var reservationId = request.RunId;
+            if (!RunContext.CreateRunContext(Runtime, reservationId, request.ModelSystem,
+                    request.WorkingDirectory, request.StartToExecute, RunMode.Estimation, out var context))
+                throw new InvalidOperationException("Unable to create the shared-estimation worker queue entry.");
+            return _remoteRunRegistry is not null
+                ? _remoteRunRegistry.ReserveWorkerSlot(context, request.WorkerSlotCount)
+                : _runScheduler!.ReserveGroup(request.RunId, context, request.WorkerSlotCount);
+        }
+
+        public void SetSharedActivityProviders(
+            Func<IReadOnlyList<RunServerActivity>> coordinatorProvider,
+            Func<IReadOnlyList<RunServerActivity>> workerProvider)
+        {
+            _coordinatorActivityProvider = coordinatorProvider ?? throw new ArgumentNullException(nameof(coordinatorProvider));
+            _workerActivityProvider = workerProvider ?? throw new ArgumentNullException(nameof(workerProvider));
+        }
+
+        public void SetDeploymentGate(Action beginDrain, Action cancelDrain, Func<bool> isIdle,
+            Func<string, bool>? activateDeployment = null)
+        {
+            _beginDeploymentDrain = beginDrain ?? throw new ArgumentNullException(nameof(beginDrain));
+            _cancelDeploymentDrain = cancelDrain ?? throw new ArgumentNullException(nameof(cancelDrain));
+            _isDeploymentIdle = isIdle ?? throw new ArgumentNullException(nameof(isIdle));
+            _activateDeployment = activateDeployment;
         }
 
         /// <summary>
@@ -134,8 +234,9 @@ private void Write(Action<BinaryWriter> writeWith)
             }
         }
 
-        internal Task StartProcessingRequestFromRun(string id, Stream clientToRunStream)
+        internal Task StartProcessingRequestFromRun(string id, Stream clientToRunStream, IRunOutputSink? outputSink = null)
         {
+            var output = outputSink ?? this;
             return Task.Factory.StartNew(() =>
             {
                 // leaveOpen=false so the stream is disposed when the reader exits.
@@ -147,7 +248,9 @@ internal Task StartProcessingRequestFromRun(string id, Stream clientToRunStream)
                         switch ((Out)reader.ReadInt32())
                         {
                             case Out.Heartbeat:
-                                WriteHeartbeat(reader.ReadString());
+                                var heartbeatRunId = reader.ReadString();
+                                if (outputSink is null)
+                                    WriteHeartbeat(heartbeatRunId);
                                 break;
                             case Out.ClientErrorValidatingModelSystem:
                             {
@@ -155,11 +258,11 @@ internal Task StartProcessingRequestFromRun(string id, Stream clientToRunStream)
                                 var error = reader.ReadString();
                                 var moduleName = reader.ReadString();
                                 var elementId = reader.ReadString();
-                                ModelRunFailedValidation(runId,error, moduleName, elementId);
+                                output.ModelRunFailedValidation(runId, error, moduleName, elementId);
                                 return;
                             }
                             case Out.ClientErrorWhenRunningModelSystem:
-                                ModelRunFailed(
+                                output.ModelRunFailed(
                                     reader.ReadString(),
                                     reader.ReadString(),
                                     reader.ReadString(),
@@ -167,10 +270,10 @@ internal Task StartProcessingRequestFromRun(string id, Stream clientToRunStream)
                                     reader.ReadString());
                                 return;
                             case Out.ClientReportedStatus:
-                                SendStatusMessage(reader.ReadString(), reader.ReadString());
+                                output.SendStatusMessage(reader.ReadString(), reader.ReadString());
                                 break;
                             case Out.ClientFinishedModelSystem:
-                                ModelRunComplete(reader.ReadString());
+                                output.ModelRunComplete(reader.ReadString());
                                 return;
                             case Out.ProgressUpdate:
                                 SendProgressUpdate(reader.ReadString(), reader.ReadSingle());
@@ -182,7 +285,7 @@ internal Task StartProcessingRequestFromRun(string id, Stream clientToRunStream)
                                     var results = new List<(int nodeIndex, double value)>(count);
                                     for (int i = 0; i < count; i++)
                                         results.Add((reader.ReadInt32(), reader.ReadDouble()));
-                                    SendOptimizationResults(runId, results);
+                                    output.SendOptimizationResults(runId, results);
                                 }
                                 break;
                             case Out.ClientIterationProgress:
@@ -190,11 +293,12 @@ internal Task StartProcessingRequestFromRun(string id, Stream clientToRunStream)
                                     var runId = reader.ReadString();
                                     int iteration = reader.ReadInt32();
                                     double fitness = reader.ReadDouble();
+                                    int fitnessTestsThisIteration = reader.ReadInt32();
                                     int count = reader.ReadInt32();
                                     var values = new (int nodeIndex, double value)[count];
                                     for (int i = 0; i < count; i++)
                                         values[i] = (reader.ReadInt32(), reader.ReadDouble());
-                                    SendIterationProgress(runId, iteration, fitness, values);
+                                    output.SendIterationProgress(runId, iteration, fitness, fitnessTestsThisIteration, values);
                                 }
                                 break;
                             default:
@@ -288,6 +392,49 @@ internal void SendStatusMessage(string runId, string? message)
             });
         }
 
+        internal void SendSharedEstimationResult(SharedEstimationEvaluationResult result)
+            => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteResult(writer, result));
+
+        public void SendSharedEstimationProgress(SharedEstimationProgress progress)
+            => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteProgress(writer, progress));
+
+        public void SendSharedEstimationCompletion(SharedEstimationCompletion completion)
+            => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteCompletion(writer, completion));
+
+        public void SendSharedEstimationStatus(SharedEstimationStatus status)
+            => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteStatus(writer, status));
+
+        internal void SendSharedEstimationWorkerReady(SharedEstimationWorkerReady readiness)
+            => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteWorkerReady(writer, readiness));
+
+        public void SendSharedEstimationJobSnapshots(IReadOnlyList<SharedEstimationJobSnapshot> snapshots)
+            => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteJobSnapshots(writer, snapshots));
+
+        public void SendServerActivitySnapshots(string requestId, IReadOnlyList<RunServerActivity> activities)
+            => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteServerActivitySnapshots(writer, requestId, activities));
+
+        public void SendRemoteRunSnapshots(IReadOnlyList<RemoteRunSnapshot> snapshots)
+            => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteRemoteRunSnapshots(writer, snapshots));
+
+        public void SendRemoteRunArtifacts(string runId, byte[]? archive, string? error)
+            => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteRemoteRunArtifacts(writer, runId, archive, error));
+
+        public void SendRemoteRunDeletionResponse(RemoteRunDeletionResponse response)
+            => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteRemoteRunDeleted(writer, response));
+
+        public void SendSharedEstimationWorkerControlAcknowledgement(
+            SharedEstimationWorkerControlAcknowledgement acknowledgement)
+            => WriteSharedEstimation(writer => SharedEstimationProtocol.WriteWorkerControlAcknowledgement(writer, acknowledgement));
+
+        private void WriteSharedEstimation(Action<BinaryWriter> writePayload)
+        {
+            Write(writer =>
+            {
+                writer.Write((int)Out.SharedEstimationMessage);
+                writePayload(writer);
+            });
+        }
+
         /// <summary>
         /// Sends the final optimised parameter values to the host so the user can
         /// choose whether to apply them back to the model system.
@@ -311,7 +458,7 @@ internal void SendOptimizationResults(string runId, IReadOnlyList<(int nodeIndex
         /// Sends the per-iteration parameter snapshot to the host for live display.
         /// </summary>
         internal void SendIterationProgress(string runId, int iteration, double fitness,
-            IReadOnlyList<(int nodeIndex, double value)> values)
+            int fitnessTestsThisIteration, IReadOnlyList<(int nodeIndex, double value)> values)
         {
             Write((writer) =>
             {
@@ -319,6 +466,7 @@ internal void SendIterationProgress(string runId, int iteration, double fitness,
                 writer.Write(runId);
                 writer.Write(iteration);
                 writer.Write(fitness);
+                writer.Write(fitnessTestsThisIteration);
                 writer.Write(values.Count);
                 foreach (var (idx, val) in values)
                 {
@@ -405,13 +553,33 @@ public void ProcessRequests()
                                 var cwd = _usePrivateWorkspace ? CreateRunDirectory(id) : requestedDirectory;
                                 var start = reader.ReadString();
                                 var runMode = (RunMode)reader.ReadInt32();
+                                var runName = reader.ReadString();
+                                var projectId = Guid.TryParse(reader.ReadString(), out var parsedProjectId)
+                                    ? parsedProjectId
+                                    : (Guid?)null;
+                                var modelSystemId = Guid.TryParse(reader.ReadString(), out var parsedModelSystemId)
+                                    ? parsedModelSystemId
+                                    : (Guid?)null;
+                                var ownerUserId = Guid.TryParse(reader.ReadString(), out var parsedOwnerUserId)
+                                    ? parsedOwnerUserId
+                                    : (Guid?)null;
                                 var msSize = (int)reader.ReadInt64();
                                 Console.WriteLine($"RunServer model system run issued: {id} (start '{start}', mode {runMode}, {msSize} bytes)");
                                 Console.Out.Flush();
                                 using var mem = CreateMemoryStreamLoadingFrom(reader.BaseStream, msSize);
-                                if (RunContext.CreateRunContext(Runtime, id, mem.ToArray(), cwd, start, runMode, out var context))
+                                var modelSystem = mem.ToArray();
+                                if (RunContext.CreateRunContext(Runtime, id, modelSystem, cwd, start, runMode, out var context))
                                 {
-                                    _runScheduler.Run(context);
+                                    if (_remoteRunRegistry is not null)
+                                    {
+                                        if (!_remoteRunRegistry.Submit(this, context, runName, runMode, cwd, start,
+                                            modelSystem, projectId, modelSystemId, ownerUserId))
+                                            ModelRunFailed(id, "A run with this ID is already registered.", string.Empty);
+                                    }
+                                    else
+                                    {
+                                        _runScheduler!.Run(context);
+                                    }
                                 }
                                 else
                                 {
@@ -426,7 +594,135 @@ public void ProcessRequests()
                         case In.CancelModelRun:
                             {
                                 var runId = reader.ReadString();
-                                _runScheduler.RequestCancel(runId);
+                                if (_remoteRunRegistry is not null)
+                                    _remoteRunRegistry.Cancel(runId);
+                                else
+                                    _runScheduler!.RequestCancel(runId);
+                            }
+                            break;
+                        case In.KillModelRun:
+                            {
+                                var runId = reader.ReadString();
+                                if (_remoteRunRegistry is not null)
+                                    _remoteRunRegistry.Kill(runId);
+                                else
+                                    _runScheduler!.Kill(runId);
+                            }
+                            break;
+                        case In.SharedEstimationMessage:
+                            {
+                                var (_, messageType) = SharedEstimationProtocol.ReadHeader(reader);
+                                switch (messageType)
+                                {
+                                    case SharedEstimationMessageType.StartCoordinator:
+                                        SharedEstimationCoordinatorRequested?.Invoke(this,
+                                            SharedEstimationProtocol.ReadCoordinatorRequestPayload(reader));
+                                        break;
+                                    case SharedEstimationMessageType.StartRun:
+                                        SharedEstimationRunRequested?.Invoke(this,
+                                            SharedEstimationProtocol.ReadRunRequestPayload(reader));
+                                        break;
+                                    case SharedEstimationMessageType.AddWorker:
+                                        SharedEstimationWorkerRequested?.Invoke(this,
+                                            SharedEstimationProtocol.ReadWorkerRegistrationPayload(reader), false);
+                                        break;
+                                    case SharedEstimationMessageType.RemoveWorker:
+                                        SharedEstimationWorkerRequested?.Invoke(this,
+                                            SharedEstimationProtocol.ReadWorkerRegistrationPayload(reader), true);
+                                        break;
+                                    case SharedEstimationMessageType.EvaluateCandidate:
+                                        SharedEstimationCandidateReceived?.Invoke(this,
+                                            SharedEstimationProtocol.ReadCandidatePayload(reader));
+                                        break;
+                                    case SharedEstimationMessageType.Cancel:
+                                        var cancellation = SharedEstimationProtocol.ReadCancelPayload(reader);
+                                        if (_remoteRunRegistry is not null)
+                                            _remoteRunRegistry.Cancel(cancellation.RunId);
+                                        else
+                                            _runScheduler?.RequestCancel(cancellation.RunId);
+                                        SharedEstimationCancellationRequested?.Invoke(this,
+                                            cancellation.RunId, cancellation.Reason);
+                                        break;
+                                    case SharedEstimationMessageType.QueryJobs:
+                                        SharedEstimationJobsQueryRequested?.Invoke(this);
+                                        break;
+                                    case SharedEstimationMessageType.QueryRemoteRuns:
+                                        if (_remoteRunRegistry is not null)
+                                        {
+                                            _remoteRunRegistry.Attach(this);
+                                            SendRemoteRunSnapshots(_remoteRunRegistry.GetSnapshots());
+                                        }
+                                        break;
+                                    case SharedEstimationMessageType.QueryServerActivity:
+                                        var requestId = SharedEstimationProtocol.ReadQueryServerActivityPayload(reader);
+                                        SendServerActivitySnapshots(requestId, GetServerActivity());
+                                        break;
+                                    case SharedEstimationMessageType.GetRemoteRunArtifacts:
+                                        {
+                                            var runId = SharedEstimationProtocol.ReadGetRemoteRunArtifactsPayload(reader);
+                                            byte[]? archive = null;
+                                            var found = _remoteRunRegistry is not null &&
+                                                _remoteRunRegistry.TryReadArtifacts(runId, out archive);
+                                            SendRemoteRunArtifacts(runId, found ? archive : null,
+                                                found ? null : "No unacknowledged artifact archive is available for this run.");
+                                        }
+                                        break;
+                                    case SharedEstimationMessageType.AcknowledgeRemoteRun:
+                                        _remoteRunRegistry?.AcknowledgeReceived(
+                                            SharedEstimationProtocol.ReadAcknowledgeRemoteRunPayload(reader));
+                                        break;
+                                    case SharedEstimationMessageType.DeleteRemoteRun:
+                                        {
+                                            var request = SharedEstimationProtocol.ReadDeleteRemoteRunPayload(reader);
+                                            string? error = null;
+                                            var deleted = _remoteRunRegistry is not null &&
+                                                _remoteRunRegistry.DeleteRun(request.RunId, out error);
+                                            error ??= _remoteRunRegistry is null
+                                                ? "Remote run retention is unavailable on this RunServer."
+                                                : null;
+                                            SendRemoteRunDeletionResponse(new RemoteRunDeletionResponse(
+                                                request.RequestId, request.RunId, deleted, error));
+                                        }
+                                        break;
+                                    case SharedEstimationMessageType.AddCoordinatorWorker:
+                                        var addWorker = SharedEstimationProtocol.ReadCoordinatorWorkerRequestPayload(reader);
+                                        SharedEstimationCoordinatorWorkerRequested?.Invoke(this,
+                                            addWorker.RunId, addWorker.Worker, false);
+                                        break;
+                                    case SharedEstimationMessageType.RemoveCoordinatorWorker:
+                                        var removeWorker = SharedEstimationProtocol.ReadCoordinatorWorkerRequestPayload(reader);
+                                        SharedEstimationCoordinatorWorkerRequested?.Invoke(this,
+                                            removeWorker.RunId, removeWorker.Worker, true);
+                                        break;
+                                    default:
+                                        throw new InvalidDataException(
+                                            $"Unexpected shared estimation message to RunServer: {messageType}.");
+                                }
+                            }
+                            break;
+                        case In.DeploymentMessage:
+                            {
+                                if (!_allowDeployment)
+                                    throw new SecurityException("Deployment operations require an authenticated connection.");
+
+                                var (_, messageType) = DeploymentProtocol.ReadHeader(reader);
+                                switch (messageType)
+                                {
+                                    case DeploymentMessageType.BeginDrain:
+                                        BeginDeploymentDrain(DeploymentProtocol.ReadRequestId(reader));
+                                        break;
+                                    case DeploymentMessageType.CancelDrain:
+                                        CancelDeploymentDrain(DeploymentProtocol.ReadRequestId(reader));
+                                        break;
+                                    case DeploymentMessageType.DeployArchive:
+                                        StageDeploymentArchive(DeploymentProtocol.ReadDeployArchive(reader));
+                                        break;
+                                    case DeploymentMessageType.ActivateDeployment:
+                                        ActivateDeployment(DeploymentProtocol.ReadRequestId(reader));
+                                        break;
+                                    default:
+                                        throw new InvalidDataException($"Unexpected deployment message from host: {messageType}.");
+                                }
                             }
                             break;
                         // failsafe
@@ -445,6 +741,239 @@ public void ProcessRequests()
             }
         }
 
+        private IReadOnlyList<RunServerActivity> GetServerActivity()
+        {
+            var activities = new List<RunServerActivity>();
+            if (_remoteRunRegistry is not null)
+            {
+                activities.AddRange(_remoteRunRegistry.GetActiveActivities());
+            }
+            else if (_runScheduler is not null)
+            {
+                foreach (var item in _runScheduler.GetInventory())
+                    activities.Add(new RunServerActivity(item.Context.ID,
+                        item.IsReservation ? "Shared estimation worker" : item.Context.StartToExecute,
+                        item.IsReservation ? "Shared estimation worker" : item.Context.Mode.ToString(),
+                        item.IsRunning ? RunServerActivityState.Running : RunServerActivityState.Queued,
+                        item.IsReservation
+                            ? item.IsRunning ? "Worker has the RunServer execution slot." : "Waiting in the RunServer queue."
+                            : item.IsRunning ? "Running" : "Queued",
+                        item.QueuePosition, ActiveWorkers: item.IsReservation && item.IsRunning ? 1 : 0));
+            }
+
+            if (_coordinatorActivityProvider is not null)
+                activities.AddRange(_coordinatorActivityProvider());
+            if (_workerActivityProvider is not null)
+            {
+                var queuedWorkerRunIds = activities
+                    .Where(activity => activity.Kind == "Shared estimation worker")
+                    .Select(activity => activity.RunId)
+                    .ToHashSet(StringComparer.Ordinal);
+                activities.AddRange(_workerActivityProvider()
+                    .Where(activity => !queuedWorkerRunIds.Contains(activity.RunId)));
+            }
+            return activities;
+        }
+
+        private void BeginDeploymentDrain(string requestId)
+        {
+            if (!DeploymentProtocol.IsValidRequestId(requestId))
+                throw new InvalidDataException("Invalid deployment request ID.");
+
+            Console.WriteLine($"Deployment queued: {requestId}. Waiting for active RunServer work to finish.");
+            Console.Out.Flush();
+            lock (_deploymentSync)
+            {
+                if (_deploymentRequests.Count != 0)
+                {
+                    SendDeploymentFailure(requestId, "Another deployment is already in progress.");
+                    return;
+                }
+                if (!_deploymentRequests.Add(requestId))
+                    return;
+                _deploymentIdle = false;
+                _stagedDeploymentRoot = null;
+                _stagedDeploymentRequestId = null;
+            }
+
+            try
+            {
+                var beginDrain = _beginDeploymentDrain ??
+                    (_runScheduler is null ? null : new Action(_runScheduler.BeginDrain));
+                beginDrain?.Invoke();
+                SendDeploymentStatus(new RunServerDrainStatus(requestId, RunServerDrainState.Draining,
+                    0, 0, "RunServer is draining existing work."));
+                _ = Task.Run(() => CompleteDeploymentDrainAsync(requestId));
+            }
+            catch (Exception exception)
+            {
+                SendDeploymentFailure(requestId, exception.Message);
+            }
+        }
+
+        private void CancelDeploymentDrain(string requestId)
+        {
+            if (!DeploymentProtocol.IsValidRequestId(requestId))
+                throw new InvalidDataException("Invalid deployment request ID.");
+
+            lock (_deploymentSync)
+            {
+                if (!_deploymentRequests.Contains(requestId))
+                    return;
+            }
+            _cancelDeploymentDrain?.Invoke();
+            lock (_deploymentSync)
+            {
+                _deploymentRequests.Remove(requestId);
+                _deploymentIdle = false;
+                _stagedDeploymentRoot = null;
+                _stagedDeploymentRequestId = null;
+            }
+            SendDeploymentStatus(new RunServerDrainStatus(requestId, RunServerDrainState.Cancelled,
+                0, 0, "RunServer deployment drain cancelled."));
+        }
+
+        private async Task CompleteDeploymentDrainAsync(string requestId)
+        {
+            while (true)
+            {
+                bool stillActive;
+                lock (_deploymentSync)
+                    stillActive = _deploymentRequests.Contains(requestId);
+                if (!stillActive)
+                    return;
+
+                var activities = GetServerActivity();
+                var activeCount = activities.Count(activity => activity.State == RunServerActivityState.Running);
+                var queuedCount = activities.Count(activity => activity.State == RunServerActivityState.Queued);
+                if ((_isDeploymentIdle?.Invoke() ?? _runScheduler?.IsIdle ?? true) && activities.Count == 0)
+                {
+                    SendDeploymentStatus(new RunServerDrainStatus(requestId, RunServerDrainState.Idle,
+                        0, 0, "RunServer is idle and ready for deployment."));
+                    lock (_deploymentSync)
+                        _deploymentIdle = true;
+                    SendDeploymentCompleted(new RunServerDrainStatus(requestId, RunServerDrainState.Idle,
+                        0, 0, "RunServer is idle and ready for deployment."));
+                    return;
+                }
+
+                SendDeploymentStatus(new RunServerDrainStatus(requestId, RunServerDrainState.Draining,
+                    activeCount, queuedCount, "Waiting for existing RunServer work to finish."));
+                await Task.Delay(250).ConfigureAwait(false);
+            }
+        }
+
+        private void SendDeploymentStatus(RunServerDrainStatus status)
+            => Write(writer =>
+            {
+                writer.Write((int)Out.DeploymentMessage);
+                DeploymentProtocol.WriteDrainStatus(writer, status);
+            });
+
+        private void SendDeploymentFailure(string requestId, string message)
+            => Write(writer =>
+            {
+                writer.Write((int)Out.DeploymentMessage);
+                DeploymentProtocol.WriteDeploymentFailed(writer, requestId, message);
+            });
+
+        private void SendDeploymentCompleted(RunServerDrainStatus status)
+            => Write(writer =>
+            {
+                writer.Write((int)Out.DeploymentMessage);
+                DeploymentProtocol.WriteDrainCompleted(writer, status);
+            });
+
+        private void StageDeploymentArchive((string RequestId, byte[] Archive, string Sha256) deployment)
+        {
+            if (!DeploymentProtocol.IsValidRequestId(deployment.RequestId))
+                throw new InvalidDataException("Invalid deployment request ID.");
+
+            lock (_deploymentSync)
+            {
+                if (!_deploymentRequests.Contains(deployment.RequestId) || !_deploymentIdle)
+                {
+                    SendDeploymentFailure(deployment.RequestId,
+                        "Deployment archive received before the matching drain completed.");
+                    return;
+                }
+            }
+
+            var actualHash = Convert.ToHexString(SHA256.HashData(deployment.Archive));
+            if (!string.Equals(actualHash, deployment.Sha256, StringComparison.OrdinalIgnoreCase))
+            {
+                SendDeploymentFailure(deployment.RequestId, "Deployment archive hash verification failed.");
+                return;
+            }
+
+            try
+            {
+                using var archiveStream = new MemoryStream(deployment.Archive, writable: false);
+                using var archive = new ZipArchive(archiveStream, ZipArchiveMode.Read, leaveOpen: false);
+                if (archive.Entries.Count > DeploymentProtocol.MaxArchiveEntries)
+                    throw new InvalidDataException("Deployment archive contains too many entries.");
+                long expandedBytes = 0;
+                foreach (var entry in archive.Entries)
+                {
+                    if (Path.IsPathRooted(entry.FullName) || entry.FullName.Contains("..", StringComparison.Ordinal))
+                        throw new InvalidDataException("Deployment archive contains an unsafe path.");
+                    if (entry.Length < 0 || entry.Length > DeploymentProtocol.MaxArchiveEntryBytes ||
+                        (expandedBytes += entry.Length) > DeploymentProtocol.MaxExpandedArchiveBytes)
+                        throw new InvalidDataException("Deployment archive expands beyond the allowed limit.");
+                }
+
+                var stagingRoot = Path.Combine(Path.GetTempPath(), "XTMF2", "Deployments", deployment.RequestId);
+                Directory.CreateDirectory(stagingRoot);
+                var archivePath = Path.Combine(stagingRoot, "deployment.zip");
+                File.WriteAllBytes(archivePath, deployment.Archive);
+                lock (_deploymentSync)
+                {
+                    _stagedDeploymentRoot = stagingRoot;
+                    _stagedDeploymentRequestId = deployment.RequestId;
+                }
+                Console.WriteLine($"Deployment staged: {deployment.RequestId}. Archive hash verified.");
+                Console.Out.Flush();
+                SendDeploymentStaged(new RunServerDrainStatus(deployment.RequestId, RunServerDrainState.Staged,
+                    0, 0, "Deployment archive staged and hash verified."));
+            }
+            catch (Exception exception) when (exception is IOException or InvalidDataException or UnauthorizedAccessException)
+            {
+                SendDeploymentFailure(deployment.RequestId, exception.Message);
+            }
+        }
+
+        private void SendDeploymentStaged(RunServerDrainStatus status)
+            => Write(writer =>
+            {
+                writer.Write((int)Out.DeploymentMessage);
+                DeploymentProtocol.WriteDeploymentStaged(writer, status);
+            });
+
+        private void ActivateDeployment(string requestId)
+        {
+            if (!DeploymentProtocol.IsValidRequestId(requestId))
+                throw new InvalidDataException("Invalid deployment request ID.");
+
+            string? stagingRoot;
+            lock (_deploymentSync)
+            {
+                if (!string.Equals(_stagedDeploymentRequestId, requestId, StringComparison.Ordinal))
+                {
+                    SendDeploymentFailure(requestId, "Deployment activation does not match the staged archive.");
+                    return;
+                }
+                stagingRoot = _stagedDeploymentRoot;
+            }
+            if (stagingRoot is null || !Directory.Exists(stagingRoot))
+            {
+                SendDeploymentFailure(requestId, "No verified deployment archive is staged.");
+                return;
+            }
+
+            if (!(_activateDeployment?.Invoke(stagingRoot) ?? false))
+                SendDeploymentFailure(requestId, "The RunServer could not activate the staged deployment.");
+        }
+
         private static string CreateRunDirectory(string runId)
         {
             var directory = Path.Combine(Path.GetTempPath(), "XTMF2", "Runs", runId);
diff --git a/src/XTMF2/Bus/Scheduler.cs b/src/XTMF2/Bus/Scheduler.cs
index 29b707b9..bf6c8d38 100644
--- a/src/XTMF2/Bus/Scheduler.cs
+++ b/src/XTMF2/Bus/Scheduler.cs
@@ -29,6 +29,8 @@ You should have received a copy of the GNU General Public License
 */
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -39,10 +41,192 @@ namespace XTMF2.Bus
     /// </summary>
     internal sealed class Scheduler : IDisposable
     {
-        private readonly ConcurrentQueue<RunContext> _ToRun = new ConcurrentQueue<RunContext>();
-        private readonly RunServerBus _Bus;
-        private readonly CancellationTokenSource _CancelExecutionEngine;
+        internal sealed class Reservation : IDisposable
+        {
+            private readonly object _sync = new();
+            private readonly TaskCompletionSource _started = new(TaskCreationOptions.RunContinuationsAsynchronously);
+            private readonly TaskCompletionSource _released = new(TaskCreationOptions.RunContinuationsAsynchronously);
+            private Action? _cancellationHandler;
+            private bool _cancellationRequested;
+
+            public Task Started => _started.Task;
+            internal bool IsReleased => _released.Task.IsCompleted;
+            internal Task Released => _released.Task;
+
+            internal bool TryStart()
+            {
+                if (IsReleased)
+                    return false;
+                _started.TrySetResult();
+                return true;
+            }
+
+            internal void SetCancellationHandler(Action handler)
+            {
+                ArgumentNullException.ThrowIfNull(handler);
+                bool invoke;
+                lock (_sync)
+                {
+                    _cancellationHandler = handler;
+                    invoke = _cancellationRequested;
+                }
+                if (invoke)
+                    handler();
+            }
+
+            internal void RequestCancellation()
+            {
+                Action? handler;
+                lock (_sync)
+                {
+                    _cancellationRequested = true;
+                    handler = _cancellationHandler;
+                }
+                if (handler is null)
+                    Dispose();
+                else
+                    handler();
+            }
+
+            public void Dispose()
+            {
+                lock (_sync)
+                    _cancellationHandler = null;
+                _released.TrySetResult();
+                _started.TrySetCanceled();
+            }
+        }
+
+        internal sealed class ReservationLease : IDisposable
+        {
+            private readonly ReservationGroup _group;
+            private Action? _cancellationHandler;
+            private bool _disposed;
+
+            internal ReservationLease(ReservationGroup group) => _group = group;
+
+            internal Task Started => _group.Started;
+
+            internal void SetCancellationHandler(Action handler)
+            {
+                ArgumentNullException.ThrowIfNull(handler);
+                _group.SetCancellationHandler(this, handler);
+            }
+
+            internal void CancelGroup() => _group.Cancel();
+
+            public void Dispose()
+            {
+                if (_disposed) return;
+                _disposed = true;
+                _group.Release(this);
+            }
+
+            internal void InvokeCancellationHandler() => _cancellationHandler?.Invoke();
+
+            internal void SetHandler(Action handler) => _cancellationHandler = handler;
+        }
+
+        internal sealed class ReservationGroup
+        {
+            private readonly object _sync = new();
+            private readonly Reservation _reservation;
+            private readonly Action _completed;
+            private readonly HashSet<ReservationLease> _leases = [];
+            private int _expectedSlotCount;
+            private int _joinedSlotCount;
+            private bool _cancelled;
+            private bool _released;
+
+            internal ReservationGroup(Reservation reservation, int expectedSlotCount, Action completed)
+            {
+                _reservation = reservation;
+                _expectedSlotCount = expectedSlotCount;
+                _completed = completed;
+                _reservation.SetCancellationHandler(Cancel);
+            }
+
+            internal Task Started => _reservation.Started;
+
+            internal ReservationLease Join(int expectedSlotCount)
+            {
+                lock (_sync)
+                {
+                    if (_released || _cancelled)
+                        throw new InvalidOperationException("The shared estimation scheduler task is no longer active.");
+                    _expectedSlotCount = Math.Max(_expectedSlotCount, expectedSlotCount);
+                    _joinedSlotCount++;
+                    var lease = new ReservationLease(this);
+                    _leases.Add(lease);
+                    return lease;
+                }
+            }
+
+            internal void SetCancellationHandler(ReservationLease lease, Action handler)
+            {
+                bool invoke;
+                lock (_sync)
+                {
+                    lease.SetHandler(handler);
+                    invoke = _cancelled;
+                }
+                if (invoke)
+                    handler();
+            }
+
+            internal void Release(ReservationLease lease)
+            {
+                bool complete;
+                lock (_sync)
+                {
+                    _leases.Remove(lease);
+                    complete = !_released && _leases.Count == 0
+                        && (_cancelled || _joinedSlotCount >= _expectedSlotCount);
+                    if (complete)
+                        _released = true;
+                }
+                if (complete)
+                    Complete();
+            }
+
+            internal void Cancel()
+            {
+                Action[] handlers;
+                bool complete;
+                lock (_sync)
+                {
+                    _cancelled = true;
+                    handlers = _leases.Select(lease => (Action?)lease.InvokeCancellationHandler)
+                        .Where(handler => handler is not null)
+                        .Cast<Action>()
+                        .ToArray();
+                    complete = !_released && _leases.Count == 0;
+                    if (complete)
+                        _released = true;
+                }
+                foreach (var handler in handlers)
+                    handler();
+                if (complete)
+                    Complete();
+            }
+
+            private void Complete()
+            {
+                _reservation.Dispose();
+                _completed();
+            }
+        }
+
+        private readonly ConcurrentQueue<ScheduledWork> _ToRun = new();
+        private readonly object _inventorySync = new();
+        private readonly IRunOutputSink? _DefaultSink;
+        private readonly CancellationTokenSource _CancelExecutionEngine = new();
         private readonly SemaphoreSlim _RunsToGo = new SemaphoreSlim(0);
+        private readonly Dictionary<string, ReservationGroup> _reservationGroups = new(StringComparer.Ordinal);
+        private Reservation? _currentReservation;
+        private bool _acceptingWork = true;
+
+        private readonly record struct ScheduledWork(RunContext Context, IRunOutputSink? Sink, Reservation? Reservation);
 
         /// <summary>
         /// The currently executing RunContext.
@@ -50,14 +234,74 @@ internal sealed class Scheduler : IDisposable
         /// </summary>
         public RunContext? Current { get; private set; }
 
+        internal bool IsAcceptingWork
+        {
+            get
+            {
+                lock (_inventorySync)
+                    return _acceptingWork;
+            }
+        }
+
+        internal void BeginDrain()
+        {
+            lock (_inventorySync)
+                _acceptingWork = false;
+        }
+
+        internal void EndDrain()
+        {
+            lock (_inventorySync)
+                _acceptingWork = true;
+        }
+
+        internal bool IsIdle
+        {
+            get
+            {
+                lock (_inventorySync)
+                    return Current is null && !_ToRun.Any(work => work.Reservation?.IsReleased != true);
+            }
+        }
+
+        internal IReadOnlyList<(RunContext Context, bool IsRunning, int QueuePosition, bool IsReservation)> GetInventory()
+        {
+            lock (_inventorySync)
+            {
+                var current = Current;
+                var queued = _ToRun.ToArray().Where(work => work.Reservation?.IsReleased != true).ToArray();
+                var result = new List<(RunContext Context, bool IsRunning, int QueuePosition, bool IsReservation)>(queued.Length + 1);
+                if (current is not null)
+                    result.Add((current, true, 0, _currentReservation is not null));
+
+                var queuePosition = 0;
+                foreach (var work in queued)
+                {
+                    if (current is not null && ReferenceEquals(work.Context, current))
+                        continue;
+                    result.Add((work.Context, false, ++queuePosition, work.Reservation is not null));
+                }
+                return result;
+            }
+        }
+
         /// <summary>
         /// Create a new Scheduler to process the given client bus.
         /// </summary>
         /// <param name="bus">The bus to listen to.</param>
-        public Scheduler(RunServerBus bus, bool runLocal)
+        public Scheduler(IRunOutputSink bus, bool runLocal)
+        {
+            _DefaultSink = bus;
+            Start(runLocal);
+        }
+
+        internal Scheduler(bool runLocal)
+        {
+            Start(runLocal);
+        }
+
+        private void Start(bool runLocal)
         {
-            _Bus = bus;
-            _CancelExecutionEngine = new CancellationTokenSource();
             var token = _CancelExecutionEngine.Token;
             Task.Factory.StartNew(() =>
             {
@@ -65,32 +309,80 @@ public Scheduler(RunServerBus bus, bool runLocal)
                 {
                     try
                     {
-                        Current = null;
                         _RunsToGo.Wait(token);
                         if (token.IsCancellationRequested)
                         {
                             return;
                         }
-                        if (_ToRun.TryDequeue(out var context))
+                        ScheduledWork work;
+                        bool hasWork;
+                        lock (_inventorySync)
                         {
+                            Current = null;
+                            hasWork = _ToRun.TryDequeue(out work);
+                            while (hasWork && work.Reservation?.IsReleased == true)
+                                hasWork = _ToRun.TryDequeue(out work);
+                            if (hasWork)
+                            {
+                                Current = work.Context;
+                                _currentReservation = work.Reservation;
+                            }
+                        }
+                        if (hasWork)
+                        {
+                            if (work.Reservation is { } reservation)
+                            {
+                                try
+                                {
+                                    if (reservation.TryStart())
+                                        reservation.Released.Wait(token);
+                                }
+                                finally
+                                {
+                                    lock (_inventorySync)
+                                    {
+                                        if (ReferenceEquals(Current, work.Context))
+                                        {
+                                            Current = null;
+                                            _currentReservation = null;
+                                        }
+                                    }
+                                }
+                                continue;
+                            }
                             try
                             {
-                                Current = context;
+                                var context = work.Context;
+                                var sink = work.Sink!;
                                 Console.WriteLine($"RunServer model system run started processing: {context.ID}");
                                 Console.Out.Flush();
                                 if (runLocal)
                                 {
-                                    context.RunInCurrentProcess(_Bus);
+                                    context.RunInCurrentProcess(sink);
                                 }
                                 else
                                 {
-                                    context.RunInNewProcess(_Bus);
+                                    context.RunInNewProcess(sink);
                                 }
-                                _Bus.SendRunArtifacts(context.ID, context.WorkingDirectory);
+                                if (context.KillRequested)
+                                    sink.ModelRunFailed(context.ID, "Run stopped from RunServer Activity window.", string.Empty);
+                                else
+                                    sink.SendRunArtifacts(context.ID, context.WorkingDirectory);
                             }
                             catch (Exception e)
                             {
-                                _Bus.ModelRunFailed(context.ID, e.Message, e.StackTrace, null, null);
+                                work.Sink!.ModelRunFailed(work.Context.ID, e.Message, e.StackTrace, null, null);
+                            }
+                            finally
+                            {
+                                lock (_inventorySync)
+                                {
+                                    if (ReferenceEquals(Current, work.Context))
+                                    {
+                                        Current = null;
+                                        _currentReservation = null;
+                                    }
+                                }
                             }
                         }
                     }
@@ -137,8 +429,69 @@ internal void Run(RunContext context)
             {
                 throw new ArgumentNullException(nameof(context));
             }
-            _ToRun.Enqueue(context);
-            _RunsToGo.Release();
+            if (_DefaultSink is null)
+                throw new InvalidOperationException("A run output sink is required.");
+            Run(context, _DefaultSink);
+        }
+
+        internal void Run(RunContext context, IRunOutputSink sink)
+        {
+            ArgumentNullException.ThrowIfNull(context);
+            ArgumentNullException.ThrowIfNull(sink);
+            lock (_inventorySync)
+            {
+                if (!_acceptingWork)
+                    throw new InvalidOperationException("The RunServer is draining for deployment and is not accepting new work.");
+                _ToRun.Enqueue(new ScheduledWork(context, sink, null));
+                _RunsToGo.Release();
+            }
+        }
+
+        internal Reservation Reserve(RunContext context)
+        {
+            ArgumentNullException.ThrowIfNull(context);
+            var reservation = new Reservation();
+            lock (_inventorySync)
+            {
+                if (!_acceptingWork)
+                    throw new InvalidOperationException("The RunServer is draining for deployment and is not accepting new work.");
+                _ToRun.Enqueue(new ScheduledWork(context, null, reservation));
+                _RunsToGo.Release();
+            }
+            return reservation;
+        }
+
+        internal ReservationLease ReserveGroup(string groupId, RunContext context, int expectedSlotCount)
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(groupId);
+            if (expectedSlotCount < 1)
+                throw new ArgumentOutOfRangeException(nameof(expectedSlotCount));
+
+            lock (_inventorySync)
+            {
+                if (!_acceptingWork)
+                    throw new InvalidOperationException("The RunServer is draining for deployment and is not accepting new work.");
+                if (_reservationGroups.TryGetValue(groupId, out var existing))
+                    return existing.Join(expectedSlotCount);
+
+                var reservation = new Reservation();
+                ReservationGroup? group = null;
+                group = new ReservationGroup(reservation, expectedSlotCount,
+                    () => RemoveReservationGroup(groupId, group!));
+                _reservationGroups.Add(groupId, group);
+                _ToRun.Enqueue(new ScheduledWork(context, null, reservation));
+                _RunsToGo.Release();
+                return group.Join(expectedSlotCount);
+            }
+        }
+
+        private void RemoveReservationGroup(string groupId, ReservationGroup group)
+        {
+            lock (_inventorySync)
+            {
+                if (_reservationGroups.TryGetValue(groupId, out var current) && ReferenceEquals(current, group))
+                    _reservationGroups.Remove(groupId);
+            }
         }
 
         /// <summary>
@@ -149,7 +502,52 @@ internal void RequestCancel(string runId)
         {
             Current?.RequestCancelRun(runId);
             foreach (var queued in _ToRun)
-                queued.RequestCancelRun(runId);
+                queued.Context.RequestCancelRun(runId);
+        }
+
+        internal bool Kill(string runId)
+        {
+            RunContext? current = null;
+            Reservation? currentReservation = null;
+            ScheduledWork? removed = null;
+            lock (_inventorySync)
+            {
+                if (Current?.ID == runId)
+                {
+                    current = Current;
+                    currentReservation = _currentReservation;
+                }
+                else
+                {
+                    var retained = new List<ScheduledWork>();
+                    while (_ToRun.TryDequeue(out var work))
+                    {
+                        if (removed is null && work.Context.ID == runId)
+                        {
+                            removed = work;
+                            work.Reservation?.RequestCancellation();
+                        }
+                        else
+                            retained.Add(work);
+                    }
+                    foreach (var work in retained)
+                        _ToRun.Enqueue(work);
+                }
+            }
+
+            if (current is not null)
+            {
+                currentReservation?.RequestCancellation();
+                current.Kill();
+                return true;
+            }
+            if (removed is { } queued)
+            {
+                if (queued.Reservation is null)
+                    queued.Sink!.ModelRunFailed(runId, "Run removed from the queue by RunServer Activity window.", string.Empty);
+                return true;
+            }
+            return false;
         }
     }
 }
\ No newline at end of file
diff --git a/src/XTMF2/Bus/SharedEstimationWorkingDirectoryLease.cs b/src/XTMF2/Bus/SharedEstimationWorkingDirectoryLease.cs
new file mode 100644
index 00000000..2d0bfa98
--- /dev/null
+++ b/src/XTMF2/Bus/SharedEstimationWorkingDirectoryLease.cs
@@ -0,0 +1,67 @@
+using System;
+using System.IO;
+using System.Threading;
+
+namespace XTMF2.Bus;
+
+internal static class SharedEstimationWorkingDirectoryLease
+{
+    private static readonly object Sync = new();
+    private static readonly StringComparison PathComparison = OperatingSystem.IsWindows()
+        ? StringComparison.OrdinalIgnoreCase
+        : StringComparison.Ordinal;
+    private static string? _activeDirectory;
+    private static string? _originalDirectory;
+    private static int _leaseCount;
+
+    internal static IDisposable Acquire(string directory)
+    {
+        var fullPath = Path.GetFullPath(directory);
+        lock (Sync)
+        {
+            while (_leaseCount > 0 && !String.Equals(_activeDirectory, fullPath, PathComparison))
+                Monitor.Wait(Sync);
+
+            if (_leaseCount == 0)
+            {
+                _originalDirectory = Directory.GetCurrentDirectory();
+                Directory.SetCurrentDirectory(fullPath);
+                _activeDirectory = fullPath;
+            }
+
+            _leaseCount++;
+            return new Lease();
+        }
+    }
+
+    private static void Release()
+    {
+        lock (Sync)
+        {
+            if (--_leaseCount != 0)
+                return;
+
+            try
+            {
+                Directory.SetCurrentDirectory(_originalDirectory!);
+            }
+            finally
+            {
+                _originalDirectory = null;
+                _activeDirectory = null;
+                Monitor.PulseAll(Sync);
+            }
+        }
+    }
+
+    private sealed class Lease : IDisposable
+    {
+        private int _released;
+
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _released, 1) == 0)
+                Release();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/XTMF2/Configuration/User.cs b/src/XTMF2/Configuration/User.cs
index 99ce5efa..81e05aeb 100644
--- a/src/XTMF2/Configuration/User.cs
+++ b/src/XTMF2/Configuration/User.cs
@@ -36,6 +36,8 @@ public sealed class User
         /// </summary>
         public string UserName { get; }
 
+        public Guid UserId { get; }
+
         /// <summary>
         /// Does this user have administrative rights?
         /// </summary>
@@ -43,6 +45,7 @@ public sealed class User
 
         private const string UserNameProperty = "UserName";
         private const string AdminProperty = "Admin";
+        private const string UserIdProperty = "UserId";
 
         /// <summary>
         /// Lock this before editing a user's available projects
@@ -73,11 +76,14 @@ public ReadOnlyObservableCollection<Project> AvailableProjects
         /// <param name="userPath">The default storage location for this user</param>
         /// <param name="userName">A unique name for this user</param>
         /// <param name="admin">Does this user have administrative privileges?</param>
-        internal User(string userPath, string userName, bool admin = false)
+        internal User(string userPath, string userName, bool admin = false, Guid? userId = null)
         {
             UserName = userName;
             IsAdmin = admin;
             UserPath = userPath;
+            UserId = userId is { } parsedUserId && parsedUserId != Guid.Empty
+                ? parsedUserId
+                : Guid.NewGuid();
         }
 
         /// <summary>
@@ -133,6 +139,7 @@ internal static bool Load(string userFile, out User? user, ref string? error)
         {
             string? userName = null;
             bool admin = false;
+            Guid? userId = null;
             try
             {
                 var buffer = File.ReadAllBytes(userFile);
@@ -151,6 +158,13 @@ internal static bool Load(string userFile, out User? user, ref string? error)
                             reader.Read();
                             admin = reader.GetBoolean();
                         }
+                        else if (reader.ValueTextEquals(UserIdProperty))
+                        {
+                            reader.Read();
+                            if (reader.TokenType == JsonTokenType.String &&
+                                Guid.TryParse(reader.GetString(), out var parsedUserId) && parsedUserId != Guid.Empty)
+                                userId = parsedUserId;
+                        }
                     }
                 }
             }
@@ -166,7 +180,9 @@ internal static bool Load(string userFile, out User? user, ref string? error)
                 error = "The user file failed to contain a user name!";
                 return false;
             }
-            user = new User(Path.GetDirectoryName(userFile)!, userName, admin);
+            user = new User(Path.GetDirectoryName(userFile)!, userName, admin, userId);
+            if (userId is null)
+                user.Save(out _);
             return true;
         }
 
@@ -191,6 +207,7 @@ internal bool Save(out CommandError? error)
                     writer.WriteStartObject();
                     writer.WriteString(UserNameProperty, UserName);
                     writer.WriteBoolean(AdminProperty, IsAdmin);
+                    writer.WriteString(UserIdProperty, UserId);
                     writer.WriteEndObject();
                 }
                 // when we have complete copy the results
diff --git a/src/XTMF2/Editing/ModelSystemSession.cs b/src/XTMF2/Editing/ModelSystemSession.cs
index f792650f..8ceb4ddd 100644
--- a/src/XTMF2/Editing/ModelSystemSession.cs
+++ b/src/XTMF2/Editing/ModelSystemSession.cs
@@ -2746,6 +2746,31 @@ public bool ApplyOptimizationResults(User user, IReadOnlyList<(int nodeIndex, do
             return result;
         }
 
+        /// <summary>
+        /// Returns serialized metadata for BasicParameter&lt;string&gt; nodes that can be
+        /// overridden independently on shared-estimation workers.
+        /// </summary>
+        public IReadOnlyList<(int nodeIndex, Guid nodeId, string name, string value)> GetStringBasicParameterMeta()
+        {
+            var result = new System.Collections.Generic.List<(int, Guid, string, string)>();
+            lock (_sessionLock)
+            {
+                if (ModelSystem.NodesByLoadIndex is null)
+                    return result;
+
+                foreach (var (nodeIndex, node) in ModelSystem.NodesByLoadIndex)
+                {
+                    if (node.Type != typeof(RuntimeModules.BasicParameter<string>) || node.ParameterValue is null)
+                        continue;
+                    string? error = null;
+                    var value = node.ParameterValue.GetValue(null!, typeof(string), ref error) as string;
+                    if (error is null && value is not null)
+                        result.Add((nodeIndex, node.Id, node.Name ?? string.Empty, value));
+                }
+            }
+            return result;
+        }
+
         /// <summary>
         /// Set the value of a parameter to an expression
         /// </summary>
@@ -6482,6 +6507,26 @@ public bool SetEstimationFitnessNode(User user, Node? fitnessNode,
             }
         }
 
+        public bool SetEstimationInputDirectoryNode(User user, Node? inputDirectoryNode,
+            [System.Diagnostics.CodeAnalysis.NotNullWhen(false)] out CommandError? error)
+        {
+            ArgumentNullException.ThrowIfNull(user);
+            if (!_session.HasAccess(user))
+            { error = new CommandError("The user does not have access to this project.", true); return false; }
+            if (inputDirectoryNode is not null && inputDirectoryNode.Type != typeof(RuntimeModules.BasicParameter<string>))
+            { error = new CommandError("The estimation input directory must be a BasicParameter<string>."); return false; }
+            lock (_sessionLock)
+            {
+                var oldNode = ModelSystem.EstimationInputDirectoryNode;
+                ModelSystem.EstimationInputDirectoryNode = inputDirectoryNode;
+                Buffer.AddUndo(new Command(
+                    () => { ModelSystem.EstimationInputDirectoryNode = oldNode; return (true, null); },
+                    () => { ModelSystem.EstimationInputDirectoryNode = inputDirectoryNode; return (true, null); }));
+                error = null;
+                return true;
+            }
+        }
+
         /// <summary>
         /// Sets the estimation algorithm configuration for the model system.
         /// This determines which search algorithm (Nelder-Mead, PSO, GA, etc.) is used
diff --git a/src/XTMF2/ModelSystemConstruct/ModelSystem.cs b/src/XTMF2/ModelSystemConstruct/ModelSystem.cs
index 23d00123..0d226d21 100644
--- a/src/XTMF2/ModelSystemConstruct/ModelSystem.cs
+++ b/src/XTMF2/ModelSystemConstruct/ModelSystem.cs
@@ -109,6 +109,18 @@ internal set
         }
         private Node? _estimationFitnessNode;
 
+        /// <summary>The single string parameter used as the distributed-estimation input directory.</summary>
+        public Node? EstimationInputDirectoryNode
+        {
+            get => _estimationInputDirectoryNode;
+            internal set
+            {
+                _estimationInputDirectoryNode = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(EstimationInputDirectoryNode)));
+            }
+        }
+        private Node? _estimationInputDirectoryNode;
+
         /// <summary>Named groups of calibration parameters.</summary>
         public ObservableCollection<CalibrationGroup> CalibrationGroups { get; private set; } = new ObservableCollection<CalibrationGroup>();
 
@@ -157,6 +169,7 @@ internal set
         private const string VariablesProperty = "Variables";
         private const string EstimationGroupsProperty      = "EstimationGroups";
         private const string EstimationFitnessNodeProperty = "EstimationFitnessNode";
+        private const string EstimationInputDirectoryNodeProperty = "EstimationInputDirectoryNode";
         private const string EstimationAlgorithmConfigProperty = "EstimationAlgorithmConfig";
         private const string EstimationObjectiveProperty   = "EstimationObjective";
         private const string CalibrationGroupsProperty     = "CalibrationGroups";
@@ -223,6 +236,7 @@ private bool Save(ref string? error, Stream saveTo, bool leaveOpen)
                 WriteVariables(writer, nodeDictionary);
                 WriteEstimationGroups(writer, nodeDictionary);
                 WriteEstimationFitnessNode(writer, nodeDictionary);
+                WriteEstimationInputDirectoryNode(writer, nodeDictionary);
                 WriteEstimationAlgorithmConfig(writer);
                 WriteEstimationObjective(writer);
                 WriteCalibrationGroups(writer, nodeDictionary);
@@ -331,6 +345,13 @@ private void WriteEstimationFitnessNode(Utf8JsonWriter writer, Dictionary<Node,
                 writer.WriteNumber(EstimationFitnessNodeProperty, idx);
         }
 
+        private void WriteEstimationInputDirectoryNode(Utf8JsonWriter writer, Dictionary<Node, int> nodeDictionary)
+        {
+            if (_estimationInputDirectoryNode is not null
+                && nodeDictionary.TryGetValue(_estimationInputDirectoryNode, out var idx))
+                writer.WriteNumber(EstimationInputDirectoryNodeProperty, idx);
+        }
+
         private void WriteEstimationAlgorithmConfig(Utf8JsonWriter writer)
         {
             writer.WritePropertyName(EstimationAlgorithmConfigProperty);
@@ -504,6 +525,12 @@ internal static bool Load(ProjectSession session, ModelSystemHeader modelSystemH
                             if (nodes.TryGetValue(reader.GetInt32(), out var fn))
                                 modelSystem.EstimationFitnessNode = fn;
                         }
+                        else if (reader.ValueTextEquals(EstimationInputDirectoryNodeProperty))
+                        {
+                            reader.Read();
+                            if (nodes.TryGetValue(reader.GetInt32(), out var inputDirectory))
+                                modelSystem.EstimationInputDirectoryNode = inputDirectory;
+                        }
                         else if (reader.ValueTextEquals(EstimationAlgorithmConfigProperty))
                         {
                             reader.Read(); // move to StartObject
diff --git a/src/XTMF2/ModelSystemHeader.cs b/src/XTMF2/ModelSystemHeader.cs
index 3eaadec7..5fb6a152 100644
--- a/src/XTMF2/ModelSystemHeader.cs
+++ b/src/XTMF2/ModelSystemHeader.cs
@@ -38,6 +38,8 @@ public sealed class ModelSystemHeader : INotifyPropertyChanged
 
         public string Name { get; private set; }
         public string Description { get; private set; }
+        public Guid Id { get; private set; }
+        internal bool IdentityWasGeneratedDuringLoad { get; private set; }
 
         private readonly Project? _project;
         internal string ModelSystemPath => Path.Combine(_project?.ProjectDirectory ?? 
@@ -48,6 +50,7 @@ public sealed class ModelSystemHeader : INotifyPropertyChanged
         internal ModelSystemHeader(Project? project, string name, string? description = null)
         {
             _project = project;
+            Id = Guid.NewGuid();
             Name = name;
             Description = description ?? string.Empty;
         }
@@ -84,6 +87,7 @@ public bool SetDescription(ProjectSession session, string description, out Comma
         internal void Save(Utf8JsonWriter writer)
         {
             writer.WriteStartObject();
+            writer.WriteString("Id", Id);
             writer.WriteString("Name", Name);
             writer.WriteString("Description", Description);
             writer.WriteEndObject();
@@ -101,11 +105,18 @@ internal static ModelSystemHeader Load(Project project, ref Utf8JsonReader reade
                 throw new ArgumentException(nameof(reader), "Is not processing a model system header!");
             }
             string? name = null, description = null;
+            Guid id = Guid.Empty;
             while(reader.Read() && reader.TokenType != JsonTokenType.EndObject)
             {
                 if(reader.TokenType == JsonTokenType.PropertyName)
                 {
-                    if(reader.ValueTextEquals("Name"))
+                    if(reader.ValueTextEquals("Id"))
+                    {
+                        reader.Read();
+                        if (reader.TokenType == JsonTokenType.String)
+                            Guid.TryParse(reader.GetString(), out id);
+                    }
+                    else if(reader.ValueTextEquals("Name"))
                     {
                         reader.Read();
                         name = reader.GetString();
@@ -117,7 +128,12 @@ internal static ModelSystemHeader Load(Project project, ref Utf8JsonReader reade
                     }
                 }
             }
-            return new ModelSystemHeader(project, name ?? "Unnamed", description);
+            var header = new ModelSystemHeader(project, name ?? "Unnamed", description);
+            if (id != Guid.Empty)
+                header.Id = id;
+            else
+                header.IdentityWasGeneratedDuringLoad = true;
+            return header;
         }
 
         internal static ModelSystemHeader CreateRunHeader(XTMFRuntime runtime)
diff --git a/src/XTMF2/Project.cs b/src/XTMF2/Project.cs
index da2121bc..05e9fd6a 100644
--- a/src/XTMF2/Project.cs
+++ b/src/XTMF2/Project.cs
@@ -37,6 +37,7 @@ namespace XTMF2
     public sealed class Project : INotifyPropertyChanged
     {
         private const string ProjectFile = "Project.xpjt";
+        private const string IdProperty = "Id";
         private const string NameProperty = "Name";
         private const string DescriptionProperty = "Description";
         private const string ModelSystemHeadersProperty = "ModelSystemHeaders";
@@ -45,6 +46,7 @@ public sealed class Project : INotifyPropertyChanged
         private const string CustomRunDirectoryProperty = "CustomRunDirectory";
         private const string AlternativeRunDirectories = "AlternativeRunDirectories";
 
+        public Guid Id { get; private set; }
         public string? Name { get; private set; }
         public string? Description { get; private set; }
         public string? ProjectFilePath { get; private set; }
@@ -72,6 +74,7 @@ public sealed class Project : INotifyPropertyChanged
 
         private Project()
         {
+            Id = Guid.NewGuid();
         }
 
         internal static bool Load(UserController userController, string filePath, [NotNullWhen(true)] out Project? project, [NotNullWhen(false)] ref string? error)
@@ -80,6 +83,7 @@ internal static bool Load(UserController userController, string filePath, [NotNu
             {
                 ProjectFilePath = filePath
             };
+            bool hasProjectId = false;
             try
             {
                 byte[] buffer = File.ReadAllBytes(filePath);
@@ -89,7 +93,17 @@ internal static bool Load(UserController userController, string filePath, [NotNu
                     {
                         if (reader.TokenType == JsonTokenType.PropertyName)
                         {
-                            if (reader.ValueTextEquals(NameProperty))
+                            if (reader.ValueTextEquals(IdProperty))
+                            {
+                                reader.Read();
+                                if (reader.TokenType == JsonTokenType.String && Guid.TryParse(reader.GetString(), out var id) &&
+                                    id != Guid.Empty)
+                                {
+                                    project.Id = id;
+                                    hasProjectId = true;
+                                }
+                            }
+                            else if (reader.ValueTextEquals(NameProperty))
                             {
                                 reader.Read();
                                 project.Name = reader.GetString();
@@ -109,7 +123,8 @@ internal static bool Load(UserController userController, string filePath, [NotNu
                                 }
                                 while (reader.Read() && reader.TokenType != JsonTokenType.EndArray)
                                 {
-                                    project._ModelSystems.Add(ModelSystemHeader.Load(project, ref reader));
+                                    var header = ModelSystemHeader.Load(project, ref reader);
+                                    project._ModelSystems.Add(header);
                                 }
                             }
                             else if (reader.ValueTextEquals(OwnerProperty))
@@ -181,6 +196,17 @@ internal static bool Load(UserController userController, string filePath, [NotNu
                     error = "Unable to load an owner for the given project.";
                     return false;
                 }
+                if (!hasProjectId || project._ModelSystems.Any(header => header.IdentityWasGeneratedDuringLoad))
+                {
+                    try
+                    {
+                        project.Save(ref error);
+                    }
+                    catch (UnauthorizedAccessException)
+                    {
+                    }
+                    error = null;
+                }
                 return true;
             }
             catch (JsonException e)
@@ -378,6 +404,7 @@ internal bool Save([NotNullWhen(false)] ref string? error)
                 {
                     using var writer = new Utf8JsonWriter(tempFile, Helper.RelaxedJsonWriterOptions);
                     writer.WriteStartObject();
+                    writer.WriteString(IdProperty, Id);
                     writer.WriteString(NameProperty, Name);
                     writer.WriteString(DescriptionProperty, Description);
                     writer.WriteString(OwnerProperty, Owner!.UserName);
diff --git a/src/XTMF2/XTMF2.csproj b/src/XTMF2/XTMF2.csproj
index 2ed93544..8ae1c4e0 100644
--- a/src/XTMF2/XTMF2.csproj
+++ b/src/XTMF2/XTMF2.csproj
@@ -17,6 +17,9 @@
 
   <ItemGroup>
     <ProjectReference Include="..\XTMF2.Interfaces\XTMF2.Interfaces.csproj" />
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+      <_Parameter1>XTMF2.UnitTests</_Parameter1>
+    </AssemblyAttribute>
   </ItemGroup>
 
 </Project>
diff --git a/tests/XTMF2.GUI.Tests/Headless/RemoteEstimationWorkersWindowTests.cs b/tests/XTMF2.GUI.Tests/Headless/RemoteEstimationWorkersWindowTests.cs
new file mode 100644
index 00000000..d2c61022
--- /dev/null
+++ b/tests/XTMF2.GUI.Tests/Headless/RemoteEstimationWorkersWindowTests.cs
@@ -0,0 +1,145 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
+using XTMF2.GUI.Properties;
+using XTMF2.GUI.ViewModels;
+using XTMF2.GUI.Views;
+
+namespace XTMF2.GUI.Tests.Headless;
+
+[TestClass]
+public class RemoteEstimationWorkersWindowTests
+{
+    private HeadlessUnitTestSession Session => HeadlessAppLifetime.HeadlessSession!;
+
+    [TestMethod]
+    public void WorkerWindow_BindsLiveRunWorkerCollection()
+    {
+        Session.Dispatch(() =>
+        {
+            var run = CreateRun();
+            var window = new RemoteEstimationWorkersWindow(run);
+
+            Assert.AreSame(run, window.DataContext);
+            Assert.AreSame(run.RemoteWorkers, window.FindControl<ItemsControl>("RemoteWorkersList")!.ItemsSource);
+            Assert.AreEqual("Estimation Workers - Shared forecast", window.Title);
+        }, System.Threading.CancellationToken.None).GetAwaiter().GetResult();
+    }
+
+    [TestMethod]
+    public void WorkerWindowButton_IsBesideParameterProgressButton()
+    {
+        Session.Dispatch(() =>
+        {
+            var view = new RunsView();
+            var progressButton = view.FindControl<Button>("ViewProgressButton");
+            var workersButton = view.FindControl<Button>("EstimationWorkersButton");
+
+            Assert.IsNotNull(progressButton);
+            Assert.IsNotNull(workersButton);
+            Assert.AreSame(progressButton.Parent, workersButton.Parent);
+            Assert.AreEqual("Estimation Workers", workersButton.Content);
+        }, System.Threading.CancellationToken.None).GetAwaiter().GetResult();
+    }
+
+    [TestMethod]
+    public void WorkerWindow_ShowsReadyCountAgainstConfiguredCapacity()
+    {
+        Session.Dispatch(() =>
+        {
+            var run = CreateRun();
+            var worker = run.RemoteWorkers[0];
+
+            Assert.AreEqual("0 / 3 workers", worker.ActiveWorkerCountDisplay);
+
+            run.UpdateSharedEstimationProgress(new SharedEstimationProgress(
+                "shared-run", 1, 0.5, 2, 0, 2, 2,
+                new System.Collections.Generic.Dictionary<string, int>
+                {
+                    ["server-2"] = 2,
+                    ["server-2#run-2"] = 3,
+                    ["server-3"] = 7,
+                    ["coordinator"] = 11
+                },
+                Array.Empty<double>(), ["server-2", "server-2#run-2"]));
+
+            Assert.AreEqual(2, worker.ActiveWorkerCount);
+            Assert.AreEqual("2 / 3 workers", worker.ActiveWorkerCountDisplay);
+            Assert.AreEqual(5, worker.CompletedEvaluations);
+            Assert.AreEqual("Tests: 5", worker.EvaluationCountDisplay);
+        }, System.Threading.CancellationToken.None).GetAwaiter().GetResult();
+    }
+
+    [TestMethod]
+    public void CoordinatorWorker_IsShownButCannotBeRemoved()
+    {
+        Session.Dispatch(() =>
+        {
+            var removalRequested = false;
+            var run = CreateRun();
+            run.SetRemoteEstimationWorkers(
+                [new RunServerEndpoint
+                {
+                    Id = RemoteEstimationWorkerViewModel.CoordinatorWorkerId,
+                    Name = "Coordinator",
+                    Address = "127.0.0.1"
+                }],
+                [RemoteEstimationWorkerViewModel.CoordinatorWorkerId],
+                _ => null,
+                _ =>
+                {
+                    removalRequested = true;
+                    return null;
+                },
+                new System.Collections.Generic.Dictionary<string, int>
+                {
+                    [RemoteEstimationWorkerViewModel.CoordinatorWorkerId] = 2
+                });
+            var coordinator = run.RemoteWorkers[0];
+
+            run.UpdateSharedEstimationProgress(new SharedEstimationProgress(
+                "shared-run", 1, 0.5, 2, 0, 2, 2,
+                new System.Collections.Generic.Dictionary<string, int>
+                {
+                    ["coordinator"] = 4,
+                    ["coordinator#run-2"] = 6
+                },
+                Array.Empty<double>(), ["coordinator", "coordinator#run-2"]));
+            run.RemoveRemoteWorkerCommand.Execute(coordinator);
+
+            Assert.IsTrue(coordinator.IsCoordinator);
+            Assert.IsTrue(coordinator.IsActive);
+            Assert.IsFalse(coordinator.CanRemove);
+            Assert.AreEqual(2, coordinator.ActiveWorkerCount);
+            Assert.AreEqual("Tests: 10", coordinator.EvaluationCountDisplay);
+            Assert.IsFalse(removalRequested);
+        }, System.Threading.CancellationToken.None).GetAwaiter().GetResult();
+    }
+
+    [TestMethod]
+    public void LocalCoordinatorRun_DoesNotOfferRemoteOutputTransfer()
+    {
+        var run = CreateRun();
+        run.SetRemoteRunTracking(false);
+        run.MarkFinished("Cancelled");
+
+        Assert.IsFalse(run.CanTransferRemoteOutput);
+    }
+
+    private static RunViewModel CreateRun()
+    {
+        var run = new RunViewModel("shared-run", "Shared forecast", "/runs/shared", "server-1",
+            null!, null!);
+        run.SetRunMode(RunMode.Estimation, Array.Empty<(int nodeIndex, string name, double min, double max)>(), () => { });
+        run.SetRemoteEstimationWorkers(
+            [new RunServerEndpoint { Id = "server-2", Name = "Remote Two", Address = "10.0.0.2", Port = 5000 }],
+            ["server-2"],
+            _ => null,
+            _ => null,
+            new System.Collections.Generic.Dictionary<string, int> { ["server-2"] = 3 });
+        return run;
+    }
+}
\ No newline at end of file
diff --git a/tests/XTMF2.GUI.Tests/Headless/RunConfigurationDialogTests.cs b/tests/XTMF2.GUI.Tests/Headless/RunConfigurationDialogTests.cs
new file mode 100644
index 00000000..b0505d79
--- /dev/null
+++ b/tests/XTMF2.GUI.Tests/Headless/RunConfigurationDialogTests.cs
@@ -0,0 +1,119 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.GUI.Properties;
+using XTMF2.GUI.Views;
+
+namespace XTMF2.GUI.Tests.Headless;
+
+[TestClass]
+public class RunConfigurationDialogTests
+{
+    private HeadlessUnitTestSession Session => HeadlessAppLifetime.HeadlessSession!;
+
+    [TestMethod]
+    public void SavedEndpointOverride_IsLoadedByStableNodeId()
+    {
+        Session.Dispatch(() =>
+        {
+            var nodeId = Guid.Parse("11111111-1111-1111-1111-111111111111");
+            var endpoint = new RunServerEndpoint
+            {
+                Id = "worker-1",
+                Name = "Worker 1",
+                BasicParameterOverrides = new Dictionary<string, string>
+                {
+                    [nodeId.ToString("D")] = "/worker/data"
+                }
+            };
+            var dialog = new RunConfigurationDialog(
+                "Run Estimation",
+                "estimation",
+                [endpoint],
+                ["Start"],
+                allowMultipleRunServers: true,
+                [new RunConfigurationDialog.PathParameter(7, nodeId, "Input path", "/shared/data")]);
+            dialog.UseMultipleRunServers = true;
+
+            Assert.IsTrue(dialog.IsPathOverridesVisible);
+            Assert.AreSame(endpoint, dialog.SelectedCoordinatorRunServer);
+            StringAssert.Contains(dialog.SelectedRunServerSummary, "Worker 1");
+            Assert.AreEqual("/worker/data", dialog.PathOverrides[endpoint.Id][7]);
+        }, System.Threading.CancellationToken.None).GetAwaiter().GetResult();
+    }
+
+    [TestMethod]
+    public void EstimationCanSelectSingleRemoteRunServerByDefault()
+    {
+        Session.Dispatch(() =>
+        {
+            var local = new RunServerEndpoint { Id = "local", Name = "Local" };
+            var remote = new RunServerEndpoint { Id = "remote-1", Name = "Remote 1" };
+            var dialog = new RunConfigurationDialog("Run Estimation", "estimation",
+                [local, remote], ["Start"], allowMultipleRunServers: true);
+
+            Assert.IsFalse(dialog.UseMultipleRunServers);
+            Assert.IsTrue(dialog.IsSingleRunServerSelectionVisible);
+            dialog.SelectedRunServer = remote;
+            Assert.AreSame(remote, dialog.SelectedRunServer);
+
+            dialog.UseMultipleRunServers = true;
+            Assert.IsTrue(dialog.IsMultipleRunServerSelectionVisible);
+            Assert.IsFalse(dialog.IsSingleRunServerSelectionVisible);
+        }, System.Threading.CancellationToken.None).GetAwaiter().GetResult();
+    }
+
+    [TestMethod]
+    public void DistributedEstimationCanChooseRemoteCoordinatorIndependentlyOfWorkers()
+    {
+        Session.Dispatch(() =>
+        {
+            var local = new RunServerEndpoint { Id = "local", Name = "Local" };
+            var remote = new RunServerEndpoint { Id = "remote-1", Name = "Remote 1" };
+            var dialog = new RunConfigurationDialog("Run Estimation", "estimation",
+                [local, remote], ["Start"], allowMultipleRunServers: true);
+            dialog.UseMultipleRunServers = true;
+            dialog.SelectedCoordinatorRunServer = remote;
+            dialog.RunServerChoices.Single(choice => choice.Endpoint.Id == local.Id).IsSelected = true;
+
+            Assert.AreSame(remote, dialog.SelectedCoordinatorRunServer);
+            Assert.Contains(remote, dialog.RunServers);
+        }, System.Threading.CancellationToken.None).GetAwaiter().GetResult();
+    }
+
+    [TestMethod]
+    public void ServerRows_UseCheckboxSelectionAndIndependentRunCounts()
+    {
+        Session.Dispatch(() =>
+        {
+            var coordinator = new RunServerEndpoint { Id = "coordinator", Name = "Coordinator" };
+            var local = new RunServerEndpoint { Id = "local", Name = "Local" };
+            var remote = new RunServerEndpoint { Id = "remote-1", Name = "Remote 1" };
+            var dialog = new RunConfigurationDialog("Run Estimation", "estimation",
+                [coordinator, local, remote], ["Start"], allowMultipleRunServers: true);
+            dialog.UseMultipleRunServers = true;
+            var remoteRow = dialog.RunServerChoices.Single(choice => choice.Endpoint.Id == remote.Id);
+            var localRow = dialog.RunServerChoices.Single(choice => choice.Endpoint.Id == local.Id);
+            var coordinatorRow = dialog.RunServerChoices.Single(choice => choice.Endpoint.Id == coordinator.Id);
+            remoteRow.IsSelected = true;
+            remoteRow.ConcurrentRuns = 3;
+            localRow.IsSelected = true;
+            localRow.ConcurrentRuns = 2;
+            coordinatorRow.IsSelected = false;
+
+            Assert.IsTrue(remoteRow.IsSelected);
+            Assert.IsTrue(localRow.IsSelected);
+            Assert.AreEqual(3, remoteRow.ConcurrentRuns);
+            Assert.AreEqual(2, localRow.ConcurrentRuns);
+            Assert.AreEqual(3, dialog.ConcurrentRunsByEndpoint[remote.Id]);
+            Assert.AreEqual(2, dialog.ConcurrentRunsByEndpoint[local.Id]);
+            Assert.AreEqual(1, dialog.ConcurrentRunsByEndpoint[coordinator.Id]);
+            Assert.Contains(coordinator, dialog.RunServers);
+            Assert.IsFalse(dialog.SelectedRunServers.Any(endpoint => endpoint.Id == coordinator.Id));
+            Assert.IsTrue(coordinatorRow.CanConfigureRuns);
+        }, System.Threading.CancellationToken.None).GetAwaiter().GetResult();
+    }
+}
\ No newline at end of file
diff --git a/tests/XTMF2.GUI.Tests/Headless/RunServerActivityWindowTests.cs b/tests/XTMF2.GUI.Tests/Headless/RunServerActivityWindowTests.cs
new file mode 100644
index 00000000..cfc0fc57
--- /dev/null
+++ b/tests/XTMF2.GUI.Tests/Headless/RunServerActivityWindowTests.cs
@@ -0,0 +1,81 @@
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Linq;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
+using XTMF2.GUI;
+using XTMF2.GUI.Properties;
+using XTMF2.GUI.ViewModels;
+using XTMF2.GUI.Views;
+
+namespace XTMF2.GUI.Tests.Headless;
+
+[TestClass]
+public class RunServerActivityWindowTests
+{
+    private HeadlessUnitTestSession Session => HeadlessAppLifetime.HeadlessSession!;
+
+    [TestMethod]
+    public void ActivityWindow_LoadsFromRuntimeXaml()
+    {
+        Session.Dispatch(() =>
+        {
+            var window = new RunServerActivityWindow();
+            Assert.IsNotNull(window.Content);
+            Assert.IsNotNull(window.FindControl<StackPanel>("ServerList"));
+            Assert.IsNotNull(window.FindControl<Button>("RefreshButton"));
+        }, System.Threading.CancellationToken.None).GetAwaiter().GetResult();
+    }
+
+    [TestMethod]
+    public void ActiveActivityRow_ExposesKillButton()
+    {
+        Session.Dispatch(() =>
+        {
+            var window = new RunServerActivityWindow();
+            var endpoint = new RunServerEndpoint
+            {
+                Id = "server-1",
+                Name = "Server 1",
+                Address = "127.0.0.1",
+                Port = 5000
+            };
+            window.RenderServers(new[]
+            {
+                new RunServerActivityServerSnapshot(endpoint, RunServerConnectionState.Available, null,
+                    new[]
+                    {
+                        new RunServerActivity("run-1", "Forecast", "Normal",
+                            RunServerActivityState.Running, "Running")
+                    })
+            });
+
+            var serverList = window.FindControl<StackPanel>("ServerList")!;
+            var serverContent = (StackPanel)((Border)serverList.Children[0]).Child!;
+            var activityRow = (Grid)serverContent.Children[2];
+            Assert.IsTrue(activityRow.Classes.Contains("activity-row"));
+            Assert.IsNotNull(activityRow.Children.OfType<Button>().SingleOrDefault(button =>
+                Equals(button.Content, "✕")));
+        }, System.Threading.CancellationToken.None).GetAwaiter().GetResult();
+    }
+
+    [TestMethod]
+    public void RecoveredSnapshot_UpdatesExistingRunServerLabel()
+    {
+        Session.Dispatch(() =>
+        {
+            var runs = new RunsViewModel();
+            var snapshot = new RemoteRunSnapshot("run-recovered-label", "Forecast", RunMode.Normal,
+                "/remote/runs/forecast", "Start", "model-hash", RemoteRunState.Completed,
+                "Run completed.", 0, double.NaN, Array.Empty<RemoteRunParameterValue>(), null,
+                null, null, false, DateTimeOffset.UtcNow);
+
+            var run = runs.RestoreRemoteRun(snapshot, "Local RunServer", () => { });
+            runs.RestoreRemoteRun(snapshot, "Remote Production", () => { });
+
+            Assert.AreEqual("Remote Production", run.RunServer);
+        }, System.Threading.CancellationToken.None).GetAwaiter().GetResult();
+    }
+}
\ No newline at end of file
diff --git a/tests/XTMF2.GUI.Tests/Properties/TestRunServerEndpoint.cs b/tests/XTMF2.GUI.Tests/Properties/TestRunServerEndpoint.cs
new file mode 100644
index 00000000..146acf59
--- /dev/null
+++ b/tests/XTMF2.GUI.Tests/Properties/TestRunServerEndpoint.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.GUI.Properties;
+
+namespace XTMF2.GUI.Tests.Properties;
+
+[TestClass]
+public class TestRunServerEndpoint
+{
+    [TestMethod]
+    public void BasicParameterOverrides_RoundTripThroughJson()
+    {
+        var endpoint = new RunServerEndpoint
+        {
+            Id = "worker-1",
+            Name = "Worker 1",
+            BasicParameterOverrides = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+            {
+                ["11111111-1111-1111-1111-111111111111"] = "/data/input",
+                ["22222222-2222-2222-2222-222222222222"] = "/data/output"
+            }
+        };
+
+        var restored = JsonSerializer.Deserialize<RunServerEndpoint>(JsonSerializer.Serialize(endpoint));
+
+        Assert.IsNotNull(restored);
+        Assert.AreEqual("/data/input", restored.BasicParameterOverrides["11111111-1111-1111-1111-111111111111"]);
+        Assert.AreEqual("/data/output", restored.BasicParameterOverrides["22222222-2222-2222-2222-222222222222"]);
+    }
+
+    [TestMethod]
+    public void Clone_IsolatesBasicParameterOverrides()
+    {
+        var endpoint = new RunServerEndpoint
+        {
+            BasicParameterOverrides = new Dictionary<string, string>
+            {
+                ["node-1"] = "/original"
+            }
+        };
+
+        var clone = endpoint.Clone();
+        clone.BasicParameterOverrides["node-1"] = "/clone";
+        clone.BasicParameterOverrides["node-2"] = "/clone-only";
+
+        Assert.AreEqual("/original", endpoint.BasicParameterOverrides["node-1"]);
+        Assert.IsFalse(endpoint.BasicParameterOverrides.ContainsKey("node-2"));
+    }
+
+    [TestMethod]
+    public void Clone_HandlesLegacyNullOverrideMap()
+    {
+        var endpoint = JsonSerializer.Deserialize<RunServerEndpoint>(
+            "{\"Id\":\"worker-1\",\"BasicParameterOverrides\":null}");
+
+        Assert.IsNotNull(endpoint);
+        var clone = endpoint.Clone();
+
+        Assert.IsNotNull(clone.BasicParameterOverrides);
+        Assert.IsEmpty(clone.BasicParameterOverrides);
+    }
+}
\ No newline at end of file
diff --git a/tests/XTMF2.GUI.Tests/RunControllerCompletionTests.cs b/tests/XTMF2.GUI.Tests/RunControllerCompletionTests.cs
new file mode 100644
index 00000000..abf5ffe0
--- /dev/null
+++ b/tests/XTMF2.GUI.Tests/RunControllerCompletionTests.cs
@@ -0,0 +1,374 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
+using XTMF2.GUI;
+using XTMF2.GUI.Properties;
+using XTMF2.GUI.ViewModels;
+using XTMF2;
+
+namespace XTMF2.GUI.Tests;
+
+[TestClass]
+public class RunControllerCompletionTests
+{
+    [TestMethod]
+    public void RemoteRunDeletion_NotFoundCountsAsAlreadyDeleted()
+    {
+        var missing = new RemoteRunDeletionResponse("request", "run-missing", false,
+            "The remote run was not found.");
+        var rejected = new RemoteRunDeletionResponse("request", "run-running", false,
+            "A running remote job cannot be deleted.");
+
+        Assert.IsTrue(missing.IsDeletedOrNotFound);
+        Assert.IsFalse(rejected.IsDeletedOrNotFound);
+    }
+
+    [TestMethod]
+    public void CompletionReceivedBeforeRunRegistration_IsReleasedAfterRegistration()
+    {
+        var gate = new SharedEstimationCompletionGate();
+        var completion = new SharedEstimationCompletion("run-1", true, 1.25,
+            new[] { 0.5, 0.75 }, 4, 2, null);
+
+        Assert.IsTrue(gate.TryReceive(completion, contextReady: false, out var accepted));
+        Assert.IsNull(accepted);
+        var released = gate.MarkReady("run-1");
+        Assert.AreSame(completion, released);
+        Assert.IsTrue(gate.TryReceive(released!, contextReady: true, out accepted));
+        Assert.AreSame(completion, accepted);
+        Assert.IsFalse(gate.TryReceive(completion, contextReady: true, out _));
+    }
+
+    [TestMethod]
+    public void CompletionReceivedAfterRunRegistration_IsAcceptedOnce()
+    {
+        var gate = new SharedEstimationCompletionGate();
+        var completion = new SharedEstimationCompletion("run-2", true, 2.5,
+            new[] { 0.25 }, 3, 1, null);
+
+        Assert.IsTrue(gate.TryReceive(completion, contextReady: true, out var accepted));
+        Assert.AreSame(completion, accepted);
+        Assert.IsNull(gate.MarkReady("run-2"));
+        Assert.IsFalse(gate.TryReceive(completion, contextReady: true, out _));
+    }
+
+    [TestMethod]
+    public void MarkFinished_PreservesEstimationCompletionSummary()
+    {
+        TestGuiHelper.RunInModelSystemContext(nameof(MarkFinished_PreservesEstimationCompletionSummary),
+            (user, _, session) =>
+            {
+                var run = new RunViewModel("run-3", "estimation", string.Empty, "remote", session, user);
+                run.SetRunMode(RunMode.Estimation,
+                    Array.Empty<(int nodeIndex, string name, double min, double max)>(), () => { });
+                const string completion = "[Estimation] converged after 8 fitness tests in 3 iterations.";
+
+                run.AppendStatus(completion);
+                run.MarkFinished();
+
+                Assert.AreEqual(RunStatus.Finished, run.Status);
+                Assert.AreEqual(completion, run.StatusText);
+            });
+    }
+
+    [TestMethod]
+    public void RecoveredOptimizationRun_RemainsUnboundUntilExplicitBinding()
+    {
+        var snapshot = new RemoteRunSnapshot("run-recovered", "estimation", RunMode.Estimation,
+            "/remote/runs/estimation", "Start", "model-hash", RemoteRunState.Completed,
+            "Run completed.", 4, 0.125,
+            new[] { new RemoteRunParameterValue(12, 1.5) },
+            new[] { new RemoteRunParameterValue(12, 1.25) }, null, null, true,
+            DateTimeOffset.UtcNow);
+
+        var run = new RunViewModel(snapshot, "orchestrator");
+
+        Assert.IsTrue(run.IsRecoveredRunUnbound);
+        Assert.AreEqual(RunStatus.Finished, run.Status);
+        Assert.AreEqual(4, run.CurrentIteration);
+        Assert.IsTrue(run.HasOptimizationResults);
+        Assert.IsFalse(run.ApplyOptimizationResultsCommand.CanExecute(null));
+        Assert.AreEqual(1.5, run.OptimizationParameters[0].CurrentValue);
+    }
+
+    [TestMethod]
+    public void RecoveredRemoteRun_ReportsOutputLocationAndOffersTransfer()
+    {
+        var snapshot = new RemoteRunSnapshot("run-output", "forecast", RunMode.Normal,
+            "/remote/private/run-output", "Start", "model-hash", RemoteRunState.Completed,
+            "Run completed.", 0, double.NaN, Array.Empty<RemoteRunParameterValue>(), null,
+            null, null, true, DateTimeOffset.UtcNow);
+
+        var run = new RunViewModel(snapshot, "Remote Server");
+
+        Assert.IsTrue(run.IsRemoteRun);
+        Assert.IsTrue(run.RemoteOutputAvailable);
+        Assert.IsTrue(run.CanTransferRemoteOutput);
+        Assert.IsFalse(run.ArtifactsAvailable);
+        Assert.AreNotEqual(snapshot.WorkingDirectory, run.RunDirectory);
+        Assert.AreEqual("Output is available on the RunServer.", run.OutputTransferStatus);
+
+        run.MarkArtifactsAvailable();
+
+        Assert.IsTrue(run.ArtifactsAvailable);
+        Assert.IsFalse(run.RemoteOutputAvailable);
+        Assert.IsFalse(run.CanTransferRemoteOutput);
+        Assert.AreEqual("Output is on this computer.", run.OutputTransferStatus);
+    }
+
+    [TestMethod]
+    public void RecoveredRemoteRun_UsesLocalReceiptDirectoryForOpenOutput()
+    {
+        var snapshot = new RemoteRunSnapshot("run-local-output", "forecast", RunMode.Normal,
+            "/remote/server/runs/forecast", "Start", "model-hash", RemoteRunState.Completed,
+            "Run completed.", 0, double.NaN, Array.Empty<RemoteRunParameterValue>(), null,
+            null, null, true, DateTimeOffset.UtcNow);
+        var run = new RunViewModel(snapshot, "Remote Server");
+        var localReceiptDirectory = Path.Combine(Path.GetTempPath(), "XTMF2-GUI-RunOutput", snapshot.RunId);
+
+        run.SetLocalOutputDirectory(localReceiptDirectory);
+
+        Assert.AreEqual(localReceiptDirectory, run.RunDirectory);
+        Assert.AreNotEqual(snapshot.WorkingDirectory, run.RunDirectory);
+    }
+
+    [TestMethod]
+    public void RecoveredLocalRun_DoesNotOfferOutputTransfer()
+    {
+        var snapshot = new RemoteRunSnapshot("run-local-output", "forecast", RunMode.Normal,
+            "/local/runs/forecast", "Start", "model-hash", RemoteRunState.Completed,
+            "Run completed.", 0, double.NaN, Array.Empty<RemoteRunParameterValue>(), null,
+            null, null, true, DateTimeOffset.UtcNow);
+        var localDirectory = Directory.CreateTempSubdirectory("xtmf-local-run-output-");
+        var run = new RunViewModel(snapshot, "Local RunServer");
+
+        try
+        {
+            run.SetRemoteRunTracking(false);
+            run.SetLocalOutputDirectory(localDirectory.FullName);
+
+            Assert.IsFalse(run.IsRemoteRun);
+            Assert.IsFalse(run.CanTransferRemoteOutput);
+            Assert.IsTrue(run.ArtifactsAvailable);
+            Assert.IsTrue(run.HasRunDirectory);
+            Assert.AreEqual(localDirectory.FullName, run.RunDirectory);
+            Assert.AreEqual("Output is on this computer.", run.OutputTransferStatus);
+        }
+        finally
+        {
+            localDirectory.Delete(recursive: true);
+        }
+    }
+
+    [TestMethod]
+    public void LocalCoordinatorEstimation_OffersRunDirectoryAfterCompletionOrCancellation()
+    {
+        var completedDirectory = Directory.CreateTempSubdirectory("xtmf-estimation-completed-");
+        var cancelledDirectory = Directory.CreateTempSubdirectory("xtmf-estimation-cancelled-");
+        try
+        {
+            var completedRun = CreateLocalCoordinatorEstimationRun("run-completed", completedDirectory.FullName);
+            completedRun.MarkFinished("Estimation completed.");
+
+            Assert.IsTrue(completedRun.HasRunDirectory);
+            Assert.IsTrue(completedRun.OpenRunDirectoryCommand.CanExecute(null));
+            Assert.IsFalse(completedRun.CanTransferRemoteOutput);
+
+            var cancelledRun = CreateLocalCoordinatorEstimationRun("run-cancelled", cancelledDirectory.FullName);
+            cancelledRun.MarkError("Cancelled by user.", string.Empty, null, null);
+
+            Assert.IsTrue(cancelledRun.HasRunDirectory);
+            Assert.IsTrue(cancelledRun.OpenRunDirectoryCommand.CanExecute(null));
+            Assert.IsFalse(cancelledRun.CanTransferRemoteOutput);
+        }
+        finally
+        {
+            completedDirectory.Delete(recursive: true);
+            cancelledDirectory.Delete(recursive: true);
+        }
+    }
+
+    [TestMethod]
+    public void RemoteCoordinatorEstimation_DoesNotOfferTransferWhenOutputIsAlreadyLocal()
+    {
+        var localDirectory = Directory.CreateTempSubdirectory("xtmf-remote-estimation-output-");
+        try
+        {
+            var run = CreateLocalCoordinatorEstimationRun(
+                "run-remote-estimation", localDirectory.FullName, isRemote: true);
+            run.MarkFinished("Estimation completed.");
+
+            Assert.IsTrue(run.IsRemoteRun);
+            Assert.IsTrue(run.ArtifactsAvailable);
+            Assert.IsTrue(run.HasRunDirectory);
+            Assert.IsFalse(run.CanTransferRemoteOutput);
+            Assert.AreEqual("Output is on this computer.", run.OutputTransferStatus);
+        }
+        finally
+        {
+            localDirectory.Delete(recursive: true);
+        }
+    }
+
+    [TestMethod]
+    public void RemoteCoordinatorEstimation_StillOffersTransferWhenOutputIsNotLocal()
+    {
+        var missingDirectory = Path.Combine(Path.GetTempPath(), $"xtmf-remote-estimation-missing-{Guid.NewGuid():N}");
+        var run = CreateLocalCoordinatorEstimationRun("run-remote-estimation-missing",
+            missingDirectory, isRemote: true);
+
+        run.MarkFinished("Estimation completed.");
+
+        Assert.IsFalse(run.ArtifactsAvailable);
+        Assert.IsTrue(run.CanTransferRemoteOutput);
+    }
+
+    private static RunViewModel CreateLocalCoordinatorEstimationRun(string runId, string runDirectory,
+        bool isRemote = false)
+    {
+        var run = new RunViewModel(runId, "estimation", runDirectory, "Local RunServer", null!, null!);
+        run.SetRunMode(RunMode.Estimation,
+            Array.Empty<(int nodeIndex, string name, double min, double max)>(), () => { });
+        run.SetRemoteRunTracking(isRemote);
+        run.SetRemoteEstimationWorkers(Array.Empty<RunServerEndpoint>(), Array.Empty<string>(),
+            _ => null, _ => null);
+        return run;
+    }
+
+    [TestMethod]
+    public void RecoveredRemoteRun_OffersTransferBeforeAvailabilitySnapshot()
+    {
+        var snapshot = new RemoteRunSnapshot("run-output-unknown", "forecast", RunMode.Normal,
+            "/remote/private/run-output-unknown", "Start", "model-hash", RemoteRunState.Completed,
+            "Run completed.", 0, double.NaN, Array.Empty<RemoteRunParameterValue>(), null,
+            null, null, false, DateTimeOffset.UtcNow);
+
+        var run = new RunViewModel(snapshot, "Remote Server");
+
+        Assert.IsFalse(run.RemoteOutputAvailable);
+        Assert.IsTrue(run.CanTransferRemoteOutput);
+    }
+
+    [TestMethod]
+    public void RecoveredInterruptedRun_IsNeutralAndDoesNotLogAnError()
+    {
+        var snapshot = new RemoteRunSnapshot("run-interrupted", "forecast", RunMode.Normal,
+            "/remote/runs/forecast", "Start", "model-hash", RemoteRunState.Interrupted,
+            "RunServer restarted; saved run details restored. The run did not resume.",
+            0, double.NaN, Array.Empty<RemoteRunParameterValue>(), null, null, null, false,
+            DateTimeOffset.UtcNow);
+
+        var run = new RunViewModel(snapshot, "orchestrator");
+
+        Assert.AreEqual(RunStatus.Interrupted, run.Status);
+        Assert.IsTrue(run.IsCompleted);
+        Assert.AreEqual("↻", run.StatusBadge);
+        Assert.AreEqual(snapshot.Status, run.StatusText);
+        Assert.Contains(snapshot.Status, run.Messages);
+        Assert.IsFalse(run.Messages.Any(message => message.StartsWith("Error:", StringComparison.Ordinal)));
+    }
+
+    [TestMethod]
+    public void RecoveredSharedEstimation_RestoresProgressAndWorkers()
+    {
+        var progress = new SharedEstimationProgress("shared-recovered", 5, 0.125,
+            18, 2, 3, 4, new Dictionary<string, int> { ["worker-1"] = 6 }, [1.25, 2.5]);
+        var snapshot = new SharedEstimationJobSnapshot("shared-recovered", SharedEstimationJobState.Running,
+            progress, null, ["worker-1"], "restored-estimation", "/runs/restored-estimation", "model-hash",
+            [new SharedEstimationParameterMetadata(14, "Fare", 0, 10),
+             new SharedEstimationParameterMetadata(27, "Wait", 0, 20)]);
+
+        var run = new RunViewModel(snapshot, "Remote Orchestrator", () => { });
+
+        Assert.AreEqual("restored-estimation", run.RunName);
+        Assert.AreEqual(RunStatus.Running, run.Status);
+        Assert.IsTrue(run.IsRecoveredRunUnbound);
+        Assert.IsTrue(run.IsRemoteSharedEstimation);
+        Assert.AreEqual(5, run.CurrentIteration);
+        Assert.AreEqual(0.125, run.CurrentFitness);
+        Assert.AreEqual("Fare", run.OptimizationParameters[0].Name);
+        Assert.AreEqual(1.25, run.OptimizationParameters[0].CurrentValue);
+        Assert.AreEqual("Wait", run.OptimizationParameters[1].Name);
+        Assert.AreEqual(2.5, run.OptimizationParameters[1].CurrentValue);
+    }
+
+    [TestMethod]
+    public void RecoveredCompletedSharedEstimation_KeepsResultsUnappliableUntilBound()
+    {
+        var completion = new SharedEstimationCompletion("shared-complete", true, 0.25,
+            [3.5], 12, 4, null);
+        var snapshot = new SharedEstimationJobSnapshot("shared-complete", SharedEstimationJobState.Completed,
+            null, completion, [], "completed-estimation", "/runs/completed-estimation", "model-hash",
+            [new SharedEstimationParameterMetadata(18, "Mode share", 0, 1)]);
+
+        var run = new RunViewModel(snapshot, "Remote Orchestrator", () => { });
+
+        Assert.AreEqual(RunStatus.Finished, run.Status);
+        Assert.IsTrue(run.HasOptimizationResults);
+        Assert.IsTrue(run.IsRecoveredRunUnbound);
+        Assert.IsFalse(run.ApplyOptimizationResultsCommand.CanExecute(null));
+    }
+
+    [TestMethod]
+    public void DisconnectedEstimationWorker_IsMarkedInactiveAndReaddedAfterReconnect()
+    {
+        TestGuiHelper.RunInModelSystemContext(nameof(DisconnectedEstimationWorker_IsMarkedInactiveAndReaddedAfterReconnect),
+            (user, _, session) =>
+            {
+                var run = new RunViewModel("shared-worker-reconnect", "estimation", string.Empty,
+                    "coordinator", session, user);
+                var endpoint = new RunServerEndpoint { Id = "worker-1", Name = "Worker 1" };
+                var addRequests = 0;
+                run.SetRunMode(RunMode.Estimation,
+                    Array.Empty<(int nodeIndex, string name, double min, double max)>(), () => { });
+                run.SetRemoteEstimationWorkers([endpoint], [endpoint.Id], _ =>
+                {
+                    addRequests++;
+                    return null;
+                }, _ => null);
+
+                run.MarkRemoteWorkerDisconnected(endpoint.Id);
+
+                Assert.IsFalse(run.RemoteWorkers.Single().IsActive);
+                run.ReconnectRemoteWorker(endpoint.Id);
+
+                Assert.AreEqual(1, addRequests);
+                Assert.IsTrue(run.RemoteWorkers.Single().IsBusy);
+                run.ApplyRemoteWorkerAcknowledgement(new SharedEstimationWorkerControlAcknowledgement(
+                    run.RunId, endpoint.Id, Add: true, Succeeded: true, Error: null, ActiveWorkerCount: 1));
+                Assert.IsTrue(run.RemoteWorkers.Single().IsActive);
+                Assert.IsFalse(run.RemoteWorkers.Single().IsBusy);
+            });
+    }
+
+    [TestMethod]
+    public void ConnectionLostRun_IsInterruptedAndRestoredWhenRecoverySnapshotIsRunning()
+    {
+        var remoteSnapshot = new RemoteRunSnapshot("run-reconnect-state", "forecast", RunMode.Normal,
+            "/remote/runs/forecast", "Start", "model-hash", RemoteRunState.Running,
+            "Run is executing.", 0, double.NaN, Array.Empty<RemoteRunParameterValue>(), null,
+            null, null, false, DateTimeOffset.UtcNow);
+        var remoteRun = new RunViewModel(remoteSnapshot, "Remote Server");
+
+        remoteRun.MarkConnectionLost();
+
+        Assert.AreEqual(RunStatus.Interrupted, remoteRun.Status);
+        remoteRun.ApplyRecoveredSnapshot(remoteSnapshot);
+        Assert.AreEqual(RunStatus.Running, remoteRun.Status);
+
+        var sharedSnapshot = new SharedEstimationJobSnapshot("shared-reconnect-state",
+            SharedEstimationJobState.Running, null, null, ["worker-1"], "estimation",
+            "/remote/runs/estimation", "model-hash");
+        var sharedRun = new RunViewModel(sharedSnapshot, "Remote Coordinator", () => { });
+
+        sharedRun.MarkConnectionLost();
+
+        Assert.AreEqual(RunStatus.Interrupted, sharedRun.Status);
+        sharedRun.ApplyRecoveredSharedEstimationSnapshot(sharedSnapshot);
+        Assert.AreEqual(RunStatus.Running, sharedRun.Status);
+    }
+}
diff --git a/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationCoordinator.cs b/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationCoordinator.cs
new file mode 100644
index 00000000..04f8b6f6
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationCoordinator.cs
@@ -0,0 +1,229 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
+
+namespace XTMF2.UnitTests.Bus.Optimization;
+
+[TestClass]
+public class TestSharedEstimationCoordinator
+{
+    [TestMethod]
+    public async Task EvaluateAsync_DispatchesAcrossWorkersAndPreservesCandidateOrder()
+    {
+        using var coordinator = new SharedEstimationCoordinator();
+        using var first = new FakeWorker("worker-1");
+        using var second = new FakeWorker("worker-2");
+        Assert.IsTrue(coordinator.AddWorker(first, out var error), error);
+        Assert.IsTrue(coordinator.AddWorker(second, out error), error);
+
+        var candidates = new[]
+        {
+            Candidate("candidate-1"),
+            Candidate("candidate-2"),
+            Candidate("candidate-3")
+        };
+        var completed = new ConcurrentQueue<(string WorkerId, SharedEstimationEvaluationResult Result)>();
+        var evaluation = coordinator.EvaluateAsync(candidates,
+            evaluationCompleted: (workerId, _, result) => completed.Enqueue((workerId, result)));
+
+        WaitFor(() => first.Sent.Count == 1 && second.Sent.Count == 1);
+        Assert.HasCount(1, first.Sent);
+        Assert.HasCount(1, second.Sent);
+        Assert.AreEqual("candidate-1", first.Sent.Single().CandidateId);
+        Assert.AreEqual("candidate-2", second.Sent.Single().CandidateId);
+
+        second.Complete("candidate-2", 2.0);
+        WaitFor(() => completed.Count == 1 && second.Sent.Count == 2);
+        Assert.HasCount(1, completed);
+        Assert.AreEqual("candidate-3", second.Sent.Last().CandidateId);
+        first.Complete("candidate-1", 1.0);
+        WaitFor(() => completed.Count == 2);
+        Assert.HasCount(2, completed);
+        second.Complete("candidate-3", 3.0);
+        Assert.HasCount(3, completed);
+
+        var results = await evaluation;
+        Assert.HasCount(3, results);
+        CollectionAssert.AreEquivalent(new[] { "worker-1", "worker-2", "worker-2" },
+            completed.Select(item => item.WorkerId).ToArray());
+        CollectionAssert.AreEqual(
+            new[] { "candidate-1", "candidate-2", "candidate-3" },
+            results.Select(result => result.CandidateId).ToArray());
+    }
+
+    [TestMethod]
+    public async Task EvaluateAsync_SlowWorkerDoesNotBlockOtherWorkerDispatchOrRefill()
+    {
+        using var coordinator = new SharedEstimationCoordinator();
+        using var slowWorker = new FakeWorker("slow-worker");
+        using var remote = new FakeWorker("remote");
+        using var slowWorkerStarted = new ManualResetEventSlim();
+        using var releaseSlowWorker = new ManualResetEventSlim();
+        using var remoteReceivedCandidate = new ManualResetEventSlim();
+        slowWorker.OnSend = _ =>
+        {
+            slowWorkerStarted.Set();
+            releaseSlowWorker.Wait();
+        };
+        remote.OnSend = _ => remoteReceivedCandidate.Set();
+        Assert.IsTrue(coordinator.AddWorker(slowWorker, out var error), error);
+        Assert.IsTrue(coordinator.AddWorker(remote, out error), error);
+
+        var evaluation = coordinator.EvaluateAsync([
+            Candidate("candidate-1"),
+            Candidate("candidate-2"),
+            Candidate("candidate-3")
+        ]);
+
+        Assert.IsTrue(slowWorkerStarted.Wait(TimeSpan.FromSeconds(3)), "The slow worker should receive its candidate.");
+        Assert.IsTrue(remoteReceivedCandidate.Wait(TimeSpan.FromSeconds(3)),
+            "The slow worker must not block dispatch to the remote worker.");
+        remote.Complete("candidate-2", 2.0);
+        WaitFor(() => remote.Sent.Count == 2);
+        Assert.AreEqual("candidate-3", remote.Sent[1].CandidateId,
+            "The remote worker should be refilled while the other worker remains blocked.");
+        remote.Complete("candidate-3", 3.0);
+        releaseSlowWorker.Set();
+        slowWorker.Complete("candidate-1", 1.0);
+        Assert.HasCount(3, await evaluation);
+    }
+
+    [TestMethod]
+    public async Task EvaluateAsync_RequeuesAssignedCandidateAfterDisconnect()
+    {
+        using var coordinator = new SharedEstimationCoordinator();
+        using var first = new FakeWorker("worker-1");
+        using var replacement = new FakeWorker("worker-2");
+        using var finalWorker = new FakeWorker("worker-3");
+        Assert.IsTrue(coordinator.AddWorker(first, out var error), error);
+        Assert.IsTrue(coordinator.AddWorker(replacement, out error), error);
+
+        var evaluation = coordinator.EvaluateAsync([Candidate("candidate-1")]);
+        WaitFor(() => first.Sent.Count == 1);
+        first.Disconnect();
+        Assert.AreEqual(1, coordinator.ActiveWorkerCount);
+
+        WaitFor(() => replacement.Sent.Count == 1);
+        Assert.AreEqual("candidate-1", replacement.Sent.Single().CandidateId);
+        first.Complete("candidate-1", 99.0);
+        replacement.Disconnect();
+        Assert.IsTrue(coordinator.AddWorker(finalWorker, out error), error);
+        WaitFor(() => finalWorker.Sent.Count == 1);
+        Assert.AreEqual("candidate-1", finalWorker.Sent.Single().CandidateId);
+        finalWorker.Complete("candidate-1", 4.0);
+
+        var result = (await evaluation).Single();
+        Assert.AreEqual("candidate-1", result.CandidateId);
+        Assert.AreEqual(4.0, result.Fitness);
+    }
+
+    [TestMethod]
+    public async Task EvaluateAsync_RequeuesCandidateWhenWorkerSendThrows()
+    {
+        using var coordinator = new SharedEstimationCoordinator();
+        using var failedWorker = new FakeWorker("worker-failed")
+        {
+            SendException = new InvalidOperationException("Stream was not writable.")
+        };
+        using var replacement = new FakeWorker("worker-replacement");
+        Assert.IsTrue(coordinator.AddWorker(failedWorker, out var error), error);
+
+        var evaluation = coordinator.EvaluateAsync([Candidate("candidate-send-error")]);
+
+        WaitFor(() => failedWorker.IsDisposed);
+        Assert.IsTrue(failedWorker.IsDisposed);
+        Assert.AreEqual(0, coordinator.ActiveWorkerCount);
+        Assert.IsFalse(evaluation.IsCompleted);
+        Assert.IsTrue(coordinator.AddWorker(replacement, out error), error);
+        WaitFor(() => replacement.Sent.Count == 1);
+        Assert.AreEqual("candidate-send-error", replacement.Sent.Single().CandidateId);
+        replacement.Complete("candidate-send-error", 6.0);
+
+        var result = (await evaluation).Single();
+        Assert.AreEqual(6.0, result.Fitness);
+    }
+
+    [TestMethod]
+    public async Task EvaluateAsync_DistributesSequentialCandidatesRoundRobin()
+    {
+        using var coordinator = new SharedEstimationCoordinator();
+        using var first = new FakeWorker("worker-1");
+        using var second = new FakeWorker("worker-2");
+        Assert.IsTrue(coordinator.AddWorker(first, out var error), error);
+        Assert.IsTrue(coordinator.AddWorker(second, out error), error);
+
+        var firstEvaluation = coordinator.EvaluateAsync([Candidate("candidate-1")]);
+        WaitFor(() => first.Sent.Count == 1);
+        first.Complete("candidate-1", 1.0);
+        await firstEvaluation;
+
+        var secondEvaluation = coordinator.EvaluateAsync([Candidate("candidate-2")]);
+        WaitFor(() => second.Sent.Count == 1);
+        Assert.AreEqual("candidate-2", second.Sent.Single().CandidateId);
+        second.Complete("candidate-2", 2.0);
+        await secondEvaluation;
+
+        var nextFirstEvaluation = coordinator.EvaluateAsync([Candidate("candidate-3")]);
+        WaitFor(() => first.Sent.Count == 2);
+        Assert.AreEqual("candidate-3", first.Sent.Last().CandidateId);
+        first.Complete("candidate-3", 3.0);
+        await nextFirstEvaluation;
+    }
+
+    private static SharedEstimationCandidate Candidate(string id)
+        => new("run-1", 1, id, new[] { 1.0 });
+
+    private static void WaitFor(Func<bool> condition)
+        => Assert.IsTrue(SpinWait.SpinUntil(condition, TimeSpan.FromSeconds(3)),
+            "Expected worker dispatch or result callback did not occur in time.");
+
+    private sealed class FakeWorker(string workerId) : ISharedEstimationWorker
+    {
+        private readonly object _sync = new();
+        private readonly List<SharedEstimationCandidate> _sent = [];
+
+        public string WorkerId { get; } = workerId;
+        public IReadOnlyList<SharedEstimationCandidate> Sent
+        {
+            get
+            {
+                lock (_sync)
+                    return _sent.ToArray();
+            }
+        }
+        public bool IsDisposed { get; private set; }
+        public Exception SendException { get; init; } = null!;
+        public Action<SharedEstimationCandidate> OnSend { get; set; } = null!;
+
+        public event EventHandler<SharedEstimationEvaluationResult> ResultReceived;
+        public event EventHandler Disconnected;
+
+        public bool SendCandidate(SharedEstimationCandidate candidate, out string error)
+        {
+            if (SendException is not null)
+                throw SendException;
+            error = null;
+            lock (_sync)
+                _sent.Add(candidate);
+            OnSend?.Invoke(candidate);
+            return !IsDisposed;
+        }
+
+        public void Complete(string candidateId, double fitness)
+        {
+            var candidate = Sent.Single(candidate => candidate.CandidateId == candidateId);
+            ResultReceived?.Invoke(this, new SharedEstimationEvaluationResult(
+                candidate.RunId, candidate.BatchId, candidate.CandidateId, fitness, null, null, null));
+        }
+
+        public void Disconnect() => Disconnected?.Invoke(this, EventArgs.Empty);
+
+        public void Dispose() => IsDisposed = true;
+    }
+}
diff --git a/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationEndToEnd.cs b/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationEndToEnd.cs
new file mode 100644
index 00000000..9fe0cc39
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationEndToEnd.cs
@@ -0,0 +1,364 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
+using XTMF2.Editing;
+using XTMF2.ModelSystemConstruct;
+using XTMF2.RuntimeModules;
+using XTMF2.UnitTests.Modules;
+using static XTMF2.UnitTests.TestHelper;
+
+namespace XTMF2.UnitTests.Bus.Optimization;
+
+[TestClass]
+public class TestSharedEstimationEndToEnd
+{
+    [TestMethod]
+    public void LocalRunServerCoordinator_CanEvaluateAsItsOwnWorker()
+    {
+        RunInModelSystemContext(nameof(LocalRunServerCoordinator_CanEvaluateAsItsOwnWorker),
+            (user, projectSession, session) =>
+            {
+                XTMF2.Editing.CommandError error = null;
+                var modelSystem = session.ModelSystem;
+                Assert.IsTrue(session.AddModelSystemStart(user, modelSystem.GlobalBoundary, "Start",
+                    Rectangle.Hidden, out Start start, out error), error?.Message);
+                Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Ignore",
+                    typeof(IgnoreResult<string>), Rectangle.Hidden, out var ignore, out error), error?.Message);
+                Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Action",
+                    typeof(SimpleTestModule), Rectangle.Hidden, out var action, out error), error?.Message);
+                Assert.IsTrue(session.AddLink(user, start, start.Hooks[0], ignore, out _, out error), error?.Message);
+                Assert.IsTrue(session.AddLink(user, ignore, ignore.Hooks[0], action, out _, out error), error?.Message);
+                Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Fitness",
+                    typeof(BasicParameter<float>), Rectangle.Hidden, out var fitness, out error), error?.Message);
+                Assert.IsTrue(session.SetParameterValue(user, fitness, "2.5", out error), error?.Message);
+                Assert.IsTrue(session.SetEstimationFitnessNode(user, fitness, out error), error?.Message);
+                Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Parameter",
+                    typeof(SetableParameter<float>), Rectangle.Hidden, out var parameter, out error), error?.Message);
+                Assert.IsTrue(session.SetParameterValue(user, parameter, "0.5", out error), error?.Message);
+                Assert.IsTrue(session.AddEstimationGroup(user, "Group", out var group, out error), error?.Message);
+                Assert.IsTrue(session.AddEstimationParameter(user, group!, parameter,
+                    0.0, 1.0, 0.5, out _, out error), error?.Message);
+
+                using var serialized = new MemoryStream();
+                Assert.IsTrue(session.Save(out error, serialized), error?.Message);
+                var runId = Guid.NewGuid().ToString("N");
+                var runDirectory = Path.Combine(Path.GetTempPath(), "XTMF2-LocalCoordinator", runId);
+                Directory.CreateDirectory(runDirectory);
+                var config = modelSystem.EstimationAlgorithmConfig;
+                var metadata = session.GetOptimizationParameterMeta(RunMode.Estimation);
+                var request = new SharedEstimationCoordinatorRequest(
+                    new SharedEstimationRunRequest(runId, runDirectory, "Start", serialized.ToArray(),
+                        ProjectId: Guid.NewGuid(), ModelSystemId: Guid.NewGuid()),
+                    Array.Empty<SharedEstimationWorkerEndpoint>(),
+                    config.AlgorithmId,
+                    config.GetParameters(),
+                    metadata.Select(item => item.min).ToArray(),
+                    metadata.Select(item => item.max).ToArray(),
+                    metadata.Select(item => 0.5).ToArray(),
+                    IsMaximize: false,
+                    UseCoordinatorAsWorker: true,
+                    Parameters: metadata.Select(item => new SharedEstimationParameterMetadata(
+                        item.nodeIndex, item.name, item.min, item.max)).ToArray(),
+                    CoordinatorConcurrentRuns: 2);
+
+                try
+                {
+                    CreateRunClient(true, host =>
+                    {
+                        var statuses = new List<string>();
+                        var progressUpdates = new List<SharedEstimationProgress>();
+                        var completion = new TaskCompletionSource<SharedEstimationCompletion>(
+                            TaskCreationOptions.RunContinuationsAsynchronously);
+                        host.SharedEstimationStatusAvailable += (_, status) =>
+                        {
+                            if (status.RunId == runId)
+                                statuses.Add(status.Message);
+                        };
+                        host.SharedEstimationProgressAvailable += (_, progress) =>
+                        {
+                            if (progress.RunId == runId)
+                                progressUpdates.Add(progress);
+                        };
+                        host.SharedEstimationCompleted += (_, result) =>
+                        {
+                            if (result.RunId == runId)
+                                completion.TrySetResult(result);
+                        };
+                        Assert.IsTrue(host.StartRemoteSharedEstimation(request, out var startError), startError?.Message);
+                        Assert.IsTrue(completion.Task.Wait(TimeSpan.FromSeconds(30)),
+                            $"The local coordinator did not report completion. Statuses: {string.Join(" | ", statuses)}; " +
+                            $"progress updates: {progressUpdates.Count}.");
+                        Assert.IsTrue(completion.Task.Result.Succeeded, completion.Task.Result.FailureReason);
+                        Assert.AreEqual(2.5, completion.Task.Result.BestFitness, 0.0001);
+                        Assert.IsTrue(progressUpdates.Any(progress => progress.ActiveWorkers == 2));
+                        Assert.IsTrue(File.Exists(Path.Combine(runDirectory, "estimation_report.csv")));
+                        Assert.IsFalse(Directory.Exists(Path.Combine(runDirectory,
+                            ".xtmf-estimation-workers")), "Worker scratch directories should be removed before completion is reported.");
+                    });
+                }
+                finally
+                {
+                    if (Directory.Exists(runDirectory))
+                        Directory.Delete(runDirectory, recursive: true);
+                }
+            });
+    }
+
+    [TestMethod]
+    public void RunServerActivityQuery_IncludesSharedEstimationWorkerAssignment()
+    {
+        RunInModelSystemContext(nameof(RunServerActivityQuery_IncludesSharedEstimationWorkerAssignment),
+            (user, projectSession, session) =>
+        {
+            CommandError error = null;
+            var modelSystem = session.ModelSystem;
+            Assert.IsTrue(session.AddModelSystemStart(user, modelSystem.GlobalBoundary, "Start",
+                Rectangle.Hidden, out Start start, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Ignore",
+                typeof(IgnoreResult<string>), Rectangle.Hidden, out var ignore, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Action",
+                typeof(SimpleTestModule), Rectangle.Hidden, out var action, out error), error?.Message);
+            Assert.IsTrue(session.AddLink(user, start, start.Hooks[0], ignore, out _, out error), error?.Message);
+            Assert.IsTrue(session.AddLink(user, ignore, ignore.Hooks[0], action, out _, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Fitness",
+                typeof(BasicParameter<float>), Rectangle.Hidden, out var fitness, out error), error?.Message);
+            Assert.IsTrue(session.SetParameterValue(user, fitness, "2.5", out error), error?.Message);
+            Assert.IsTrue(session.SetEstimationFitnessNode(user, fitness, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Parameter",
+                typeof(SetableParameter<float>), Rectangle.Hidden, out var parameter, out error), error?.Message);
+            Assert.IsTrue(session.SetParameterValue(user, parameter, "0.5", out error), error?.Message);
+            Assert.IsTrue(session.AddEstimationGroup(user, "Group", out var group, out error), error?.Message);
+            Assert.IsTrue(session.AddEstimationParameter(user, group!, parameter,
+                0.0, 1.0, 0.5, out _, out error), error?.Message);
+
+            using var serialized = new MemoryStream();
+            Assert.IsTrue(session.Save(out error, serialized), error?.Message);
+            var workerRoot = Directory.CreateTempSubdirectory("xtmf-worker-cancel-");
+            try
+            {
+                var request = new SharedEstimationRunRequest(
+                    "worker-activity", workerRoot.FullName, "Start", serialized.ToArray());
+                CreateRunClient(true, host =>
+                {
+                    var ready = new TaskCompletionSource<SharedEstimationWorkerReady>(
+                        TaskCreationOptions.RunContinuationsAsynchronously);
+                    host.SharedEstimationWorkerReadyAvailable += (_, workerReady) =>
+                    {
+                        if (workerReady.RunId == request.RunId)
+                            ready.TrySetResult(workerReady);
+                    };
+                    Assert.IsTrue(host.StartSharedEstimation(request, out var startError), startError?.Message);
+                    Assert.IsTrue(ready.Task.Wait(TimeSpan.FromSeconds(10)), "The worker process did not become ready.");
+                    Assert.IsTrue(ready.Task.Result.Succeeded, ready.Task.Result.Error);
+
+                    var responses = Task.WhenAll(host.QueryServerActivityAsync(), host.QueryServerActivityAsync())
+                        .GetAwaiter().GetResult();
+
+                    Assert.AreNotEqual(responses[0].RequestId, responses[1].RequestId);
+                    var activity = responses[0].Activities.Single(item => item.RunId == request.RunId);
+                    Assert.AreEqual("Shared estimation worker", activity.Kind);
+                    Assert.AreEqual(RunServerActivityState.Running, activity.State);
+                    Assert.AreEqual("Shared estimation worker", activity.RunName);
+                    Assert.IsTrue(host.CancelSharedEstimation(request.RunId, "test complete", out var cancelError),
+                        cancelError?.Message);
+                    Assert.IsTrue(SpinWait.SpinUntil(() => !Directory.Exists(Path.Combine(
+                            workerRoot.FullName, ".xtmf-estimation-workers")),
+                        TimeSpan.FromSeconds(5)), "Cancellation should delete worker scratch directories.");
+                });
+            }
+            finally
+            {
+                workerRoot.Delete(true);
+            }
+        });
+    }
+
+    [TestMethod]
+    public void CoordinatorEvaluatesBatchAcrossTwoRunServers()
+    {
+        RunInModelSystemContext("SharedEstimationEndToEnd", (user, _, session) =>
+        {
+            CommandError error = null;
+            var modelSystem = session.ModelSystem;
+            Assert.IsTrue(session.AddModelSystemStart(user, modelSystem.GlobalBoundary, "Start",
+                Rectangle.Hidden, out Start start, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Ignore",
+                typeof(IgnoreResult<string>), Rectangle.Hidden, out var ignore, out error), error?.Message);
+            Assert.IsTrue(session.AddNodeGenerateParameters(user, modelSystem.GlobalBoundary, "Action",
+                typeof(PathValidationModule), Rectangle.Hidden, out var action, out var actionParameters, out error), error?.Message);
+            var pathParameter = actionParameters.Single(parameter => parameter.Name == "Path");
+            var workerRoot = Directory.CreateTempSubdirectory("xtmf-shared-e2e-");
+            var firstPath = Path.Combine(workerRoot.FullName, "worker-one.input");
+            var secondPath = Path.Combine(workerRoot.FullName, "worker-two.input");
+            File.WriteAllText(firstPath, "worker one");
+            File.WriteAllText(secondPath, "worker two");
+            Assert.IsTrue(session.SetParameterValue(user, pathParameter, "missing.input", out error), error?.Message);
+            Assert.IsTrue(session.AddLink(user, start, start.Hooks[0], ignore, out var firstLink, out error), error?.Message);
+            Assert.IsTrue(session.AddLink(user, ignore, ignore.Hooks[0], action, out var secondLink, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Fitness",
+                typeof(BasicParameter<float>), Rectangle.Hidden, out var fitness, out error), error?.Message);
+            Assert.IsTrue(session.SetParameterValue(user, fitness, "2.5", out error), error?.Message);
+            Assert.IsTrue(session.SetEstimationFitnessNode(user, fitness, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Parameter",
+                typeof(SetableParameter<float>), Rectangle.Hidden, out var parameter, out error), error?.Message);
+            Assert.IsTrue(session.SetParameterValue(user, parameter, "0.5", out error), error?.Message);
+            Assert.IsTrue(session.AddEstimationGroup(user, "Group", out var group, out error), error?.Message);
+            Assert.IsTrue(session.AddEstimationParameter(user, group!, parameter,
+                0.0, 1.0, 0.5, out var entry, out error), error?.Message);
+
+            using var serialized = new MemoryStream();
+            Assert.IsTrue(session.Save(out error, serialized), error?.Message);
+            var pathNodeIndex = FindSerializedNodeIndex(serialized.ToArray(), "Path");
+            var request = new SharedEstimationRunRequest(
+                "shared-e2e", workerRoot.FullName, "Start", serialized.ToArray());
+            var overrides = new Dictionary<string, IReadOnlyDictionary<int, string>>
+            {
+                ["worker-1"] = new Dictionary<int, string> { [pathNodeIndex] = firstPath },
+                ["worker-2"] = new Dictionary<int, string> { [pathNodeIndex] = secondPath }
+            };
+
+            try
+            {
+                CreateRunClient(true, firstHost =>
+                {
+                    CreateRunClient(true, secondHost =>
+                    {
+                        using var pool = new SharedEstimationWorkerPool();
+                        Assert.IsTrue(pool.AddExistingWorker("worker-1", "worker-1", firstHost, out var poolError), poolError);
+                        Assert.IsTrue(pool.AddExistingWorker("worker-2", "worker-2", secondHost, out poolError), poolError);
+                        Assert.IsTrue(pool.StartRun(request, out poolError, overrides), poolError);
+                        Assert.IsTrue(SpinWait.SpinUntil(() => pool.WorkerCount == 2,
+                            TimeSpan.FromSeconds(10)), "Both RunServers should report readiness before evaluation starts.");
+
+                        var algorithm = new FixedBatchAlgorithm();
+                        var reportPath = Path.Combine(workerRoot.FullName, "estimation_report.csv");
+                        var runner = new SharedEstimationCoordinatorRun(
+                            request.RunId, algorithm, pool.Coordinator,
+                            reportPath: reportPath, parameterNames: ["Fare, USD"]);
+                        var progressUpdates = new List<SharedEstimationProgress>();
+                        var completion = runner.Execute(progressUpdates.Add);
+
+                        Assert.IsTrue(completion.Succeeded, completion.FailureReason);
+                        Assert.AreEqual(4, completion.TotalEvaluations);
+                        Assert.AreEqual(2.5, completion.BestFitness, 0.0001);
+                        Assert.AreEqual(1, completion.Iterations);
+                        Assert.IsGreaterThanOrEqualTo(4, progressUpdates.Count);
+                        Assert.IsTrue(progressUpdates.All(progress => double.IsFinite(progress.BestFitness)));
+                        Assert.AreEqual(2.5, progressUpdates[0].BestFitness, 0.0001);
+                        CollectionAssert.AreEqual(new[] { 1, 2, 3, 4 },
+                            progressUpdates.Take(4).Select(progress => progress.EvaluationsCompleted).ToArray());
+                        var finalProgress = progressUpdates.Last();
+                        Assert.AreEqual(4, finalProgress.EvaluationsByWorker.Values.Sum());
+                        CollectionAssert.AreEquivalent(new[] { "worker-1", "worker-2" },
+                            finalProgress.EvaluationsByWorker.Keys.ToArray());
+                        CollectionAssert.AreEqual(new[] { 0.1 }, finalProgress.BestParameters.ToArray());
+                        var reportLines = File.ReadAllLines(reportPath);
+                        Assert.AreEqual("Iteration,Fitness,\"Fare, USD\"", reportLines[0]);
+                        Assert.HasCount(5, reportLines);
+                        Assert.IsTrue(reportLines.Skip(1).All(line => line.StartsWith("1,2.5,", StringComparison.Ordinal)));
+                        CollectionAssert.AreEquivalent(new[] { "0.1", "0.2", "0.3", "0.4" },
+                            reportLines.Skip(1).Select(line => line.Split(',')[2]).ToArray());
+                        pool.Dispose();
+                        Assert.IsTrue(File.Exists(reportPath), "Coordinator estimation output should remain in the run directory.");
+                        Assert.IsTrue(SpinWait.SpinUntil(() => !Directory.Exists(Path.Combine(
+                                workerRoot.FullName, ".xtmf-estimation-workers")),
+                            TimeSpan.FromSeconds(5)), "Worker scratch directories should be deleted when workers terminate.");
+                    });
+                });
+            }
+            finally
+            {
+                workerRoot.Delete(true);
+            }
+        });
+    }
+
+    private static int FindSerializedNodeIndex(byte[] modelSystem, string nodeName)
+    {
+        using var document = JsonDocument.Parse(modelSystem);
+        foreach (var property in document.RootElement.EnumerateObject())
+        {
+            if (TryFindNodeIndex(property.Value, nodeName, out var index))
+                return index;
+        }
+        Assert.Fail($"Unable to find serialized node '{nodeName}'.");
+        return -1;
+    }
+
+    private static bool TryFindNodeIndex(JsonElement element, string nodeName, out int index)
+    {
+        if (element.ValueKind == JsonValueKind.Object)
+        {
+            if (element.TryGetProperty("Name", out var name)
+                && name.GetString() == nodeName
+                && element.TryGetProperty("Index", out var serializedIndex))
+            {
+                index = serializedIndex.GetInt32();
+                return true;
+            }
+            foreach (var property in element.EnumerateObject())
+            {
+                if (TryFindNodeIndex(property.Value, nodeName, out index))
+                    return true;
+            }
+        }
+        else if (element.ValueKind == JsonValueKind.Array)
+        {
+            foreach (var item in element.EnumerateArray())
+            {
+                if (TryFindNodeIndex(item, nodeName, out index))
+                    return true;
+            }
+        }
+        index = -1;
+        return false;
+    }
+
+    private sealed class FixedBatchAlgorithm : IEstimationAlgorithm
+    {
+        private double[] _bestParameters = Array.Empty<double>();
+        private double _bestFitness = double.MaxValue;
+
+        public string Name => "Fixed batch test algorithm";
+        public double[] BestParameters => _bestParameters;
+        public double BestFitness => _bestFitness;
+
+        public void Initialize(int dimensions, double[] lowerBounds, double[] upperBounds,
+            double[] initialPoint, int maxIterations = 500, double convergenceTolerance = 1e-6,
+            bool isMaximize = false)
+        {
+            _bestParameters = (double[])initialPoint.Clone();
+        }
+
+        public void Run(Func<double[], double> fitnessEvaluator,
+            Action<int, double> progressCallback = null,
+            Func<bool> shouldCancel = null)
+            => RunBatch(fitnessEvaluator, candidates => candidates.Select(fitnessEvaluator).ToArray(),
+                progressCallback, shouldCancel);
+
+        public void RunBatch(Func<double[], double> fitnessEvaluator,
+            Func<IReadOnlyList<double[]>, IReadOnlyList<double>> batchFitnessEvaluator,
+            Action<int, double> progressCallback = null,
+            Func<bool> shouldCancel = null)
+        {
+            var candidates = new[] { new[] { 0.1 }, new[] { 0.2 }, new[] { 0.3 }, new[] { 0.4 } };
+            var fitnesses = batchFitnessEvaluator(candidates);
+            var bestIndex = 0;
+            for (int i = 1; i < fitnesses.Count; i++)
+            {
+                if (fitnesses[i] < fitnesses[bestIndex])
+                    bestIndex = i;
+            }
+            _bestFitness = fitnesses[bestIndex];
+            _bestParameters = (double[])candidates[bestIndex].Clone();
+            progressCallback?.Invoke(1, _bestFitness);
+        }
+    }
+}
diff --git a/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationProtocol.cs b/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationProtocol.cs
new file mode 100644
index 00000000..74f9d6a2
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationProtocol.cs
@@ -0,0 +1,449 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
+
+namespace XTMF2.UnitTests.Bus.Optimization;
+
+[TestClass]
+public class TestSharedEstimationProtocol
+{
+    [TestMethod]
+    public void CoordinatorRequest_RoundTrips()
+    {
+        var projectId = Guid.NewGuid();
+        var modelSystemId = Guid.NewGuid();
+        var ownerUserId = Guid.NewGuid();
+        var request = new SharedEstimationCoordinatorRequest(
+            new SharedEstimationRunRequest("run-remote", "/remote/runs", "Start", [1, 2, 3],
+            ProjectId: projectId, ModelSystemId: modelSystemId, OwnerUserId: ownerUserId, WorkerSlotCount: 3),
+            [new SharedEstimationWorkerEndpoint("worker-1", "endpoint-1", "worker.example", 5000,
+                "token", "fingerprint", new Dictionary<int, string> { [7] = "/worker/input" }, ConcurrentRuns: 3)],
+            "NelderMead",
+            [new AlgorithmParameterDescriptor { Key = "MaxIterations", Label = "Max Iterations", Hint = "limit", Value = "12" }],
+            [0.0], [1.0], [0.5], false, UseCoordinatorAsWorker: false,
+            Parameters: [new SharedEstimationParameterMetadata(7, "Demand", 0.0, 1.0)],
+            CoordinatorConcurrentRuns: 2);
+
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+            SharedEstimationProtocol.WriteCoordinatorRequest(writer, request);
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        var read = SharedEstimationProtocol.ReadCoordinatorRequest(reader);
+        Assert.AreEqual(request.Run.RunId, read.Run.RunId);
+        Assert.AreEqual(request.Workers[0].EndpointId, read.Workers[0].EndpointId);
+        Assert.AreEqual(request.Workers[0].Address, read.Workers[0].Address);
+        Assert.AreEqual(request.Workers[0].Port, read.Workers[0].Port);
+        Assert.AreEqual(3, read.Workers[0].ConcurrentRuns);
+        Assert.AreEqual(request.Workers[0].BasicParameterOverrides![7],
+            read.Workers[0].BasicParameterOverrides![7]);
+        Assert.AreEqual(request.AlgorithmId, read.AlgorithmId);
+        Assert.AreEqual(request.AlgorithmParameters[0].Value, read.AlgorithmParameters[0].Value);
+        Assert.AreEqual(request.InitialValues[0], read.InitialValues[0]);
+        Assert.AreEqual(request.UseCoordinatorAsWorker, read.UseCoordinatorAsWorker);
+        Assert.AreEqual(2, read.CoordinatorConcurrentRuns);
+        Assert.AreEqual(request.Parameters![0], read.Parameters![0]);
+        Assert.AreEqual(projectId, read.Run.ProjectId);
+        Assert.AreEqual(modelSystemId, read.Run.ModelSystemId);
+        Assert.AreEqual(ownerUserId, read.Run.OwnerUserId);
+        Assert.AreEqual(3, read.Run.WorkerSlotCount);
+        Assert.AreEqual(stream.Length, stream.Position);
+    }
+
+    [TestMethod]
+    public void ServerActivityQueryAndSnapshot_RoundTrip()
+    {
+        var activities = new[]
+        {
+            new RunServerActivity("run-queued", "Queued model", "Normal",
+                RunServerActivityState.Queued, "Waiting", QueuePosition: 2),
+            new RunServerActivity("run-estimation", "Shared estimation", "Shared estimation",
+                RunServerActivityState.Running, "Evaluating", Iteration: 4, Fitness: 0.25,
+                ActiveWorkers: 3, EvaluationsCompleted: 12, EvaluationsPending: 2)
+        };
+
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+        {
+            SharedEstimationProtocol.WriteQueryServerActivity(writer, "request-17");
+            SharedEstimationProtocol.WriteServerActivitySnapshots(writer, "request-17", activities);
+        }
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        Assert.AreEqual("request-17", SharedEstimationProtocol.ReadQueryServerActivity(reader));
+        var response = SharedEstimationProtocol.ReadServerActivitySnapshots(reader);
+        Assert.AreEqual("request-17", response.RequestId);
+        CollectionAssert.AreEqual(activities, response.Activities.ToArray());
+    }
+
+    [TestMethod]
+    public void ServerActivitySnapshot_RejectsNegativeCounters()
+    {
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+        {
+            SharedEstimationProtocol.WriteHeader(writer, SharedEstimationMessageType.ServerActivitySnapshots);
+            writer.Write("request-1");
+            writer.Write(1);
+            writer.Write("run-1");
+            writer.Write("Run");
+            writer.Write("Normal");
+            writer.Write((int)RunServerActivityState.Queued);
+            writer.Write("Waiting");
+            writer.Write(-1);
+            writer.Write(0);
+            writer.Write(double.NaN);
+            writer.Write(0);
+            writer.Write(0);
+            writer.Write(0);
+        }
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        Assert.Throws<InvalidDataException>(() => SharedEstimationProtocol.ReadServerActivitySnapshots(reader));
+    }
+
+    [TestMethod]
+    public void RunAndWorkerMessages_RoundTrip()
+    {
+        var run = new SharedEstimationRunRequest(
+            "run-1", "/shared/runs", "Start", new byte[] { 1, 2, 3 },
+            new Dictionary<int, string> { [4] = "/worker/input", [9] = "/worker/output" },
+            Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), WorkerSlotCount: 4);
+        var registration = new SharedEstimationWorkerRegistration("run-1", "worker-1", "server-1");
+
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+        {
+            SharedEstimationProtocol.WriteRunRequest(writer, run);
+            SharedEstimationProtocol.WriteWorkerRegistration(writer, registration, remove: false);
+            SharedEstimationProtocol.WriteWorkerRegistration(writer, registration, remove: true);
+        }
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        var readRun = SharedEstimationProtocol.ReadRunRequest(reader);
+        Assert.AreEqual(run.RunId, readRun.RunId);
+        Assert.AreEqual(run.WorkingDirectory, readRun.WorkingDirectory);
+        Assert.AreEqual(run.StartToExecute, readRun.StartToExecute);
+        Assert.AreEqual(run.ProjectId, readRun.ProjectId);
+        Assert.AreEqual(run.ModelSystemId, readRun.ModelSystemId);
+        Assert.AreEqual(run.OwnerUserId, readRun.OwnerUserId);
+        Assert.AreEqual(run.WorkerSlotCount, readRun.WorkerSlotCount);
+        Assert.HasCount(run.ModelSystem.Length, readRun.ModelSystem);
+        for (int i = 0; i < run.ModelSystem.Length; i++)
+            Assert.AreEqual(run.ModelSystem[i], readRun.ModelSystem[i]);
+        Assert.IsNotNull(readRun.BasicParameterOverrides);
+        Assert.AreEqual(run.BasicParameterOverrides![4], readRun.BasicParameterOverrides[4]);
+        Assert.AreEqual(run.BasicParameterOverrides[9], readRun.BasicParameterOverrides[9]);
+        Assert.AreEqual(registration, SharedEstimationProtocol.ReadWorkerRegistration(reader, remove: false));
+        Assert.AreEqual(registration, SharedEstimationProtocol.ReadWorkerRegistration(reader, remove: true));
+    }
+
+    [TestMethod]
+    public void CandidateResultProgressAndCompletionMessages_RoundTrip()
+    {
+        var candidate = new SharedEstimationCandidate("run-1", 4, "candidate-1", new[] { 1.0, 2.0 });
+        var result = new SharedEstimationEvaluationResult("run-1", 4, "candidate-1", 0.25,
+            "worker failed", "Module", Guid.Parse("11111111-1111-1111-1111-111111111111"));
+        var progress = new SharedEstimationProgress("run-1", 2, 0.25, 3, 1, 2, 2,
+            new Dictionary<string, int> { ["coordinator"] = 1, ["worker-1"] = 2 },
+            new[] { 1.0, 2.0 }, ["worker-1", "worker-1#run-2"]);
+        var status = new SharedEstimationStatus("run-1", "Estimation started with 2 workers.");
+        var completion = new SharedEstimationCompletion("run-1", true, 0.25,
+            new[] { 1.0, 2.0 }, 3, 2, null);
+
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+        {
+            SharedEstimationProtocol.WriteCandidate(writer, candidate);
+            SharedEstimationProtocol.WriteResult(writer, result);
+            SharedEstimationProtocol.WriteProgress(writer, progress);
+            SharedEstimationProtocol.WriteStatus(writer, status);
+            SharedEstimationProtocol.WriteCompletion(writer, completion);
+            SharedEstimationProtocol.WriteCancel(writer, "run-1", "user requested cancellation");
+        }
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        var readCandidate = SharedEstimationProtocol.ReadCandidate(reader);
+        Assert.AreEqual(candidate.RunId, readCandidate.RunId);
+        Assert.AreEqual(candidate.BatchId, readCandidate.BatchId);
+        Assert.AreEqual(candidate.CandidateId, readCandidate.CandidateId);
+        CollectionAssert.AreEqual(candidate.Parameters.ToArray(), readCandidate.Parameters.ToArray());
+        Assert.AreEqual(result, SharedEstimationProtocol.ReadResult(reader));
+
+        var readProgress = SharedEstimationProtocol.ReadProgress(reader);
+        Assert.AreEqual(progress.RunId, readProgress.RunId);
+        Assert.AreEqual(progress.Iteration, readProgress.Iteration);
+        Assert.AreEqual(progress.BestFitness, readProgress.BestFitness);
+        Assert.AreEqual(progress.EvaluationsCompleted, readProgress.EvaluationsCompleted);
+        Assert.AreEqual(progress.EvaluationsPending, readProgress.EvaluationsPending);
+        Assert.AreEqual(progress.ActiveWorkers, readProgress.ActiveWorkers);
+        Assert.AreEqual(progress.FitnessTestsThisIteration, readProgress.FitnessTestsThisIteration);
+        CollectionAssert.AreEquivalent(progress.EvaluationsByWorker.ToArray(),
+            readProgress.EvaluationsByWorker.ToArray());
+        CollectionAssert.AreEqual(progress.BestParameters.ToArray(), readProgress.BestParameters.ToArray());
+        CollectionAssert.AreEquivalent(progress.ActiveWorkerIds.ToArray(), readProgress.ActiveWorkerIds.ToArray());
+        Assert.AreEqual(status, SharedEstimationProtocol.ReadStatus(reader));
+        var readCompletion = SharedEstimationProtocol.ReadCompletion(reader);
+        Assert.AreEqual(completion.RunId, readCompletion.RunId);
+        Assert.AreEqual(completion.Succeeded, readCompletion.Succeeded);
+        Assert.AreEqual(completion.BestFitness, readCompletion.BestFitness);
+        Assert.HasCount(completion.BestParameters.Count, readCompletion.BestParameters);
+        for (int i = 0; i < completion.BestParameters.Count; i++)
+            Assert.AreEqual(completion.BestParameters[i], readCompletion.BestParameters[i]);
+        Assert.AreEqual(completion.TotalEvaluations, readCompletion.TotalEvaluations);
+        Assert.AreEqual(completion.Iterations, readCompletion.Iterations);
+        Assert.AreEqual(completion.FailureReason, readCompletion.FailureReason);
+        Assert.AreEqual(("run-1", "user requested cancellation"), SharedEstimationProtocol.ReadCancel(reader));
+    }
+
+    [TestMethod]
+    public void WorkerReadyMessage_RoundTripsSuccessAndFailure()
+    {
+        var readiness = new[]
+        {
+            new SharedEstimationWorkerReady("run-ready", true, null),
+            new SharedEstimationWorkerReady("run-failed", false, "Model preparation failed.")
+        };
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+        {
+            foreach (var item in readiness)
+                SharedEstimationProtocol.WriteWorkerReady(writer, item);
+        }
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        foreach (var item in readiness)
+            Assert.AreEqual(item, SharedEstimationProtocol.ReadWorkerReady(reader));
+        Assert.AreEqual(stream.Length, stream.Position);
+    }
+
+    [TestMethod]
+    public void RunRequestWithoutOverrides_RoundTripsAsVersionOnePayload()
+    {
+        var run = new SharedEstimationRunRequest("run-legacy", "/shared/runs", "Start", new byte[] { 4, 5 });
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+            SharedEstimationProtocol.WriteRunRequest(writer, run);
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        var readRun = SharedEstimationProtocol.ReadRunRequest(reader);
+
+        Assert.AreEqual(run.RunId, readRun.RunId);
+        Assert.IsNull(readRun.BasicParameterOverrides);
+    }
+
+    [TestMethod]
+    public void Header_RejectsUnsupportedVersionAndUnknownMessage()
+    {
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+        {
+            writer.Write(SharedEstimationProtocol.Version + 1);
+            writer.Write((int)SharedEstimationMessageType.StartRun);
+        }
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        Assert.Throws<InvalidDataException>(() => SharedEstimationProtocol.ReadHeader(reader));
+
+        stream.SetLength(0);
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+        {
+            writer.Write(SharedEstimationProtocol.Version);
+            writer.Write(int.MaxValue);
+        }
+
+        stream.Position = 0;
+        Assert.Throws<InvalidDataException>(() => SharedEstimationProtocol.ReadHeader(reader));
+    }
+
+    [TestMethod]
+    public void RemoteRunReconnectMessages_RoundTrip()
+    {
+        var timestamp = DateTimeOffset.UtcNow;
+        var projectId = Guid.NewGuid();
+        var modelSystemId = Guid.NewGuid();
+        var ownerUserId = Guid.NewGuid();
+        var snapshots = new[]
+        {
+            new RemoteRunSnapshot("run-1", "forecast", RunMode.Normal, "/runs/forecast", "Start",
+                "model-hash", RemoteRunState.Running, "Iteration 4", 4, 1.25,
+                [new RemoteRunParameterValue(3, 0.75)], null, null, null, false, timestamp,
+                projectId, modelSystemId, ownerUserId),
+            new RemoteRunSnapshot("run-2", "calibration", RunMode.Calibration, "/runs/calibration", "Start",
+                "model-hash-2", RemoteRunState.Completed, "Complete", 8, 0.01,
+                [], [new RemoteRunParameterValue(5, 1.1)], null, null, true, timestamp)
+        };
+        var archive = new byte[] { 4, 5, 6, 7 };
+
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+        {
+            SharedEstimationProtocol.WriteQueryRemoteRuns(writer);
+            SharedEstimationProtocol.WriteRemoteRunSnapshots(writer, snapshots);
+            SharedEstimationProtocol.WriteGetRemoteRunArtifacts(writer, "run-2");
+            SharedEstimationProtocol.WriteRemoteRunArtifacts(writer, "run-2", archive);
+            SharedEstimationProtocol.WriteAcknowledgeRemoteRun(writer, "run-2");
+        }
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        SharedEstimationProtocol.ReadQueryRemoteRuns(reader);
+        var readSnapshots = SharedEstimationProtocol.ReadRemoteRunSnapshots(reader);
+        Assert.HasCount(2, readSnapshots);
+        Assert.AreEqual(snapshots[0].RunId, readSnapshots[0].RunId);
+        Assert.AreEqual(snapshots[0].RunMode, readSnapshots[0].RunMode);
+        Assert.AreEqual(snapshots[0].ModelSystemHash, readSnapshots[0].ModelSystemHash);
+        Assert.AreEqual(snapshots[0].ProgressParameters[0], readSnapshots[0].ProgressParameters[0]);
+        Assert.AreEqual(snapshots[1].State, readSnapshots[1].State);
+        Assert.AreEqual(snapshots[1].OptimizationResults![0], readSnapshots[1].OptimizationResults![0]);
+        Assert.AreEqual(snapshots[1].UpdatedAt, readSnapshots[1].UpdatedAt);
+        Assert.AreEqual(projectId, readSnapshots[0].ProjectId);
+        Assert.AreEqual(modelSystemId, readSnapshots[0].ModelSystemId);
+        Assert.AreEqual(ownerUserId, readSnapshots[0].OwnerUserId);
+        Assert.AreEqual("run-2", SharedEstimationProtocol.ReadGetRemoteRunArtifacts(reader));
+        var response = SharedEstimationProtocol.ReadRemoteRunArtifacts(reader);
+        Assert.AreEqual("run-2", response.RunId);
+        CollectionAssert.AreEqual(archive, response.Archive);
+        Assert.IsNull(response.Error);
+        Assert.AreEqual("run-2", SharedEstimationProtocol.ReadAcknowledgeRemoteRun(reader));
+    }
+
+    [TestMethod]
+    public void RemoteRunDeletionMessages_RoundTrip()
+    {
+        var expected = new RemoteRunDeletionResponse("request-1", "run-2", false,
+            "The run output directory could not be removed.");
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+        {
+            SharedEstimationProtocol.WriteDeleteRemoteRun(writer, expected.RequestId, expected.RunId);
+            SharedEstimationProtocol.WriteRemoteRunDeleted(writer, expected);
+        }
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        var request = SharedEstimationProtocol.ReadDeleteRemoteRun(reader);
+        Assert.AreEqual(expected.RequestId, request.RequestId);
+        Assert.AreEqual(expected.RunId, request.RunId);
+        Assert.AreEqual(expected, SharedEstimationProtocol.ReadRemoteRunDeleted(reader));
+    }
+
+    [TestMethod]
+    public void JobSnapshots_RoundTrip()
+    {
+        var projectId = Guid.NewGuid();
+        var modelSystemId = Guid.NewGuid();
+        var ownerUserId = Guid.NewGuid();
+        var progress = new SharedEstimationProgress("run-active", 4, 1.25, 8, 2, 3);
+        var completion = new SharedEstimationCompletion("run-complete", true, 0.5,
+            new[] { 0.25, 0.75 }, 12, 6, null);
+        var snapshots = new[]
+        {
+            new SharedEstimationJobSnapshot("run-active", SharedEstimationJobState.Running, progress, null,
+                ["worker-1"], "active-estimation", "/runs/active", "active-hash",
+                [new SharedEstimationParameterMetadata(4, "Transit cost", 0, 10)], projectId, modelSystemId, ownerUserId,
+                new Dictionary<string, int> { ["worker-1"] = 3 }),
+            new SharedEstimationJobSnapshot("run-complete", SharedEstimationJobState.Completed, null, completion,
+                ["worker-2"], "completed-estimation", "/runs/completed", "completed-hash",
+                [new SharedEstimationParameterMetadata(8, "Wait time", 0, 20)])
+        };
+
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+            SharedEstimationProtocol.WriteJobSnapshots(writer, snapshots);
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        var read = SharedEstimationProtocol.ReadJobSnapshots(reader);
+        Assert.HasCount(2, read);
+        Assert.AreEqual(SharedEstimationJobState.Running, read[0].State);
+        Assert.AreEqual(progress.RunId, read[0].Progress!.RunId);
+        Assert.AreEqual(progress.Iteration, read[0].Progress.Iteration);
+        Assert.AreEqual(progress.BestFitness, read[0].Progress.BestFitness);
+        Assert.AreEqual(progress.EvaluationsCompleted, read[0].Progress.EvaluationsCompleted);
+        Assert.IsNull(read[0].Completion);
+        Assert.AreEqual("active-estimation", read[0].RunName);
+        Assert.AreEqual("/runs/active", read[0].WorkingDirectory);
+        Assert.AreEqual("active-hash", read[0].ModelSystemHash);
+        CollectionAssert.AreEqual(new[] { "worker-1" }, read[0].ActiveWorkerIds!.ToArray());
+        Assert.AreEqual(new SharedEstimationParameterMetadata(4, "Transit cost", 0, 10), read[0].Parameters![0]);
+        Assert.AreEqual(projectId, read[0].ProjectId);
+        Assert.AreEqual(ownerUserId, read[0].OwnerUserId);
+        Assert.AreEqual(modelSystemId, read[0].ModelSystemId);
+        Assert.AreEqual(3, read[0].ConfiguredWorkerCounts!["worker-1"]);
+        Assert.AreEqual(SharedEstimationJobState.Completed, read[1].State);
+        Assert.IsNull(read[1].Progress);
+        Assert.IsNotNull(read[1].Completion);
+        Assert.AreEqual(completion.RunId, read[1].Completion.RunId);
+        Assert.AreEqual(completion.Succeeded, read[1].Completion.Succeeded);
+        Assert.AreEqual(completion.BestFitness, read[1].Completion.BestFitness);
+        Assert.AreEqual(completion.TotalEvaluations, read[1].Completion.TotalEvaluations);
+        Assert.AreEqual(completion.Iterations, read[1].Completion.Iterations);
+        Assert.HasCount(completion.BestParameters.Count, read[1].Completion.BestParameters);
+        for (int i = 0; i < completion.BestParameters.Count; i++)
+            Assert.AreEqual(completion.BestParameters[i], read[1].Completion.BestParameters[i]);
+    }
+
+    [TestMethod]
+    public void CoordinatorWorkerControl_RoundTrips()
+    {
+        var worker = new SharedEstimationWorkerEndpoint("worker-2", "server-2", "host", 5001,
+            "token", "fingerprint", new Dictionary<int, string> { [3] = "/input" }, ConcurrentRuns: 4);
+        var acknowledgement = new SharedEstimationWorkerControlAcknowledgement(
+            "run-1", "worker-2", true, false, "already active", 2);
+
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+        {
+            SharedEstimationProtocol.WriteCoordinatorWorkerRequest(writer, "run-1", worker, remove: false);
+            SharedEstimationProtocol.WriteWorkerControlAcknowledgement(writer, acknowledgement);
+        }
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        var readWorkerRequest = SharedEstimationProtocol.ReadCoordinatorWorkerRequest(reader, remove: false);
+        Assert.AreEqual("run-1", readWorkerRequest.RunId);
+        Assert.AreEqual(worker.WorkerId, readWorkerRequest.Worker.WorkerId);
+        Assert.AreEqual(worker.Address, readWorkerRequest.Worker.Address);
+        Assert.AreEqual(worker.ConcurrentRuns, readWorkerRequest.Worker.ConcurrentRuns);
+        Assert.AreEqual(worker.BasicParameterOverrides![3], readWorkerRequest.Worker.BasicParameterOverrides![3]);
+        Assert.AreEqual(acknowledgement, SharedEstimationProtocol.ReadWorkerControlAcknowledgement(reader));
+    }
+
+    [TestMethod]
+    public void WorkerEndpoint_CreatesOneSlotPerConfiguredRun()
+    {
+        var endpoint = new SharedEstimationWorkerEndpoint("worker-a", "server-a", "host", 5001,
+            "token", "fingerprint", ConcurrentRuns: 3);
+
+        var slots = endpoint.CreateWorkerSlots();
+
+        Assert.HasCount(3, slots);
+        CollectionAssert.AreEqual(new[] { "worker-a", "worker-a#run-2", "worker-a#run-3" },
+            slots.Select(slot => slot.WorkerId).ToArray());
+        Assert.IsTrue(slots.All(slot => slot.EndpointId == endpoint.EndpointId));
+        Assert.IsTrue(slots.All(slot => slot.ConcurrentRuns == 1));
+
+        var configuredWorker = endpoint with
+        {
+            BasicParameterOverrides = new Dictionary<int, string> { [8] = "/worker/input" }
+        };
+        Assert.IsTrue(configuredWorker.CreateWorkerSlots()
+            .All(slot => slot.BasicParameterOverrides![8] == "/worker/input"));
+        Assert.Throws<ArgumentOutOfRangeException>(() =>
+            (endpoint with { ConcurrentRuns = SharedEstimationWorkerEndpoint.MaximumConcurrentRuns + 1 })
+                .CreateWorkerSlots());
+    }
+}
diff --git a/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationWorkerParticipant.cs b/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationWorkerParticipant.cs
new file mode 100644
index 00000000..7ee74e61
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationWorkerParticipant.cs
@@ -0,0 +1,71 @@
+using System;
+using System.IO;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
+using XTMF2.ModelSystemConstruct;
+using XTMF2.RuntimeModules;
+using XTMF2.UnitTests.Modules;
+using static XTMF2.UnitTests.TestHelper;
+
+namespace XTMF2.UnitTests.Bus.Optimization;
+
+[TestClass]
+public class TestSharedEstimationWorkerParticipant
+{
+    [TestMethod]
+    public void Evaluate_UsesPreparedModelSystemAndReturnsFitness()
+    {
+        RunInModelSystemContext("SharedEstimationWorkerParticipant", (user, projectSession, session) =>
+        {
+            XTMF2.Editing.CommandError error = null;
+            var modelSystem = session.ModelSystem;
+            Assert.IsTrue(session.AddModelSystemStart(user, modelSystem.GlobalBoundary, "Start",
+                Rectangle.Hidden, out Start start, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Ignore",
+                typeof(IgnoreResult<string>), Rectangle.Hidden, out var ignore, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Action",
+                typeof(SimpleTestModule), Rectangle.Hidden, out var action, out error), error?.Message);
+            Assert.IsTrue(session.AddLink(user, start, start.Hooks[0], ignore, out var firstLink, out error), error?.Message);
+            Assert.IsTrue(session.AddLink(user, ignore, ignore.Hooks[0], action, out var secondLink, out error), error?.Message);
+
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Fitness",
+                typeof(BasicParameter<float>), Rectangle.Hidden, out var fitness, out error), error?.Message);
+            Assert.IsTrue(session.SetParameterValue(user, fitness, "2.5", out error), error?.Message);
+            Assert.IsTrue(session.SetEstimationFitnessNode(user, fitness, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Parameter",
+                typeof(SetableParameter<float>), Rectangle.Hidden, out var parameter, out error), error?.Message);
+            Assert.IsTrue(session.SetParameterValue(user, parameter, "0.5", out error), error?.Message);
+            Assert.IsTrue(session.AddEstimationGroup(user, "Group", out var group, out error), error?.Message);
+            Assert.IsTrue(session.AddEstimationParameter(user, group!, parameter,
+                0.0, 1.0, 0.5, out var entry, out error), error?.Message);
+
+            using var serialized = new MemoryStream();
+            Assert.IsTrue(session.Save(out error, serialized), error?.Message);
+            var request = new SharedEstimationRunRequest(
+                "shared-run", Directory.GetCurrentDirectory(), "Start", serialized.ToArray());
+
+            Assert.IsTrue(SharedEstimationWorkerParticipant.TryCreate(
+                CreateRuntime(), request, out var participant, out var runError), runError?.Message);
+            var result = participant!.Evaluate(new SharedEstimationCandidate(
+                "shared-run", 1, "candidate-1", new[] { 0.75 }));
+
+            Assert.AreEqual("candidate-1", result.CandidateId);
+            Assert.AreEqual(2.5, result.Fitness, 0.0001);
+            Assert.IsNull(result.Error);
+
+            Assert.IsTrue(SharedEstimationLocalWorker.TryCreate(
+                "coordinator", CreateRuntime(), request, out var localWorker, out var localError), localError);
+            using (localWorker)
+            using (var coordinator = new SharedEstimationCoordinator())
+            {
+                Assert.IsTrue(coordinator.AddWorker(localWorker!, out var addError), addError);
+                var localResult = coordinator.EvaluateAsync([new SharedEstimationCandidate(
+                    "shared-run", 2, "coordinator-candidate", new[] { 0.25 })]).GetAwaiter().GetResult().Single();
+                Assert.AreEqual(2.5, localResult.Fitness, 0.0001);
+                Assert.IsNull(localResult.Error);
+            }
+        });
+    }
+}
diff --git a/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationWorkerPool.cs b/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationWorkerPool.cs
new file mode 100644
index 00000000..e54aedbd
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/Optimization/TestSharedEstimationWorkerPool.cs
@@ -0,0 +1,262 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
+
+namespace XTMF2.UnitTests.Bus.Optimization;
+
+[TestClass]
+public class TestSharedEstimationWorkerPool
+{
+    [TestMethod]
+    public void StartRun_DropsWorkerWithNonWritableStreamAndKeepsRunActive()
+    {
+        using var failedBus = new HostBus(new RecordingDuplexStream(failWrites: true), true);
+        var healthyStream = new RecordingDuplexStream();
+        using var healthyBus = new HostBus(healthyStream, true);
+        using var pool = new SharedEstimationWorkerPool();
+        Assert.IsTrue(pool.AddExistingWorker("worker-failed", "endpoint-failed", failedBus, out var error), error);
+        Assert.IsTrue(pool.AddExistingWorker("worker-healthy", "endpoint-healthy", healthyBus, out error), error);
+
+        Assert.IsTrue(pool.StartRun(new SharedEstimationRunRequest("run-resilient", "/tmp/run-resilient",
+            "Start", [1]), out error), error);
+
+        Assert.AreEqual(0, pool.WorkerCount);
+        CollectionAssert.AreEqual(new[] { "worker-healthy" }, pool.WorkerIds.ToArray());
+        var evaluation = pool.Coordinator.EvaluateAsync([
+            new SharedEstimationCandidate("run-resilient", 1, "candidate-healthy", [0.25])]);
+        Assert.IsFalse(evaluation.IsCompleted);
+        var startFrameLength = healthyStream.GetWrittenBytes().Length;
+        healthyStream.SignalWorkerReady("run-resilient", succeeded: true);
+        Assert.IsTrue(healthyStream.WaitForWrittenBytes(startFrameLength + 1, TimeSpan.FromSeconds(3)));
+        Assert.AreEqual(1, pool.WorkerCount);
+    }
+
+    [TestMethod]
+    public void AddExistingWorker_SendsActiveRunBeforePendingCandidates()
+    {
+        var stream = new RecordingDuplexStream();
+        using var bus = new HostBus(stream, true);
+        using var pool = new SharedEstimationWorkerPool();
+        var request = new SharedEstimationRunRequest("run-reconnected", "/tmp/run-reconnected",
+            "Start", [1, 2, 3]);
+        Assert.IsTrue(pool.StartRun(request, out var error), error);
+        var candidate = new SharedEstimationCandidate("run-reconnected", 1,
+            "candidate-reconnected", [0.5]);
+        var evaluation = pool.Coordinator.EvaluateAsync([candidate]);
+
+        Assert.IsTrue(pool.AddExistingWorker("worker-1", "endpoint-1", bus, out error), error);
+
+        using var payload = new MemoryStream(stream.GetWrittenBytes());
+        using var reader = new BinaryReader(payload);
+        Assert.AreEqual(5, reader.ReadInt32());
+        var (startVersion, startType) = SharedEstimationProtocol.ReadHeader(reader);
+        Assert.AreEqual(SharedEstimationProtocol.Version, startVersion);
+        Assert.AreEqual(SharedEstimationMessageType.StartRun, startType);
+        Assert.AreEqual("run-reconnected", SharedEstimationProtocol.ReadRunRequestPayload(reader).RunId);
+        Assert.AreEqual(payload.Length, payload.Position);
+
+        var startFrameLength = stream.GetWrittenBytes().Length;
+        var candidateFrameLength = GetFrameLength(writer =>
+        {
+            writer.Write(5);
+            SharedEstimationProtocol.WriteCandidate(writer, candidate);
+        });
+        Assert.AreEqual(0, pool.WorkerCount);
+        Assert.IsFalse(evaluation.IsCompleted);
+        stream.SignalWorkerReady("run-reconnected", succeeded: true);
+        Assert.IsTrue(stream.WaitForWrittenBytes(startFrameLength + candidateFrameLength,
+            TimeSpan.FromSeconds(3)));
+
+        using var completedPayload = new MemoryStream(stream.GetWrittenBytes());
+        using var completedReader = new BinaryReader(completedPayload);
+        Assert.AreEqual(5, completedReader.ReadInt32());
+        var (startVersionAgain, startTypeAgain) = SharedEstimationProtocol.ReadHeader(completedReader);
+        Assert.AreEqual(SharedEstimationProtocol.Version, startVersionAgain);
+        Assert.AreEqual(SharedEstimationMessageType.StartRun, startTypeAgain);
+        SharedEstimationProtocol.ReadRunRequestPayload(completedReader);
+        Assert.AreEqual(5, completedReader.ReadInt32());
+        var (_, candidateType) = SharedEstimationProtocol.ReadHeader(completedReader);
+        Assert.AreEqual(SharedEstimationMessageType.EvaluateCandidate, candidateType);
+        Assert.AreEqual("candidate-reconnected",
+            SharedEstimationProtocol.ReadCandidatePayload(completedReader).CandidateId);
+        Assert.IsFalse(evaluation.IsCompleted);
+    }
+
+    [TestMethod]
+    public void StartRun_SendsSharedEndpointSlotCountToEachWorker()
+    {
+        var firstStream = new RecordingDuplexStream();
+        var secondStream = new RecordingDuplexStream();
+        using var firstBus = new HostBus(firstStream, true);
+        using var secondBus = new HostBus(secondStream, true);
+        using var pool = new SharedEstimationWorkerPool();
+        Assert.IsTrue(pool.AddExistingWorker("worker-1", "endpoint-1", firstBus, out var error), error);
+        Assert.IsTrue(pool.AddExistingWorker("worker-2", "endpoint-1", secondBus, out error), error);
+
+        Assert.IsTrue(pool.StartRun(new SharedEstimationRunRequest("run-slots", "/tmp/run-slots",
+            "Start", [1]), out error), error);
+
+        Assert.AreEqual(2, ReadWorkerSlotCount(firstStream.GetWrittenBytes()));
+        Assert.AreEqual(2, ReadWorkerSlotCount(secondStream.GetWrittenBytes()));
+    }
+
+    [TestMethod]
+    public async Task StartRun_ReportsFailureWhenOnlyWorkerCannotPrepare()
+    {
+        var stream = new RecordingDuplexStream();
+        using var bus = new HostBus(stream, true);
+        using var pool = new SharedEstimationWorkerPool();
+        Assert.IsTrue(pool.AddExistingWorker("worker-1", "endpoint-1", bus, out var error), error);
+        var failure = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
+        pool.WorkerPreparationFailed += message => failure.TrySetResult(message);
+        Assert.IsTrue(pool.StartRun(new SharedEstimationRunRequest("run-prepare-failure",
+            "/tmp/run-prepare-failure", "Start", [1]), out error), error);
+
+        stream.SignalWorkerReady("run-prepare-failure", succeeded: false, "Model preparation failed.");
+
+        Assert.AreEqual("Model preparation failed.", await failure.Task.WaitAsync(TimeSpan.FromSeconds(3)));
+        Assert.AreEqual(0, pool.WorkerCount);
+    }
+
+    private static int ReadWorkerSlotCount(byte[] frame)
+    {
+        using var stream = new MemoryStream(frame);
+        using var reader = new BinaryReader(stream);
+        _ = reader.ReadInt32();
+        SharedEstimationProtocol.ReadHeader(reader);
+        return SharedEstimationProtocol.ReadRunRequestPayload(reader).WorkerSlotCount;
+    }
+
+    private static int GetFrameLength(Action<BinaryWriter> writeFrame)
+    {
+        using var frame = new MemoryStream();
+        using (var writer = new BinaryWriter(frame, System.Text.Encoding.UTF8, true))
+            writeFrame(writer);
+        return checked((int)frame.Length);
+    }
+
+    private sealed class RecordingDuplexStream : Stream
+    {
+        private readonly object _sync = new();
+        private readonly MemoryStream _written = new();
+        private readonly List<byte> _incoming = [];
+        private int _incomingOffset;
+        private readonly TaskCompletionSource _closed = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        private readonly bool _failWrites;
+
+        public RecordingDuplexStream(bool failWrites = false)
+        {
+            _failWrites = failWrites;
+        }
+
+        public override bool CanRead => true;
+        public override bool CanSeek => false;
+        public override bool CanWrite => !_closed.Task.IsCompleted && !_failWrites;
+        public override long Length => throw new NotSupportedException();
+        public override long Position
+        {
+            get => throw new NotSupportedException();
+            set => throw new NotSupportedException();
+        }
+
+        public byte[] GetWrittenBytes()
+        {
+            lock (_sync)
+                return _written.ToArray();
+        }
+
+        public bool WaitForWrittenBytes(int minimumBytes, TimeSpan timeout)
+        {
+            var deadline = DateTime.UtcNow + timeout;
+            lock (_sync)
+            {
+                while (_written.Length < minimumBytes && !_closed.Task.IsCompleted)
+                {
+                    var remaining = deadline - DateTime.UtcNow;
+                    if (remaining <= TimeSpan.Zero)
+                        return false;
+                    Monitor.Wait(_sync, remaining);
+                }
+                return _written.Length >= minimumBytes;
+            }
+        }
+
+        public void SignalWorkerReady(string runId, bool succeeded, string error = null)
+        {
+            using var frame = new MemoryStream();
+            using (var writer = new BinaryWriter(frame, System.Text.Encoding.UTF8, true))
+            {
+                writer.Write(12);
+                SharedEstimationProtocol.WriteWorkerReady(writer,
+                    new SharedEstimationWorkerReady(runId, succeeded, error));
+            }
+            lock (_sync)
+            {
+                _incoming.AddRange(frame.ToArray());
+                Monitor.PulseAll(_sync);
+            }
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            lock (_sync)
+            {
+                while (_incomingOffset == _incoming.Count && !_closed.Task.IsCompleted)
+                    Monitor.Wait(_sync);
+                if (_incomingOffset == _incoming.Count)
+                    return 0;
+                var readCount = Math.Min(count, _incoming.Count - _incomingOffset);
+                _incoming.CopyTo(_incomingOffset, buffer, offset, readCount);
+                _incomingOffset += readCount;
+                if (_incomingOffset == _incoming.Count)
+                {
+                    _incoming.Clear();
+                    _incomingOffset = 0;
+                }
+                return readCount;
+            }
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (_failWrites)
+                throw new InvalidOperationException("Stream was not writable.");
+            lock (_sync)
+            {
+                _written.Write(buffer, offset, count);
+                Monitor.PulseAll(_sync);
+            }
+        }
+
+        public override void Write(ReadOnlySpan<byte> buffer)
+        {
+            if (_failWrites)
+                throw new InvalidOperationException("Stream was not writable.");
+            lock (_sync)
+            {
+                _written.Write(buffer);
+                Monitor.PulseAll(_sync);
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            _closed.TrySetResult();
+            lock (_sync)
+                Monitor.PulseAll(_sync);
+            if (disposing)
+                _written.Dispose();
+            base.Dispose(disposing);
+        }
+
+        public override void Flush() { }
+        public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+        public override void SetLength(long value) => throw new NotSupportedException();
+    }
+}
\ No newline at end of file
diff --git a/tests/XTMF2.UnitTests/Bus/TestDeploymentProtocol.cs b/tests/XTMF2.UnitTests/Bus/TestDeploymentProtocol.cs
new file mode 100644
index 00000000..2080e4d3
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/TestDeploymentProtocol.cs
@@ -0,0 +1,78 @@
+using System;
+using System.IO;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+
+namespace XTMF2.UnitTests.Bus;
+
+[TestClass]
+public class TestDeploymentProtocol
+{
+    [TestMethod]
+    public void DrainStatus_RoundTripsWithVersionAndPayload()
+    {
+        var expected = new RunServerDrainStatus("request-1", RunServerDrainState.Draining, 2, 3,
+            "Waiting for existing work.");
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+        {
+            DeploymentProtocol.WriteDrainStatus(writer, expected);
+            writer.Flush();
+        }
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        var header = DeploymentProtocol.ReadHeader(reader);
+        var actual = DeploymentProtocol.ReadStatusPayload(reader);
+
+        Assert.AreEqual(1, header.Version);
+        Assert.AreEqual(DeploymentMessageType.DrainStatus, header.Type);
+        Assert.AreEqual(expected, actual);
+    }
+
+    [TestMethod]
+    public void DrainStatus_RejectsNegativeActivityCounts()
+    {
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true))
+        {
+            writer.Write(1);
+            writer.Write((int)DeploymentMessageType.DrainStatus);
+            writer.Write("request-1");
+            writer.Write((int)RunServerDrainState.Draining);
+            writer.Write(-1);
+            writer.Write(0);
+            writer.Write(false);
+            writer.Flush();
+        }
+
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream);
+        DeploymentProtocol.ReadHeader(reader);
+        Assert.Throws<InvalidDataException>(() => DeploymentProtocol.ReadStatusPayload(reader));
+    }
+
+    [TestMethod]
+    public void RequestId_RequiresGuidWithoutSeparators()
+    {
+        Assert.IsTrue(DeploymentProtocol.IsValidRequestId(Guid.NewGuid().ToString("N")));
+        Assert.IsFalse(DeploymentProtocol.IsValidRequestId("../../deployment"));
+        Assert.IsFalse(DeploymentProtocol.IsValidRequestId("request-1"));
+    }
+
+    [TestMethod]
+    public void DeployArchive_RejectsArchiveAboveMaximum()
+    {
+        using var stream = new MemoryStream();
+        using var writer = new BinaryWriter(stream, System.Text.Encoding.UTF8, true);
+        writer.Write(1);
+        writer.Write((int)DeploymentMessageType.DeployArchive);
+        writer.Write(Guid.NewGuid().ToString("N"));
+        writer.Write(DeploymentProtocol.MaxArchiveBytes + 1);
+        writer.Flush();
+        stream.Position = 0;
+        using var reader = new BinaryReader(stream);
+        DeploymentProtocol.ReadHeader(reader);
+        Assert.Throws<InvalidDataException>(() => DeploymentProtocol.ReadDeployArchive(reader));
+    }
+}
diff --git a/tests/XTMF2.UnitTests/Bus/TestEstimationRandomSeeds.cs b/tests/XTMF2.UnitTests/Bus/TestEstimationRandomSeeds.cs
new file mode 100644
index 00000000..83afc9a5
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/TestEstimationRandomSeeds.cs
@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus.Optimization;
+
+namespace XTMF2.UnitTests.Bus;
+
+[TestClass]
+public sealed class TestEstimationRandomSeeds
+{
+    [TestMethod]
+    public void AllEstimationConfigsExposeRandomSeedParameter()
+    {
+        EstimationAlgorithmConfig[] configs =
+        [
+            new NelderMeadConfig(),
+            new ParticleSwarmConfig(),
+            new GeneticAlgorithmConfig(),
+            new StochasticGradientConfig()
+        ];
+
+        foreach (var config in configs)
+        {
+            var parameters = config.GetParameters();
+            var seed = parameters.Single(parameter => parameter.Key == "RandomSeed");
+            seed.Value = "-123456";
+
+            Assert.IsNull(config.ApplyParameters(parameters));
+            Assert.AreEqual(-123456, config.RandomSeed);
+        }
+    }
+
+    [TestMethod]
+    public void StochasticEstimators_ReproduceCandidatesForConfiguredSeed()
+    {
+        Func<int, EstimationAlgorithmConfig>[] createConfigs =
+        [
+            seed => new ParticleSwarmConfig
+            {
+                RandomSeed = seed,
+                SwarmSize = 8,
+                MaxIterations = 4,
+                ConvergenceTolerance = 0,
+                NoImprovementLimit = 0
+            },
+            seed => new GeneticAlgorithmConfig
+            {
+                RandomSeed = seed,
+                PopulationSize = 8,
+                MaxGenerations = 4,
+                ConvergenceTolerance = 0,
+                MutationRate = 1
+            },
+            seed => new StochasticGradientConfig
+            {
+                RandomSeed = seed,
+                MaxIterations = 4,
+                ConvergenceTolerance = 0
+            }
+        ];
+
+        foreach (var createConfig in createConfigs)
+        {
+            var first = CaptureCandidates(createConfig(731));
+            var repeated = CaptureCandidates(createConfig(731));
+            var changedSeed = CaptureCandidates(createConfig(732));
+
+            CollectionAssert.AreEqual(first, repeated);
+            Assert.IsFalse(first.SequenceEqual(changedSeed),
+                "Changing the configured seed should change the stochastic candidate sequence.");
+        }
+    }
+
+    private static string[] CaptureCandidates(EstimationAlgorithmConfig config)
+    {
+        var algorithm = config.CreateAlgorithm(2, [-2, -2], [2, 2], [0.25, -0.5]);
+        var candidates = new List<string>();
+
+        double Evaluate(double[] values)
+        {
+            candidates.Add(string.Join(",", values.Select(value =>
+                value.ToString("R", CultureInfo.InvariantCulture))));
+            return values.Sum(value => value * value);
+        }
+
+        IReadOnlyList<double> EvaluateBatch(IReadOnlyList<double[]> values)
+        {
+            var fitnesses = new double[values.Count];
+            for (int index = 0; index < values.Count; index++)
+            {
+                candidates.Add(string.Join(",", values[index].Select(value =>
+                    value.ToString("R", CultureInfo.InvariantCulture))));
+                fitnesses[index] = values[index].Sum(value => value * value);
+            }
+            return fitnesses;
+        }
+
+        algorithm.RunBatch(Evaluate, EvaluateBatch);
+        return candidates.ToArray();
+    }
+}
\ No newline at end of file
diff --git a/tests/XTMF2.UnitTests/Bus/TestHostBusDisposal.cs b/tests/XTMF2.UnitTests/Bus/TestHostBusDisposal.cs
new file mode 100644
index 00000000..50e0ef6f
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/TestHostBusDisposal.cs
@@ -0,0 +1,63 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+
+namespace XTMF2.UnitTests.Bus;
+
+[TestClass]
+public class TestHostBusDisposal
+{
+    [TestMethod]
+    public void Dispose_ClosesOwnedStreamBeforeWaitingForListener()
+    {
+        var stream = new BlockingReadStream();
+        var bus = new HostBus(stream, true);
+        Assert.IsTrue(stream.ReadStarted.Wait(TimeSpan.FromSeconds(2)));
+
+        var disposeTask = Task.Run(bus.Dispose);
+
+        Assert.IsTrue(disposeTask.Wait(TimeSpan.FromSeconds(2)),
+            "HostBus.Dispose should close the stream to release its blocked listener.");
+        Assert.IsTrue(stream.IsDisposed);
+    }
+
+    private sealed class BlockingReadStream : Stream
+    {
+        private readonly ManualResetEventSlim _readReleased = new();
+        private volatile bool _disposed;
+
+        public ManualResetEventSlim ReadStarted { get; } = new();
+        public bool IsDisposed => _disposed;
+        public override bool CanRead => !_disposed;
+        public override bool CanSeek => false;
+        public override bool CanWrite => false;
+        public override long Length => throw new NotSupportedException();
+        public override long Position
+        {
+            get => throw new NotSupportedException();
+            set => throw new NotSupportedException();
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            ReadStarted.Set();
+            _readReleased.Wait();
+            return 0;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            _disposed = true;
+            _readReleased.Set();
+            base.Dispose(disposing);
+        }
+
+        public override void Flush() => throw new NotSupportedException();
+        public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+        public override void SetLength(long value) => throw new NotSupportedException();
+        public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+    }
+}
\ No newline at end of file
diff --git a/tests/XTMF2.UnitTests/Bus/TestRemoteRunRegistry.cs b/tests/XTMF2.UnitTests/Bus/TestRemoteRunRegistry.cs
new file mode 100644
index 00000000..40b5c171
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/TestRemoteRunRegistry.cs
@@ -0,0 +1,160 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+
+namespace XTMF2.UnitTests.Bus;
+
+[TestClass]
+public class TestRemoteRunRegistry
+{
+    [TestMethod]
+    public void RegistryRestart_MarksPersistedActiveRunInterrupted()
+    {
+        var directory = Path.Combine(Path.GetTempPath(), "XTMF2-RemoteRunRegistry-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(directory);
+        try
+        {
+            var ownerUserId = Guid.NewGuid();
+            var snapshot = new RemoteRunSnapshot("run-restart", "forecast", RunMode.Normal,
+                "/runs/forecast", "Start", "model-hash", RemoteRunState.Running,
+                "Run submitted.", 0, double.NaN, Array.Empty<RemoteRunParameterValue>(), null,
+                null, null, false, DateTimeOffset.UtcNow, OwnerUserId: ownerUserId);
+            var options = new JsonSerializerOptions
+            {
+                NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals
+            };
+            File.WriteAllBytes(Path.Combine(directory, "active.json"),
+                JsonSerializer.SerializeToUtf8Bytes(snapshot, options));
+
+            using var registry = new RemoteRunRegistry(directory);
+
+            var recovered = registry.GetSnapshots();
+            Assert.HasCount(1, recovered);
+            Assert.AreEqual(RemoteRunState.Interrupted, recovered[0].State);
+            Assert.AreEqual("run-restart", recovered[0].RunId);
+            Assert.AreEqual(ownerUserId, recovered[0].OwnerUserId);
+            Assert.IsTrue(double.IsNaN(recovered[0].Fitness));
+            Assert.IsEmpty(registry.GetActiveActivities());
+        }
+        finally
+        {
+            Directory.Delete(directory, recursive: true);
+        }
+    }
+
+    [TestMethod]
+    public void DeleteRun_RemovesWorkspaceArchiveAndManifest()
+    {
+        var storageDirectory = Path.Combine(Path.GetTempPath(), "XTMF2-RemoteRunRegistry-" + Guid.NewGuid().ToString("N"));
+        var runId = Guid.NewGuid().ToString("N");
+        var workingDirectory = Path.Combine(Path.GetTempPath(), "XTMF2", "Runs", runId);
+        Directory.CreateDirectory(workingDirectory);
+        File.WriteAllText(Path.Combine(workingDirectory, "output.txt"), "run output");
+        Directory.CreateDirectory(storageDirectory);
+        try
+        {
+            var manifestPath = GetManifestPath(storageDirectory, runId);
+            var archivePath = GetArtifactPath(storageDirectory, runId);
+            File.WriteAllBytes(manifestPath, CreateSnapshot(runId, workingDirectory));
+            File.WriteAllBytes(archivePath, [1, 2, 3]);
+
+            using var registry = new RemoteRunRegistry(storageDirectory);
+
+            Assert.IsTrue(registry.DeleteRun(runId, out var error), error);
+            Assert.IsFalse(Directory.Exists(workingDirectory));
+            Assert.IsFalse(File.Exists(manifestPath));
+            Assert.IsFalse(File.Exists(archivePath));
+            Assert.IsEmpty(registry.GetSnapshots());
+        }
+        finally
+        {
+            if (Directory.Exists(workingDirectory))
+                Directory.Delete(workingDirectory, recursive: true);
+            if (Directory.Exists(storageDirectory))
+                Directory.Delete(storageDirectory, recursive: true);
+        }
+    }
+
+    [TestMethod]
+    public void DeleteRun_RefusesDirectoryOutsidePrivateWorkspace()
+    {
+        var storageDirectory = Path.Combine(Path.GetTempPath(), "XTMF2-RemoteRunRegistry-" + Guid.NewGuid().ToString("N"));
+        var runId = Guid.NewGuid().ToString("N");
+        Directory.CreateDirectory(storageDirectory);
+        try
+        {
+            var manifestPath = GetManifestPath(storageDirectory, runId);
+            File.WriteAllBytes(manifestPath, CreateSnapshot(runId, Path.GetTempPath()));
+            using var registry = new RemoteRunRegistry(storageDirectory);
+
+            Assert.IsFalse(registry.DeleteRun(runId, out var error));
+            Assert.Contains("outside the RunServer's private run workspace", error);
+            Assert.IsTrue(File.Exists(manifestPath));
+            Assert.HasCount(1, registry.GetSnapshots());
+        }
+        finally
+        {
+            if (Directory.Exists(storageDirectory))
+                Directory.Delete(storageDirectory, recursive: true);
+        }
+    }
+
+    [TestMethod]
+    public void TryReadArtifacts_RebuildsArchiveAfterReceiptAcknowledgement()
+    {
+        var storageDirectory = Path.Combine(Path.GetTempPath(), "XTMF2-RemoteRunRegistry-" + Guid.NewGuid().ToString("N"));
+        var runId = Guid.NewGuid().ToString("N");
+        var workingDirectory = Path.Combine(Path.GetTempPath(), "XTMF2", "Runs", runId);
+        Directory.CreateDirectory(workingDirectory);
+        Directory.CreateDirectory(storageDirectory);
+        File.WriteAllText(Path.Combine(workingDirectory, "output.txt"), "retained run output");
+        try
+        {
+            var manifestPath = GetManifestPath(storageDirectory, runId);
+            var archivePath = GetArtifactPath(storageDirectory, runId);
+            File.WriteAllBytes(manifestPath, CreateSnapshot(runId, workingDirectory));
+            File.WriteAllBytes(archivePath, [1, 2, 3]);
+            using var registry = new RemoteRunRegistry(storageDirectory);
+
+            Assert.IsTrue(registry.AcknowledgeReceived(runId));
+            Assert.IsFalse(File.Exists(archivePath));
+            Assert.IsTrue(registry.GetSnapshots()[0].ArtifactsAvailable);
+            Assert.IsTrue(registry.TryReadArtifacts(runId, out var archive));
+            Assert.IsNotNull(archive);
+            Assert.IsTrue(File.Exists(archivePath));
+        }
+        finally
+        {
+            if (Directory.Exists(workingDirectory))
+                Directory.Delete(workingDirectory, recursive: true);
+            if (Directory.Exists(storageDirectory))
+                Directory.Delete(storageDirectory, recursive: true);
+        }
+    }
+
+    private static byte[] CreateSnapshot(string runId, string workingDirectory)
+    {
+        var snapshot = new RemoteRunSnapshot(runId, "forecast", RunMode.Normal,
+            workingDirectory, "Start", "model-hash", RemoteRunState.Completed,
+            "Run completed.", 0, double.NaN, Array.Empty<RemoteRunParameterValue>(), null,
+            null, null, true, DateTimeOffset.UtcNow);
+        var options = new JsonSerializerOptions
+        {
+            NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals
+        };
+        return JsonSerializer.SerializeToUtf8Bytes(snapshot, options);
+    }
+
+    private static string GetManifestPath(string storageDirectory, string runId)
+        => Path.Combine(storageDirectory,
+            $"{Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(runId)))}.json");
+
+    private static string GetArtifactPath(string storageDirectory, string runId)
+        => Path.Combine(storageDirectory,
+            $"{Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(runId)))}.zip");
+}
\ No newline at end of file
diff --git a/tests/XTMF2.UnitTests/Bus/TestRunServerDeploymentFileTransaction.cs b/tests/XTMF2.UnitTests/Bus/TestRunServerDeploymentFileTransaction.cs
new file mode 100644
index 00000000..e8b79ed7
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/TestRunServerDeploymentFileTransaction.cs
@@ -0,0 +1,84 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.RunServer.Updater;
+
+namespace XTMF2.UnitTests.Bus;
+
+[TestClass]
+public class TestRunServerDeploymentFileTransaction
+{
+    [TestMethod]
+    public void ApplyAndRollback_RestoresPreviousRuntimeAndModules()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "XTMF2UpdaterTests", Guid.NewGuid().ToString("N"));
+        var installationDirectory = Path.Combine(root, "install");
+        var deploymentDirectory = Path.Combine(root, "deployment");
+        Directory.CreateDirectory(Path.Combine(installationDirectory, "Modules"));
+        Directory.CreateDirectory(deploymentDirectory);
+        File.WriteAllText(Path.Combine(installationDirectory, "XTMF2.dll"), "old runtime");
+        File.WriteAllText(Path.Combine(installationDirectory, "Modules", "OldModule.dll"), "old module");
+        CreateArchive(Path.Combine(deploymentDirectory, "deployment.zip"),
+            ("XTMF2.dll", "new runtime"), ("Modules/NewModule.dll", "new module"));
+
+        try
+        {
+            var transaction = new DeploymentFileTransaction(installationDirectory, deploymentDirectory);
+            transaction.Apply();
+
+            Assert.AreEqual("new runtime", File.ReadAllText(Path.Combine(installationDirectory, "XTMF2.dll")));
+            Assert.IsTrue(File.Exists(Path.Combine(installationDirectory, "Modules", "NewModule.dll")));
+            Assert.IsFalse(File.Exists(Path.Combine(installationDirectory, "Modules", "OldModule.dll")));
+
+            transaction.Rollback();
+
+            Assert.AreEqual("old runtime", File.ReadAllText(Path.Combine(installationDirectory, "XTMF2.dll")));
+            Assert.IsTrue(File.Exists(Path.Combine(installationDirectory, "Modules", "OldModule.dll")));
+            Assert.IsFalse(File.Exists(Path.Combine(installationDirectory, "Modules", "NewModule.dll")));
+        }
+        finally
+        {
+            Directory.Delete(root, recursive: true);
+        }
+    }
+
+    [TestMethod]
+    public void Apply_RejectsTraversalBeforeChangingInstalledFiles()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "XTMF2UpdaterTests", Guid.NewGuid().ToString("N"));
+        var installationDirectory = Path.Combine(root, "install");
+        var deploymentDirectory = Path.Combine(root, "deployment");
+        Directory.CreateDirectory(Path.Combine(installationDirectory, "Modules"));
+        Directory.CreateDirectory(deploymentDirectory);
+        File.WriteAllText(Path.Combine(installationDirectory, "XTMF2.dll"), "old runtime");
+        File.WriteAllText(Path.Combine(installationDirectory, "Modules", "OldModule.dll"), "old module");
+        CreateArchive(Path.Combine(deploymentDirectory, "deployment.zip"),
+            ("XTMF2.dll", "new runtime"), ("Modules/../outside.dll", "unexpected"));
+
+        try
+        {
+            var transaction = new DeploymentFileTransaction(installationDirectory, deploymentDirectory);
+
+            Assert.Throws<InvalidDataException>(() => transaction.Apply());
+            Assert.AreEqual("old runtime", File.ReadAllText(Path.Combine(installationDirectory, "XTMF2.dll")));
+            Assert.IsTrue(File.Exists(Path.Combine(installationDirectory, "Modules", "OldModule.dll")));
+            Assert.IsFalse(File.Exists(Path.Combine(root, "outside.dll")));
+        }
+        finally
+        {
+            Directory.Delete(root, recursive: true);
+        }
+    }
+
+    private static void CreateArchive(string archivePath, params (string Name, string Content)[] files)
+    {
+        using var archive = ZipFile.Open(archivePath, ZipArchiveMode.Create);
+        foreach (var (name, content) in files)
+        {
+            var entry = archive.CreateEntry(name);
+            using var writer = new StreamWriter(entry.Open());
+            writer.Write(content);
+        }
+    }
+}
diff --git a/tests/XTMF2.UnitTests/Bus/TestRunServerSecurity.cs b/tests/XTMF2.UnitTests/Bus/TestRunServerSecurity.cs
new file mode 100644
index 00000000..52ebb45b
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/TestRunServerSecurity.cs
@@ -0,0 +1,77 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+
+namespace XTMF2.UnitTests.Bus;
+
+[TestClass]
+public class TestRunServerSecurity
+{
+    [TestMethod]
+    public void SecureTcpClient_AuthenticatesWithCertificateFingerprintAndToken()
+    {
+        var securityDirectory = Directory.CreateTempSubdirectory("xtmf-security-test-");
+        try
+        {
+            RunServerSecurity.SaveSetup(securityDirectory.FullName, out var token, out var fingerprint);
+            using var certificate = RunServerSecurity.LoadCertificate(securityDirectory.FullName);
+            using var listener = new TcpListener(IPAddress.Loopback, 0);
+            listener.Start();
+            var port = ((IPEndPoint)listener.LocalEndpoint).Port;
+            var server = Task.Run(() =>
+            {
+                using var client = listener.AcceptTcpClient();
+                Assert.IsTrue(CreateStreams.AuthenticateSecureTcpClient(
+                    client, certificate, token, out var stream, out var error), error);
+                stream?.Dispose();
+            });
+
+            Assert.IsTrue(CreateStreams.CreateSecureTcpClient(
+                "127.0.0.1", port, token, fingerprint,
+                out var clientStream, out var clientError), clientError);
+            clientStream!.Dispose();
+            Assert.IsTrue(server.Wait(TimeSpan.FromSeconds(5)), "The secure server handshake did not complete.");
+            server.GetAwaiter().GetResult();
+        }
+        finally
+        {
+            securityDirectory.Delete(true);
+        }
+    }
+
+    [TestMethod]
+    public void SecureTcpClient_RejectsInvalidToken()
+    {
+        var securityDirectory = Directory.CreateTempSubdirectory("xtmf-security-test-");
+        try
+        {
+            RunServerSecurity.SaveSetup(securityDirectory.FullName, out var token, out var fingerprint);
+            using var certificate = RunServerSecurity.LoadCertificate(securityDirectory.FullName);
+            using var listener = new TcpListener(IPAddress.Loopback, 0);
+            listener.Start();
+            var port = ((IPEndPoint)listener.LocalEndpoint).Port;
+            var server = Task.Run(() =>
+            {
+                using var client = listener.AcceptTcpClient();
+                CreateStreams.AuthenticateSecureTcpClient(
+                    client, certificate, token, out var stream, out _);
+                stream?.Dispose();
+            });
+
+            Assert.IsFalse(CreateStreams.CreateSecureTcpClient(
+                "127.0.0.1", port, RunServerSecurity.CreateToken(), fingerprint,
+                out var clientStream, out _));
+            clientStream?.Dispose();
+            Assert.IsTrue(server.Wait(TimeSpan.FromSeconds(5)), "The secure server handshake did not complete.");
+            server.GetAwaiter().GetResult();
+        }
+        finally
+        {
+            securityDirectory.Delete(true);
+        }
+    }
+}
diff --git a/tests/XTMF2.UnitTests/Bus/TestRunServerUpdaterArguments.cs b/tests/XTMF2.UnitTests/Bus/TestRunServerUpdaterArguments.cs
new file mode 100644
index 00000000..7f4ecbbb
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/TestRunServerUpdaterArguments.cs
@@ -0,0 +1,43 @@
+using System;
+using System.IO;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.RunServer.Updater;
+
+namespace XTMF2.UnitTests.Bus;
+
+[TestClass]
+public class TestRunServerUpdaterArguments
+{
+    [TestMethod]
+    public void Parse_PreservesPathsAndRepeatedServerArguments()
+    {
+        var serverArguments = new[] { "-tcp", "0.0.0.0", "1234", "-security", "C:\\Run Server\\security" };
+        var args = new[]
+        {
+            "--old-pid", "123",
+            "--install-dir", "C:\\Run Server",
+            "--server-path", "C:\\Run Server\\XTMF2.RunServer.exe",
+            "--server-assembly", "C:\\Run Server\\XTMF2.RunServer.dll",
+            "--deployment-dir", "C:\\Run Server\\.deployments\\request",
+            "--staging-root", "C:\\Users\\user\\AppData\\Local\\Temp\\deployment",
+            "--server-arg", serverArguments[0],
+            "--server-arg", serverArguments[1],
+            "--server-arg", serverArguments[2],
+            "--server-arg", serverArguments[3],
+            "--server-arg", serverArguments[4]
+        };
+
+        var options = UpdaterArguments.Parse(args);
+
+        Assert.AreEqual(123, options.PreviousProcessId);
+        Assert.AreEqual(Path.GetFullPath("C:\\Run Server"), options.InstallationDirectory);
+        CollectionAssert.AreEqual(serverArguments, options.ServerArguments.ToArray());
+    }
+
+    [TestMethod]
+    public void Parse_RejectsMissingRequiredOptions()
+    {
+        Assert.Throws<ArgumentException>(() => UpdaterArguments.Parse(Array.Empty<string>()));
+    }
+}
diff --git a/tests/XTMF2.UnitTests/Bus/TestSchedulerDrain.cs b/tests/XTMF2.UnitTests/Bus/TestSchedulerDrain.cs
new file mode 100644
index 00000000..72b54c31
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/TestSchedulerDrain.cs
@@ -0,0 +1,40 @@
+using System;
+using System.IO;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+
+namespace XTMF2.UnitTests.Bus;
+
+[TestClass]
+public class TestSchedulerDrain
+{
+    [TestMethod]
+    public void BeginDrain_RejectsNewRunsAndReservations()
+    {
+        using var scheduler = new Scheduler(runLocal: true);
+        Assert.IsTrue(RunContext.CreateRunContext(null!, "run-1", [], Path.GetTempPath(),
+            "Start", RunMode.Normal, out var context));
+
+        scheduler.BeginDrain();
+
+        Assert.IsFalse(scheduler.IsAcceptingWork);
+        Assert.Throws<InvalidOperationException>(() => scheduler.Run(context, new Sink()));
+        Assert.Throws<InvalidOperationException>(() => scheduler.Reserve(context));
+        Assert.IsTrue(scheduler.IsIdle);
+    }
+
+    private sealed class Sink : IRunOutputSink
+    {
+        public System.Collections.Generic.IReadOnlyList<string> ExtraDlls => Array.Empty<string>();
+        public System.Threading.Tasks.Task StartProcessingRequestFromRun(string id, Stream clientToRunStream)
+            => System.Threading.Tasks.Task.CompletedTask;
+        public void ModelRunFailedValidation(string runId, string error, string moduleName = null, string elementId = null) { }
+        public void ModelRunFailed(string runId, string message, string stackTrace, string moduleName = null, string elementId = null) { }
+        public void SendStatusMessage(string runId, string message) { }
+        public void SendOptimizationResults(string runId, System.Collections.Generic.IReadOnlyList<(int nodeIndex, double value)> results) { }
+        public void SendIterationProgress(string runId, int iteration, double fitness, int fitnessTestsThisIteration,
+            System.Collections.Generic.IReadOnlyList<(int nodeIndex, double value)> values) { }
+        public void ModelRunComplete(string runId) { }
+        public void SendRunArtifacts(string runId, string runDirectory) { }
+    }
+}
\ No newline at end of file
diff --git a/tests/XTMF2.UnitTests/Bus/TestSchedulerReservations.cs b/tests/XTMF2.UnitTests/Bus/TestSchedulerReservations.cs
new file mode 100644
index 00000000..9cdf1cb8
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/TestSchedulerReservations.cs
@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+
+namespace XTMF2.UnitTests.Bus;
+
+[TestClass]
+public class TestSchedulerReservations
+{
+    [TestMethod]
+    public async Task Reservation_HoldsOrdinaryRunsUntilReleased()
+    {
+        using var scheduler = new Scheduler(runLocal: true);
+        Assert.IsTrue(RunContext.CreateRunContext(null!, "worker-run", [], Path.GetTempPath(),
+            "Start", RunMode.Normal, out var workerContext));
+        Assert.IsTrue(RunContext.CreateRunContext(null!, "ordinary-run", [], Path.GetTempPath(),
+            "Start", RunMode.Normal, out var ordinaryContext));
+        using var reservation = scheduler.Reserve(workerContext);
+        var sink = new RecordingRunOutputSink();
+
+        await reservation.Started.WaitAsync(TimeSpan.FromSeconds(3));
+        scheduler.Run(ordinaryContext, sink);
+
+        var inventory = scheduler.GetInventory();
+        Assert.HasCount(2, inventory);
+        Assert.IsTrue(inventory[0].IsRunning);
+        Assert.IsTrue(inventory[0].IsReservation);
+        Assert.AreEqual("ordinary-run", inventory[1].Context.ID);
+        Assert.IsFalse(inventory[1].IsRunning);
+        Assert.IsFalse(sink.RunFailed.Task.IsCompleted);
+
+        reservation.Dispose();
+        Assert.AreEqual("ordinary-run",
+            await sink.RunFailed.Task.WaitAsync(TimeSpan.FromSeconds(3)));
+    }
+
+    [TestMethod]
+    public async Task WorkerLeases_ShareOneScheduledTaskAndHoldOrdinaryRuns()
+    {
+        using var scheduler = new Scheduler(runLocal: true);
+        Assert.IsTrue(RunContext.CreateRunContext(null!, "worker-run-1", [], Path.GetTempPath(),
+            "Start", RunMode.Normal, out var firstWorkerContext));
+        Assert.IsTrue(RunContext.CreateRunContext(null!, "worker-run-2", [], Path.GetTempPath(),
+            "Start", RunMode.Normal, out var secondWorkerContext));
+        Assert.IsTrue(RunContext.CreateRunContext(null!, "ordinary-run-1", [], Path.GetTempPath(),
+            "Start", RunMode.Normal, out var firstOrdinaryContext));
+        Assert.IsTrue(RunContext.CreateRunContext(null!, "ordinary-run-2", [], Path.GetTempPath(),
+            "Start", RunMode.Normal, out var ordinaryContext));
+        var firstSink = new RecordingRunOutputSink();
+        var secondSink = new RecordingRunOutputSink();
+
+        using var firstLease = scheduler.ReserveGroup("estimation-run", firstWorkerContext, 2);
+        await firstLease.Started.WaitAsync(TimeSpan.FromSeconds(3));
+        scheduler.Run(firstOrdinaryContext, firstSink);
+
+        using var secondLease = scheduler.ReserveGroup("estimation-run", secondWorkerContext, 2);
+        await secondLease.Started.WaitAsync(TimeSpan.FromSeconds(3));
+        scheduler.Run(ordinaryContext, secondSink);
+
+        var inventory = scheduler.GetInventory();
+        Assert.AreEqual(1, inventory.Count(item => item.IsRunning && item.IsReservation));
+        Assert.IsFalse(firstSink.RunFailed.Task.IsCompleted);
+        Assert.IsFalse(secondSink.RunFailed.Task.IsCompleted);
+
+        firstLease.Dispose();
+        Assert.IsFalse(firstSink.RunFailed.Task.IsCompleted);
+        Assert.IsFalse(secondSink.RunFailed.Task.IsCompleted);
+        secondLease.Dispose();
+        var failedRuns = await Task.WhenAll(firstSink.RunFailed.Task, secondSink.RunFailed.Task)
+            .WaitAsync(TimeSpan.FromSeconds(3));
+        CollectionAssert.AreEquivalent(new[] { "ordinary-run-1", "ordinary-run-2" }, failedRuns);
+    }
+
+    private sealed class RecordingRunOutputSink : IRunOutputSink
+    {
+        public IReadOnlyList<string> ExtraDlls => Array.Empty<string>();
+        public TaskCompletionSource<string> RunFailed { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        public Task StartProcessingRequestFromRun(string id, Stream clientToRunStream) => Task.CompletedTask;
+        public void ModelRunFailedValidation(string runId, string error, string moduleName = null, string elementId = null) { }
+        public void ModelRunFailed(string runId, string message, string stackTrace, string moduleName = null, string elementId = null)
+            => RunFailed.TrySetResult(runId);
+        public void SendStatusMessage(string runId, string message) { }
+        public void SendOptimizationResults(string runId, IReadOnlyList<(int nodeIndex, double value)> results) { }
+        public void SendIterationProgress(string runId, int iteration, double fitness,
+            int fitnessTestsThisIteration, IReadOnlyList<(int nodeIndex, double value)> values) { }
+        public void ModelRunComplete(string runId) { }
+        public void SendRunArtifacts(string runId, string runDirectory) { }
+    }
+}
\ No newline at end of file
diff --git a/tests/XTMF2.UnitTests/Bus/TestSharedEstimationCoordinator.cs b/tests/XTMF2.UnitTests/Bus/TestSharedEstimationCoordinator.cs
new file mode 100644
index 00000000..d089657e
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/TestSharedEstimationCoordinator.cs
@@ -0,0 +1,243 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
+
+namespace XTMF2.UnitTests.Bus;
+
+[TestClass]
+public class TestSharedEstimationCoordinator
+{
+    [TestMethod]
+    public async Task EvaluateAsync_DispatchesAcrossWorkersAndPreservesCandidateOrder()
+    {
+        using var coordinator = new SharedEstimationCoordinator();
+        using var first = new FakeWorker("worker-1");
+        using var second = new FakeWorker("worker-2");
+        Assert.IsTrue(coordinator.AddWorker(first, out var error), error);
+        Assert.IsTrue(coordinator.AddWorker(second, out error), error);
+
+        var candidates = new[]
+        {
+            Candidate("candidate-1"),
+            Candidate("candidate-2"),
+            Candidate("candidate-3")
+        };
+        var completed = new ConcurrentQueue<(string WorkerId, SharedEstimationEvaluationResult Result)>();
+        var evaluation = coordinator.EvaluateAsync(candidates,
+            evaluationCompleted: (workerId, _, result) => completed.Enqueue((workerId, result)));
+
+        await first.WaitForSentCountAsync(1);
+        await second.WaitForSentCountAsync(1);
+        Assert.HasCount(1, first.Sent);
+        Assert.HasCount(1, second.Sent);
+        Assert.AreEqual("candidate-1", first.Sent.Single().CandidateId);
+        Assert.AreEqual("candidate-2", second.Sent.Single().CandidateId);
+
+        second.Complete("candidate-2", 2.0);
+        await second.WaitForSentCountAsync(2);
+        Assert.HasCount(1, completed);
+        Assert.AreEqual("candidate-3", second.Sent.Last().CandidateId);
+        first.Complete("candidate-1", 1.0);
+        Assert.HasCount(2, completed);
+        second.Complete("candidate-3", 3.0);
+        Assert.HasCount(3, completed);
+
+        var results = await evaluation;
+        Assert.HasCount(3, results);
+        CollectionAssert.AreEquivalent(new[] { "worker-1", "worker-2", "worker-2" },
+            completed.Select(item => item.WorkerId).ToArray());
+        CollectionAssert.AreEqual(
+            new[] { "candidate-1", "candidate-2", "candidate-3" },
+            results.Select(result => result.CandidateId).ToArray());
+    }
+
+    [TestMethod]
+    public async Task EvaluateAsync_AllowsSynchronousWorkersToCompleteDuringAsyncDispatch()
+    {
+        using var coordinator = new SharedEstimationCoordinator();
+        using var local = new FakeWorker("coordinator");
+        using var remote = new FakeWorker("remote");
+        local.OnSend = candidate => local.Complete(candidate.CandidateId, 1.0);
+        remote.OnSend = candidate => remote.Complete(candidate.CandidateId, 2.0);
+        Assert.IsTrue(coordinator.AddWorker(local, out var error), error);
+        Assert.IsTrue(coordinator.AddWorker(remote, out error), error);
+
+        var evaluation = coordinator.EvaluateAsync([
+            Candidate("candidate-1"),
+            Candidate("candidate-2"),
+            Candidate("candidate-3"),
+            Candidate("candidate-4")
+        ]);
+
+        var results = await evaluation;
+        await local.WaitForSentCountAsync(1);
+        await remote.WaitForSentCountAsync(1);
+
+        Assert.HasCount(4, results);
+        CollectionAssert.AreEqual(
+            new[] { "candidate-1", "candidate-2", "candidate-3", "candidate-4" },
+            results.Select(result => result.CandidateId).ToArray());
+    }
+
+    [TestMethod]
+    public async Task EvaluateAsync_RequeuesAssignedCandidateAfterDisconnect()
+    {
+        using var coordinator = new SharedEstimationCoordinator();
+        using var first = new FakeWorker("worker-1");
+        using var replacement = new FakeWorker("worker-2");
+        using var finalWorker = new FakeWorker("worker-3");
+        Assert.IsTrue(coordinator.AddWorker(first, out var error), error);
+        Assert.IsTrue(coordinator.AddWorker(replacement, out error), error);
+
+        var evaluation = coordinator.EvaluateAsync([Candidate("candidate-1")]);
+        await first.WaitForSentCountAsync(1);
+        first.Disconnect();
+        Assert.AreEqual(1, coordinator.ActiveWorkerCount);
+
+        await replacement.WaitForSentCountAsync(1);
+        Assert.AreEqual("candidate-1", replacement.Sent.Single().CandidateId);
+        first.Complete("candidate-1", 99.0);
+        replacement.Disconnect();
+        Assert.IsTrue(coordinator.AddWorker(finalWorker, out error), error);
+        await finalWorker.WaitForSentCountAsync(1);
+        Assert.AreEqual("candidate-1", finalWorker.Sent.Single().CandidateId);
+        finalWorker.Complete("candidate-1", 4.0);
+
+        var result = (await evaluation).Single();
+        Assert.AreEqual("candidate-1", result.CandidateId);
+        Assert.AreEqual(4.0, result.Fitness);
+    }
+
+    [TestMethod]
+    public async Task EvaluateAsync_RequeuesCandidateWhenWorkerSendThrows()
+    {
+        using var coordinator = new SharedEstimationCoordinator();
+        using var failedWorker = new FakeWorker("worker-failed")
+        {
+            SendException = new InvalidOperationException("Stream was not writable.")
+        };
+        using var replacement = new FakeWorker("worker-replacement");
+        Assert.IsTrue(coordinator.AddWorker(failedWorker, out var error), error);
+
+        var evaluation = coordinator.EvaluateAsync([Candidate("candidate-send-error")]);
+
+        await failedWorker.WaitForDisposedAsync();
+        Assert.IsTrue(failedWorker.IsDisposed);
+        Assert.AreEqual(0, coordinator.ActiveWorkerCount);
+        Assert.IsFalse(evaluation.IsCompleted);
+        Assert.IsTrue(coordinator.AddWorker(replacement, out error), error);
+        await replacement.WaitForSentCountAsync(1);
+        Assert.AreEqual("candidate-send-error", replacement.Sent.Single().CandidateId);
+        replacement.Complete("candidate-send-error", 6.0);
+
+        var result = (await evaluation).Single();
+        Assert.AreEqual(6.0, result.Fitness);
+    }
+
+    [TestMethod]
+    public async Task EvaluateAsync_DistributesSequentialCandidatesRoundRobin()
+    {
+        using var coordinator = new SharedEstimationCoordinator();
+        using var first = new FakeWorker("worker-1");
+        using var second = new FakeWorker("worker-2");
+        Assert.IsTrue(coordinator.AddWorker(first, out var error), error);
+        Assert.IsTrue(coordinator.AddWorker(second, out error), error);
+
+        var firstEvaluation = coordinator.EvaluateAsync([Candidate("candidate-1")]);
+        await first.WaitForSentCountAsync(1);
+        first.Complete("candidate-1", 1.0);
+        await firstEvaluation;
+
+        var secondEvaluation = coordinator.EvaluateAsync([Candidate("candidate-2")]);
+        await second.WaitForSentCountAsync(1);
+        Assert.AreEqual("candidate-2", second.Sent.Single().CandidateId);
+        second.Complete("candidate-2", 2.0);
+        await secondEvaluation;
+
+        var nextFirstEvaluation = coordinator.EvaluateAsync([Candidate("candidate-3")]);
+        await first.WaitForSentCountAsync(2);
+        Assert.AreEqual("candidate-3", first.Sent.Last().CandidateId);
+        first.Complete("candidate-3", 3.0);
+        await nextFirstEvaluation;
+    }
+
+    private static SharedEstimationCandidate Candidate(string id)
+        => new("run-1", 1, id, new[] { 1.0 });
+
+    private sealed class FakeWorker(string workerId) : ISharedEstimationWorker
+    {
+        private readonly object _sync = new();
+        private readonly List<SharedEstimationCandidate> _sent = [];
+        private TaskCompletionSource _sentChanged = NewSignal();
+        private readonly TaskCompletionSource _disposed = NewSignal();
+
+        public string WorkerId { get; } = workerId;
+        public IReadOnlyList<SharedEstimationCandidate> Sent
+        {
+            get
+            {
+                lock (_sync)
+                    return _sent.ToArray();
+            }
+        }
+        public bool IsDisposed => _disposed.Task.IsCompleted;
+        public Exception SendException { get; init; } = null!;
+        public Action<SharedEstimationCandidate> OnSend { get; set; } = null!;
+
+        public event EventHandler<SharedEstimationEvaluationResult> ResultReceived;
+        public event EventHandler Disconnected;
+
+        public bool SendCandidate(SharedEstimationCandidate candidate, out string error)
+        {
+            if (SendException is not null)
+                throw SendException;
+            error = null;
+            TaskCompletionSource changed;
+            lock (_sync)
+            {
+                _sent.Add(candidate);
+                changed = _sentChanged;
+                _sentChanged = NewSignal();
+            }
+            changed.TrySetResult();
+            OnSend?.Invoke(candidate);
+            return !IsDisposed;
+        }
+
+        public async Task WaitForSentCountAsync(int count)
+        {
+            while (true)
+            {
+                Task changed;
+                lock (_sync)
+                {
+                    if (_sent.Count >= count)
+                        return;
+                    changed = _sentChanged.Task;
+                }
+                await changed.WaitAsync(TimeSpan.FromSeconds(5));
+            }
+        }
+
+        public Task WaitForDisposedAsync() => _disposed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        public void Complete(string candidateId, double fitness)
+        {
+            var candidate = Sent.Single(candidate => candidate.CandidateId == candidateId);
+            ResultReceived?.Invoke(this, new SharedEstimationEvaluationResult(
+                candidate.RunId, candidate.BatchId, candidate.CandidateId, fitness, null, null, null));
+        }
+
+        public void Disconnect() => Disconnected?.Invoke(this, EventArgs.Empty);
+
+        public void Dispose() => _disposed.TrySetResult();
+
+        private static TaskCompletionSource NewSignal()
+            => new(TaskCreationOptions.RunContinuationsAsynchronously);
+    }
+}
diff --git a/tests/XTMF2.UnitTests/Bus/TestSharedEstimationWorkerParticipant.cs b/tests/XTMF2.UnitTests/Bus/TestSharedEstimationWorkerParticipant.cs
new file mode 100644
index 00000000..377d9fef
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/TestSharedEstimationWorkerParticipant.cs
@@ -0,0 +1,71 @@
+using System;
+using System.IO;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+using XTMF2.Bus.Optimization;
+using XTMF2.ModelSystemConstruct;
+using XTMF2.RuntimeModules;
+using XTMF2.UnitTests.Modules;
+using static XTMF2.UnitTests.TestHelper;
+
+namespace XTMF2.UnitTests.Bus;
+
+[TestClass]
+public class TestSharedEstimationWorkerParticipant
+{
+    [TestMethod]
+    public void Evaluate_UsesPreparedModelSystemAndReturnsFitness()
+    {
+        RunInModelSystemContext("SharedEstimationWorkerParticipant", (user, projectSession, session) =>
+        {
+            XTMF2.Editing.CommandError error = null;
+            var modelSystem = session.ModelSystem;
+            Assert.IsTrue(session.AddModelSystemStart(user, modelSystem.GlobalBoundary, "Start",
+                Rectangle.Hidden, out Start start, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Ignore",
+                typeof(IgnoreResult<string>), Rectangle.Hidden, out var ignore, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Action",
+                typeof(SimpleTestModule), Rectangle.Hidden, out var action, out error), error?.Message);
+            Assert.IsTrue(session.AddLink(user, start, start.Hooks[0], ignore, out var firstLink, out error), error?.Message);
+            Assert.IsTrue(session.AddLink(user, ignore, ignore.Hooks[0], action, out var secondLink, out error), error?.Message);
+
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Fitness",
+                typeof(BasicParameter<float>), Rectangle.Hidden, out var fitness, out error), error?.Message);
+            Assert.IsTrue(session.SetParameterValue(user, fitness, "2.5", out error), error?.Message);
+            Assert.IsTrue(session.SetEstimationFitnessNode(user, fitness, out error), error?.Message);
+            Assert.IsTrue(session.AddNode(user, modelSystem.GlobalBoundary, "Parameter",
+                typeof(SetableParameter<float>), Rectangle.Hidden, out var parameter, out error), error?.Message);
+            Assert.IsTrue(session.SetParameterValue(user, parameter, "0.5", out error), error?.Message);
+            Assert.IsTrue(session.AddEstimationGroup(user, "Group", out var group, out error), error?.Message);
+            Assert.IsTrue(session.AddEstimationParameter(user, group!, parameter,
+                0.0, 1.0, 0.5, out var entry, out error), error?.Message);
+
+            using var serialized = new MemoryStream();
+            Assert.IsTrue(session.Save(out error, serialized), error?.Message);
+            var request = new SharedEstimationRunRequest(
+                "shared-run", Directory.GetCurrentDirectory(), "Start", serialized.ToArray());
+
+            Assert.IsTrue(SharedEstimationWorkerParticipant.TryCreate(
+                CreateRuntime(), request, out var participant, out var runError), runError?.Message);
+            var result = participant!.Evaluate(new SharedEstimationCandidate(
+                "shared-run", 1, "candidate-1", new[] { 0.75 }));
+
+            Assert.AreEqual("candidate-1", result.CandidateId);
+            Assert.AreEqual(2.5, result.Fitness, 0.0001);
+            Assert.IsNull(result.Error);
+
+            Assert.IsTrue(SharedEstimationLocalWorker.TryCreate(
+                "coordinator", CreateRuntime(), request, out var localWorker, out var localError), localError);
+            using (localWorker)
+            using (var coordinator = new SharedEstimationCoordinator())
+            {
+                Assert.IsTrue(coordinator.AddWorker(localWorker!, out var addError), addError);
+                var localResult = coordinator.EvaluateAsync([new SharedEstimationCandidate(
+                    "shared-run", 2, "coordinator-candidate", new[] { 0.25 })]).GetAwaiter().GetResult().Single();
+                Assert.AreEqual(2.5, localResult.Fitness, 0.0001);
+                Assert.IsNull(localResult.Error);
+            }
+        });
+    }
+}
diff --git a/tests/XTMF2.UnitTests/Bus/TestSharedEstimationWorkingDirectoryLease.cs b/tests/XTMF2.UnitTests/Bus/TestSharedEstimationWorkingDirectoryLease.cs
new file mode 100644
index 00000000..40e53048
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Bus/TestSharedEstimationWorkingDirectoryLease.cs
@@ -0,0 +1,54 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using XTMF2.Bus;
+
+namespace XTMF2.UnitTests.Bus;
+
+[TestClass]
+[DoNotParallelize]
+public class TestSharedEstimationWorkingDirectoryLease
+{
+    [TestMethod]
+    public async Task Acquire_AllowsSameDirectoryAndQueuesDifferentDirectories()
+    {
+        var originalDirectory = Directory.GetCurrentDirectory();
+        var firstDirectory = Directory.CreateTempSubdirectory("xtmf-worker-cwd-a-");
+        var secondDirectory = Directory.CreateTempSubdirectory("xtmf-worker-cwd-b-");
+        Task<string> differentDirectory = Task.FromResult(String.Empty);
+        try
+        {
+            using (var firstLease = SharedEstimationWorkingDirectoryLease.Acquire(firstDirectory.FullName))
+            {
+                Assert.AreEqual(firstDirectory.FullName, Directory.GetCurrentDirectory());
+                var sameDirectory = Task.Run(() =>
+                {
+                    using var lease = SharedEstimationWorkingDirectoryLease.Acquire(firstDirectory.FullName);
+                    return Directory.GetCurrentDirectory();
+                });
+                Assert.AreEqual(firstDirectory.FullName, await sameDirectory);
+
+                using var started = new ManualResetEventSlim();
+                differentDirectory = Task.Run(() =>
+                {
+                    started.Set();
+                    using var lease = SharedEstimationWorkingDirectoryLease.Acquire(secondDirectory.FullName);
+                    return Directory.GetCurrentDirectory();
+                });
+                Assert.IsTrue(started.Wait(TimeSpan.FromSeconds(3)));
+                Assert.IsFalse(differentDirectory.Wait(TimeSpan.FromMilliseconds(50)));
+            }
+
+            Assert.AreEqual(secondDirectory.FullName, await differentDirectory);
+            Assert.AreEqual(originalDirectory, Directory.GetCurrentDirectory());
+        }
+        finally
+        {
+            Directory.SetCurrentDirectory(originalDirectory);
+            firstDirectory.Delete(true);
+            secondDirectory.Delete(true);
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/XTMF2.UnitTests/ModelSystemConstruct/TestOptimization.cs b/tests/XTMF2.UnitTests/ModelSystemConstruct/TestOptimization.cs
index 7a4ce87c..d3c7dbf6 100644
--- a/tests/XTMF2.UnitTests/ModelSystemConstruct/TestOptimization.cs
+++ b/tests/XTMF2.UnitTests/ModelSystemConstruct/TestOptimization.cs
@@ -828,7 +828,12 @@ public void Estimation_AlgorithmConfig_NelderMeadPersistence()
             (user, pSession, msSession) =>
             {
                 CommandError error = null;
-                var cfg = new NelderMeadConfig { MaxIterations = 999, ConvergenceTolerance = 1e-9 };
+                var cfg = new NelderMeadConfig
+                {
+                    MaxIterations = 999,
+                    ConvergenceTolerance = 1e-9,
+                    RandomSeed = 202401
+                };
                 Assert.IsTrue(msSession.SetEstimationAlgorithmConfig(user, cfg, out error), error?.Message);
             },
             (user, pSession, msSession) =>
@@ -838,6 +843,7 @@ public void Estimation_AlgorithmConfig_NelderMeadPersistence()
                 var loaded = (NelderMeadConfig)ms.EstimationAlgorithmConfig;
                 Assert.AreEqual(999, loaded.MaxIterations);
                 Assert.AreEqual(1e-9, loaded.ConvergenceTolerance);
+                Assert.AreEqual(202401, loaded.RandomSeed);
             });
     }
 
@@ -855,7 +861,8 @@ public void Estimation_AlgorithmConfig_ParticleSwarmPersistence()
                     Inertia = 0.5,
                     CognitiveCoeff = 1.2,
                     SocialCoeff = 1.3,
-                    ConvergenceTolerance = 1e-8
+                    ConvergenceTolerance = 1e-8,
+                    RandomSeed = 202402
                 };
                 Assert.IsTrue(msSession.SetEstimationAlgorithmConfig(user, cfg, out error), error?.Message);
             },
@@ -870,6 +877,7 @@ public void Estimation_AlgorithmConfig_ParticleSwarmPersistence()
                 Assert.AreEqual(1.2,  loaded.CognitiveCoeff);
                 Assert.AreEqual(1.3,  loaded.SocialCoeff);
                 Assert.AreEqual(1e-8, loaded.ConvergenceTolerance);
+                Assert.AreEqual(202402, loaded.RandomSeed);
             });
     }
 
@@ -888,7 +896,8 @@ public void Estimation_AlgorithmConfig_GeneticAlgorithmPersistence()
                     MutationRate = 0.02,
                     ElitismCount = 4,
                     TournamentSize = 5,
-                    ConvergenceTolerance = 1e-7
+                    ConvergenceTolerance = 1e-7,
+                    RandomSeed = 202403
                 };
                 Assert.IsTrue(msSession.SetEstimationAlgorithmConfig(user, cfg, out error), error?.Message);
             },
@@ -904,6 +913,25 @@ public void Estimation_AlgorithmConfig_GeneticAlgorithmPersistence()
                 Assert.AreEqual(4,    loaded.ElitismCount);
                 Assert.AreEqual(5,    loaded.TournamentSize);
                 Assert.AreEqual(1e-7, loaded.ConvergenceTolerance);
+                Assert.AreEqual(202403, loaded.RandomSeed);
+            });
+    }
+
+    [TestMethod]
+    public void Estimation_AlgorithmConfig_StochasticGradientPersistence()
+    {
+        TestHelper.RunInModelSystemContext("Estimation_AlgorithmConfig_StochasticGradientPersistence",
+            (user, pSession, msSession) =>
+            {
+                CommandError error = null;
+                var config = new StochasticGradientConfig { RandomSeed = -202404 };
+                Assert.IsTrue(msSession.SetEstimationAlgorithmConfig(user, config, out error), error?.Message);
+            },
+            (user, pSession, msSession) =>
+            {
+                Assert.IsInstanceOfType<StochasticGradientConfig>(msSession.ModelSystem.EstimationAlgorithmConfig);
+                Assert.AreEqual(-202404,
+                    ((StochasticGradientConfig)msSession.ModelSystem.EstimationAlgorithmConfig).RandomSeed);
             });
     }
 
@@ -930,11 +958,14 @@ public void Estimation_AlgorithmConfig_SetConfig_Undo()
             {
                 CommandError error = null;
                 var original = msSession.ModelSystem.EstimationAlgorithmConfig;
-                var pso = new ParticleSwarmConfig { SwarmSize = 10 };
+                var pso = new ParticleSwarmConfig { SwarmSize = 10, RandomSeed = 654321 };
                 Assert.IsTrue(msSession.SetEstimationAlgorithmConfig(user, pso, out error), error?.Message);
                 Assert.IsInstanceOfType<ParticleSwarmConfig>(msSession.ModelSystem.EstimationAlgorithmConfig);
+                Assert.AreEqual(654321,
+                    ((ParticleSwarmConfig)msSession.ModelSystem.EstimationAlgorithmConfig).RandomSeed);
                 Assert.IsTrue(msSession.Undo(user, out error), error?.Message);
                 Assert.AreEqual(original.AlgorithmId, msSession.ModelSystem.EstimationAlgorithmConfig.AlgorithmId);
+                Assert.AreEqual(42, msSession.ModelSystem.EstimationAlgorithmConfig.RandomSeed);
             });
     }
 
diff --git a/tests/XTMF2.UnitTests/Modules/PathValidationModule.cs b/tests/XTMF2.UnitTests/Modules/PathValidationModule.cs
new file mode 100644
index 00000000..7ca60d1d
--- /dev/null
+++ b/tests/XTMF2.UnitTests/Modules/PathValidationModule.cs
@@ -0,0 +1,24 @@
+using System.IO;
+
+namespace XTMF2.UnitTests.Modules;
+
+[Module(Name = "Path Validation Module", DocumentationLink = "http://tmg.utoronto.ca/doc/2.0",
+    Description = "Validates a worker-local path.")]
+public sealed class PathValidationModule : BaseFunction<string>
+{
+    [Parameter(Name = "Path", Description = "Path to validate", Required = true, Index = 0)]
+    public IFunction<string> Path;
+
+    public override string Invoke() => Path?.Invoke() ?? string.Empty;
+
+    public override bool RuntimeValidation(ref string error)
+    {
+        var path = Path?.Invoke();
+        if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
+        {
+            error = $"The worker-local path '{path}' does not exist.";
+            return false;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/tests/XTMF2.UnitTests/TestHelper.cs b/tests/XTMF2.UnitTests/TestHelper.cs
index 03a5e6d9..af49d52b 100644
--- a/tests/XTMF2.UnitTests/TestHelper.cs
+++ b/tests/XTMF2.UnitTests/TestHelper.cs
@@ -37,11 +37,11 @@ static class TestHelper
         /// <summary>
         /// Isolated user directory for the XTMF2.UnitTests assembly.
         /// Using a temp path that differs from both the production directory and the GUI-tests
-        /// directory ensures no cross-process file-handle collisions when <c>dotnet test</c>
-        /// runs both test assemblies concurrently.
+        /// directory prevents cross-assembly file-handle collisions.
         /// </summary>
         private static readonly string s_testUserDirectory =
             Path.Combine(Path.GetTempPath(), "XTMF2", "UnitTests", "Users");
+        private static readonly string s_testProcessId = Environment.ProcessId.ToString("X");
 
         private static readonly XTMFRuntime s_sharedRuntime = XTMFRuntime.CreateRuntime(s_testUserDirectory);
 
@@ -73,7 +73,7 @@ internal static void RunInProjectContext(string name, Action<User, ProjectSessio
             var userController = runtime.UserController;
             var projectController = runtime.ProjectController;
             CommandError error = null;
-            string userName = name + "TempUser";
+            string userName = $"{name}_{s_testProcessId}TempUser";
             string projectName = "TestProject";
             // clear out the user if possible
             userController.Delete(userName);
@@ -104,7 +104,7 @@ internal static void RunInProjectContext(string name, Action<User, ProjectSessio
             var userController = runtime.UserController;
             var projectController = runtime.ProjectController;
             CommandError error = null;
-            string userName = name + "TempUser";
+            string userName = $"{name}_{s_testProcessId}TempUser";
             string projectName = "TestProject";
             // clear out the user if possible
             userController.Delete(userName);
@@ -140,7 +140,7 @@ internal static void RunInProjectContext(string name, Action<XTMFRuntime, User,
             var userController = runtime.UserController;
             var projectController = runtime.ProjectController;
             CommandError error = null;
-            string userName = name + "TempUser";
+            string userName = $"{name}_{s_testProcessId}TempUser";
             string projectName = "TestProject";
             // clear out the user if possible
             userController.Delete(userName);
@@ -170,7 +170,7 @@ internal static void RunInProjectContext(string name, Action<User, User, Project
             var userController = runtime.UserController;
             var projectController = runtime.ProjectController;
             CommandError error = null;
-            string userName = name + "TempUser";
+            string userName = $"{name}_{s_testProcessId}TempUser";
             string unauthorizedUserName = userName + "Hacker";
             string projectName = "TestProject";
             // clear out the user if possible
@@ -203,7 +203,7 @@ internal static void RunInModelSystemContext(string name, Action<User, ProjectSe
             var userController = runtime.UserController;
             var projectController = runtime.ProjectController;
             CommandError error = null;
-            string userName = name + "TempUser";
+            string userName = $"{name}_{s_testProcessId}TempUser";
             string projectName = "TestProject";
             string modelSystemName = "ModelSystem1";
             // clear out the user if possible
@@ -238,8 +238,8 @@ internal static void RunInModelSystemContext(string name, Action<User, User, Pro
             var userController = runtime.UserController;
             var projectController = runtime.ProjectController;
             CommandError error = null;
-            string userName = name + "TempUser";
-            string unauthorizedUserName = name + "Hacker";
+            string userName = $"{name}_{s_testProcessId}TempUser";
+            string unauthorizedUserName = userName + "Hacker";
             string projectName = "TestProject";
             string modelSystemName = "ModelSystem1";
             // clear out the user if possible
@@ -343,7 +343,7 @@ internal static void RunInModelSystemContext(string name, Action<User, ProjectSe
             var userController = runtime.UserController;
             var projectController = runtime.ProjectController;
             CommandError error = null;
-            string userName = name + "TempUser";
+            string userName = $"{name}_{s_testProcessId}TempUser";
             string projectName = "TestProject";
             string modelSystemName = "ModelSystem1";
             // clear out the user if possible
diff --git a/tests/XTMF2.UnitTests/TestOptimizationRun.cs b/tests/XTMF2.UnitTests/TestOptimizationRun.cs
index 61d8b0a5..92c4002a 100644
--- a/tests/XTMF2.UnitTests/TestOptimizationRun.cs
+++ b/tests/XTMF2.UnitTests/TestOptimizationRun.cs
@@ -76,6 +76,7 @@ public void EstimationRun_DoesNotCrash()
                 min: 0.0, max: 1.0, nullHypothesis: 0.5, out _, out error), error?.Message);
 
             // ── run ────────────────────────────────────────────────────────────
+            var runDirectory = Path.Combine(pSession.RunsDirectory, "EstimationRun");
             CreateRunClient(true, (runBus) =>
             {
                 bool success = false;
@@ -93,7 +94,7 @@ public void EstimationRun_DoesNotCrash()
                 };
 
                 Assert.IsTrue(runBus.RunModelSystem(msSession,
-                    Path.Combine(pSession.RunsDirectory, "EstimationRun"),
+                    runDirectory,
                     "Start", RunMode.Estimation, out _, out error), error?.Message);
 
                 if (!sim.Wait(30000))
@@ -101,6 +102,10 @@ public void EstimationRun_DoesNotCrash()
 
                 Assert.IsTrue(success, "Estimation run did not complete successfully: " + error?.ToString());
             });
+
+            var reportLines = File.ReadAllLines(Path.Combine(runDirectory, "estimation_report.csv"));
+            Assert.AreEqual("Iteration,Fitness,Param", reportLines[0]);
+            Assert.IsGreaterThan(1, reportLines.Length, "The estimation report should contain evaluation rows.");
         });
     }
 
diff --git a/tests/XTMF2.UnitTests/TestProjects.cs b/tests/XTMF2.UnitTests/TestProjects.cs
index 485d163b..45898bde 100644
--- a/tests/XTMF2.UnitTests/TestProjects.cs
+++ b/tests/XTMF2.UnitTests/TestProjects.cs
@@ -20,6 +20,7 @@ You should have received a copy of the GNU General Public License
 using System;
 using System.IO;
 using System.Linq;
+using System.Text.Json.Nodes;
 using XTMF2.Editing;
 using XTMF2.RuntimeModules;
 
@@ -100,6 +101,8 @@ public void ProjectPersistence()
             var controller = runtime.ProjectController;
             const string projectName = "Test";
             CommandError error = null;
+            Guid projectId = Guid.Empty;
+            Guid modelSystemId = Guid.Empty;
             var localUser = TestHelper.GetTestUser(runtime, "ProjectPersistence");
             // delete the project just in case it survived
             controller.DeleteProject(localUser, projectName, out error);
@@ -109,6 +112,10 @@ public void ProjectPersistence()
                 var project = session.Project;
                 Assert.AreEqual(projectName, project.Name);
                 Assert.AreEqual(localUser, project.Owner);
+                Assert.IsTrue(session.CreateNewModelSystem(localUser, "IdentityModel", out var header, out error), error?.Message);
+                Assert.IsNotNull(header);
+                projectId = project.Id;
+                modelSystemId = header.Id;
             }), "Unable to create project");
             var numberOfProjects = localUser.AvailableProjects.Count;
             // Simulate a shutdown of XTMF
@@ -121,6 +128,51 @@ public void ProjectPersistence()
             var regainedProject = localUser.AvailableProjects.FirstOrDefault(p => p.Name == projectName);
             Assert.IsNotNull(regainedProject, $"Project '{projectName}' not found after restart");
             Assert.AreEqual(projectName, regainedProject.Name);
+            Assert.AreEqual(projectId, regainedProject.Id);
+            Assert.AreEqual(modelSystemId, regainedProject.ModelSystems.Single(header => header.Name == "IdentityModel").Id);
+        }
+
+        [TestMethod]
+        public void LegacyProjectAndModelSystemIdentityIsMigrated()
+        {
+            const string runtimeName = "LegacyIdentityMigration";
+            var runtime = TestHelper.CreateRuntime(runtimeName);
+            var controller = runtime.ProjectController;
+            var user = TestHelper.GetTestUser(runtime, runtimeName);
+            Assert.IsTrue(controller.CreateNewProject(user, "LegacyProject", out var session, out var error), error?.Message);
+            Guid originalProjectId;
+            Guid originalModelSystemId;
+            string projectFilePath;
+            using (session)
+            {
+                Assert.IsTrue(session.CreateNewModelSystem(user, "LegacyModel", out var header, out error), error?.Message);
+                originalProjectId = session.Project.Id;
+                originalModelSystemId = header.Id;
+                projectFilePath = session.Project.ProjectFilePath!;
+            }
+
+            var projectJson = JsonNode.Parse(File.ReadAllText(projectFilePath))!.AsObject();
+            projectJson.Remove("Id");
+            foreach (var header in projectJson["ModelSystemHeaders"]!.AsArray())
+                header!.AsObject().Remove("Id");
+            File.WriteAllText(projectFilePath, projectJson.ToJsonString());
+
+            runtime.Shutdown();
+            runtime = TestHelper.CreateRuntime(runtimeName);
+            user = TestHelper.GetTestUser(runtime, runtimeName, false);
+            var migratedProject = user.AvailableProjects.Single(project => project.Name == "LegacyProject");
+            var migratedModelSystemId = migratedProject.ModelSystems.Single().Id;
+            Assert.AreNotEqual(Guid.Empty, migratedProject.Id);
+            Assert.AreNotEqual(Guid.Empty, migratedModelSystemId);
+            Assert.AreNotEqual(originalProjectId, migratedProject.Id);
+            Assert.AreNotEqual(originalModelSystemId, migratedModelSystemId);
+
+            runtime.Shutdown();
+            runtime = TestHelper.CreateRuntime(runtimeName);
+            user = TestHelper.GetTestUser(runtime, runtimeName, false);
+            var reloadedProject = user.AvailableProjects.Single(project => project.Name == "LegacyProject");
+            Assert.AreEqual(migratedProject.Id, reloadedProject.Id);
+            Assert.AreEqual(migratedModelSystemId, reloadedProject.ModelSystems.Single().Id);
         }
 
         [TestMethod]
diff --git a/tests/XTMF2.UnitTests/TestUsers.cs b/tests/XTMF2.UnitTests/TestUsers.cs
index e2d4c587..59e65007 100644
--- a/tests/XTMF2.UnitTests/TestUsers.cs
+++ b/tests/XTMF2.UnitTests/TestUsers.cs
@@ -17,6 +17,7 @@ You should have received a copy of the GNU General Public License
     along with XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 using System;
+using System.IO;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using XTMF2;
 using XTMF2.Editing;
@@ -73,12 +74,24 @@ public void UserPersistence()
             // ensure the user doesn't exist before we start
             userController.Delete(userName);
             Assert.IsTrue(userController.CreateNew(userName, false, out var user, out error));
+            var userPath = user.UserPath;
+            File.WriteAllText(Path.Combine(userPath, "User.xusr"),
+                $"{{\"UserName\":\"{userName}\",\"Admin\":false}}");
             // unload XTMF to simulate it shutting down
             runtime.Shutdown();
             // rebuild XTMF
             runtime = TestHelper.CreateRuntime("UserPersistence");
             userController = runtime.UserController;
-            Assert.IsNotNull(userController.Users.FirstOrDefault(u => u.UserName == user.UserName));
+            var loadedUser = userController.Users.FirstOrDefault(u => u.UserName == user.UserName);
+            Assert.IsNotNull(loadedUser);
+            Assert.AreNotEqual(Guid.Empty, loadedUser.UserId);
+            var persistedUserId = loadedUser.UserId;
+            runtime.Shutdown();
+            runtime = TestHelper.CreateRuntime("UserPersistence");
+            userController = runtime.UserController;
+            loadedUser = userController.Users.FirstOrDefault(u => u.UserName == user.UserName);
+            Assert.IsNotNull(loadedUser);
+            Assert.AreEqual(persistedUserId, loadedUser.UserId);
             // cleanup
             Assert.IsTrue(userController.Delete(userName));
         }
diff --git a/tests/XTMF2.UnitTests/XTMF2.UnitTests.csproj b/tests/XTMF2.UnitTests/XTMF2.UnitTests.csproj
index fd41d3e0..6b73fa6e 100644
--- a/tests/XTMF2.UnitTests/XTMF2.UnitTests.csproj
+++ b/tests/XTMF2.UnitTests/XTMF2.UnitTests.csproj
@@ -13,6 +13,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\XTMF2.Client\XTMF2.RunServer.csproj" />
+    <ProjectReference Include="..\..\src\XTMF2.RunServer.Updater\XTMF2.RunServer.Updater.csproj" />
     <ProjectReference Include="..\..\src\XTMF2\XTMF2.csproj" />
     <ProjectReference Include="..\..\src\XTMF2.AI\XTMF2.AI.csproj" />
     <ProjectReference Include="..\..\src\XTMF2.Interfaces\XTMF2.Interfaces.csproj" />