diff --git a/README.md b/README.md
index 7315d56..29ed1f8 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/src/XTMF2.Client/Program.cs b/src/XTMF2.Client/Program.cs
index ac9ec8c..8807715 100644
--- a/src/XTMF2.Client/Program.cs
+++ b/src/XTMF2.Client/Program.cs
@@ -19,6 +19,8 @@ You should have received a copy of the GNU General Public License
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO.Compression;
+using System.Linq;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -27,15 +29,25 @@ 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>();
+
         [MTAThread]
         static void Main(string[] args)
         {
+            _originalArguments = args;
+            if (string.Equals(Environment.GetEnvironmentVariable("XTMF2_DEPLOYMENT_WATCHDOG"), "1", StringComparison.Ordinal))
+            {
+                RunDeploymentWatchdog(args);
+                return;
+            }
+            LogDeploymentStartupSummary();
             if (args.Length == 0)
             {
                 Console.WriteLine("Usage: XTMF.Run [-setup-security DIRECTORY] [-loadDLL dllPath] [-tcp ADDRESS PORT -security DIRECTORY] [-namedPipe PIPE_NAME]");
@@ -177,8 +189,11 @@ 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();
+            SignalDeploymentReady();
             using (tcpListener)
             using (var shutdown = new CancellationTokenSource())
+            using (var remoteEstimationRegistry = new RemoteSharedEstimationRegistry())
+            using (var remoteRunRegistry = new RemoteRunRegistry())
             {
                 Console.CancelKeyPress += (_, eventArgs) =>
                 {
@@ -212,13 +227,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 +246,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,7 +259,8 @@ 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";
             using (client)
@@ -255,7 +277,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,7 +293,9 @@ 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 runtime = XTMFRuntime.CreateRuntime(config);
             var loadedConfig = runtime.SystemConfiguration;
@@ -276,8 +303,350 @@ private static void RunClient(Stream serverStream, List<string> extraDlls, Syste
             {
                 loadedConfig.LoadAssembly(dll);
             }
-            using var clientBus = new RunServerBus(serverStream, true, runtime, extraDlls, System.Diagnostics.Debugger.IsAttached, usePrivateWorkspace);
-            clientBus.ProcessRequests();
+            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 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);
+                ExtractDeploymentArchive(archivePath, deploymentDirectory);
+                EnsureDeploymentPayload(deploymentDirectory);
+
+                var readyFile = Path.Combine(deploymentDirectory, ".deployment-ready");
+                var watchdogInfo = CreateRunServerStartInfo(processPath, processDirectory, _originalArguments);
+                watchdogInfo.Environment["XTMF2_DEPLOYMENT_WATCHDOG"] = "1";
+                watchdogInfo.Environment["XTMF2_DEPLOYMENT_WATCHDOG_OLD_PID"] =
+                    Environment.ProcessId.ToString();
+                watchdogInfo.Environment["XTMF2_DEPLOYMENT_WATCHDOG_READY_FILE"] = readyFile;
+                watchdogInfo.Environment["XTMF2_DEPLOYMENT_WATCHDOG_PROCESS_PATH"] = processPath;
+                watchdogInfo.Environment["XTMF2_DEPLOYMENT_WATCHDOG_DEPLOYMENT_DIRECTORY"] = deploymentDirectory;
+                foreach (var argument in _originalArguments)
+                    watchdogInfo.ArgumentList.Add(argument);
+                if (Process.Start(watchdogInfo) is null)
+                    throw new InvalidOperationException("Unable to start the deployment watchdog.");
+                Environment.Exit(0);
+                return true;
+            }
+            catch (Exception exception) when (exception is IOException or InvalidDataException or UnauthorizedAccessException or
+                InvalidOperationException or System.ComponentModel.Win32Exception)
+            {
+                Console.Error.WriteLine($"Unable to restart RunServer: {exception.Message}");
+                if (deploymentDirectory is not null)
+                {
+                    try
+                    {
+                        Directory.Delete(deploymentDirectory, recursive: true);
+                    }
+                    catch (IOException cleanupException)
+                    {
+                        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))
+                return;
+
+            try
+            {
+                File.WriteAllText(readyFile, "ready");
+            }
+            catch (IOException exception)
+            {
+                Console.Error.WriteLine($"Unable to signal RunServer readiness: {exception.Message}");
+            }
+        }
+
+        private static void RunDeploymentWatchdog(string[] arguments)
+        {
+            var readyFile = Environment.GetEnvironmentVariable("XTMF2_DEPLOYMENT_WATCHDOG_READY_FILE");
+            var processPath = Environment.GetEnvironmentVariable("XTMF2_DEPLOYMENT_WATCHDOG_PROCESS_PATH");
+            var deploymentDirectory = Environment.GetEnvironmentVariable("XTMF2_DEPLOYMENT_WATCHDOG_DEPLOYMENT_DIRECTORY");
+            if (string.IsNullOrWhiteSpace(readyFile) || string.IsNullOrWhiteSpace(processPath) ||
+                string.IsNullOrWhiteSpace(deploymentDirectory))
+                return;
+
+            var oldProcessIdText = Environment.GetEnvironmentVariable("XTMF2_DEPLOYMENT_WATCHDOG_OLD_PID");
+            _ = int.TryParse(oldProcessIdText, out var oldProcessId);
+            var installationDirectory = GetInstallationDirectory(processPath);
+            var deadline = DateTime.UtcNow.AddSeconds(30);
+            while (DateTime.UtcNow < deadline)
+            {
+                try
+                {
+                    if (oldProcessId <= 0 || Process.GetProcessById(oldProcessId).HasExited)
+                        break;
+                }
+                catch (ArgumentException)
+                {
+                    break;
+                }
+                Thread.Sleep(250);
+            }
+
+            string? backupDirectory = null;
+            Process? deployedProcess = null;
+            try
+            {
+                if (oldProcessId > 0)
+                {
+                    try
+                    {
+                        if (!Process.GetProcessById(oldProcessId).HasExited)
+                            throw new InvalidOperationException("The previous RunServer process did not exit before activation.");
+                    }
+                    catch (ArgumentException)
+                    {
+                    }
+                }
+
+                backupDirectory = Path.Combine(deploymentDirectory, ".backup");
+                Directory.CreateDirectory(backupDirectory);
+                EnsureDeploymentPayload(deploymentDirectory);
+                ReplaceDeploymentFile(Path.Combine(installationDirectory, "XTMF2.dll"),
+                    Path.Combine(deploymentDirectory, "XTMF2.dll"), Path.Combine(backupDirectory, "XTMF2.dll"));
+                ReplaceDeploymentDirectory(Path.Combine(installationDirectory, "Modules"),
+                    Path.Combine(deploymentDirectory, "Modules"), Path.Combine(backupDirectory, "Modules"));
+
+                var startInfo = CreateRunServerStartInfo(processPath, installationDirectory, arguments);
+                ClearDeploymentWatchdogEnvironment(startInfo);
+                startInfo.Environment["XTMF2_DEPLOYMENT_MANIFEST"] =
+                    Path.Combine(deploymentDirectory, "deployment-manifest.txt");
+                startInfo.Environment["XTMF2_DEPLOYMENT_READY_FILE"] = readyFile;
+                foreach (var argument in arguments)
+                    startInfo.ArgumentList.Add(argument);
+                deployedProcess = Process.Start(startInfo)
+                    ?? throw new InvalidOperationException("Unable to start the deployed RunServer.");
+
+                var readyDeadline = DateTime.UtcNow.AddSeconds(30);
+                while (!File.Exists(readyFile) && DateTime.UtcNow < readyDeadline)
+                {
+                    if (deployedProcess.HasExited)
+                        throw new InvalidOperationException("The deployed RunServer exited before becoming ready.");
+                    Thread.Sleep(250);
+                }
+                if (!File.Exists(readyFile))
+                    throw new InvalidOperationException("The deployed RunServer did not become ready.");
+
+                Directory.Delete(backupDirectory, recursive: true);
+                Directory.Delete(deploymentDirectory, recursive: true);
+            }
+            catch (Exception exception) when (exception is IOException or InvalidDataException or UnauthorizedAccessException or InvalidOperationException or System.ComponentModel.Win32Exception)
+            {
+                Console.Error.WriteLine($"Unable to activate the deployed RunServer: {exception.Message}");
+                if (backupDirectory is null)
+                    return;
+                try
+                {
+                    if (deployedProcess is not null && !deployedProcess.HasExited)
+                        deployedProcess.Kill(entireProcessTree: true);
+                    RestoreDeploymentFile(Path.Combine(installationDirectory, "XTMF2.dll"),
+                        Path.Combine(backupDirectory ?? string.Empty, "XTMF2.dll"));
+                    RestoreDeploymentDirectory(Path.Combine(installationDirectory, "Modules"),
+                        Path.Combine(backupDirectory ?? string.Empty, "Modules"));
+                    var rollbackInfo = CreateRunServerStartInfo(processPath, installationDirectory, arguments);
+                    ClearDeploymentWatchdogEnvironment(rollbackInfo);
+                    Process.Start(rollbackInfo);
+                }
+                catch (Exception rollbackException) when (rollbackException is IOException or UnauthorizedAccessException or InvalidOperationException or System.ComponentModel.Win32Exception)
+                {
+                    Console.Error.WriteLine($"Unable to restore the previous RunServer version: {rollbackException.Message}");
+                }
+            }
+        }
+
+        private static void ClearDeploymentWatchdogEnvironment(ProcessStartInfo startInfo)
+        {
+            startInfo.Environment.Remove("XTMF2_DEPLOYMENT_WATCHDOG");
+            startInfo.Environment.Remove("XTMF2_DEPLOYMENT_WATCHDOG_OLD_PID");
+            startInfo.Environment.Remove("XTMF2_DEPLOYMENT_WATCHDOG_READY_FILE");
+            startInfo.Environment.Remove("XTMF2_DEPLOYMENT_WATCHDOG_PROCESS_PATH");
+            startInfo.Environment.Remove("XTMF2_DEPLOYMENT_WATCHDOG_DEPLOYMENT_DIRECTORY");
+        }
+
+        private static ProcessStartInfo CreateRunServerStartInfo(string processPath, string workingDirectory,
+            IEnumerable<string> arguments)
+        {
+            var startInfo = new ProcessStartInfo(processPath)
+            {
+                UseShellExecute = false,
+                WorkingDirectory = workingDirectory,
+                RedirectStandardInput = false,
+                RedirectStandardOutput = false,
+                RedirectStandardError = false,
+                CreateNoWindow = false
+            };
+            if (IsDotnetHost(processPath))
+                startInfo.ArgumentList.Add(typeof(Program).Assembly.Location);
+            foreach (var argument in arguments)
+                startInfo.ArgumentList.Add(argument);
+            return startInfo;
+        }
+
+        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 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))
+            {
+                Directory.CreateDirectory(Path.GetDirectoryName(backup)!);
+                File.Move(destination, backup, overwrite: true);
+            }
+            File.Move(staged, destination, overwrite: true);
+        }
+
+        private static void ExtractDeploymentArchive(string archivePath, string destinationRoot)
+        {
+            using var archive = ZipFile.OpenRead(archivePath);
+            foreach (var entry in archive.Entries)
+            {
+                var destination = Path.GetFullPath(Path.Combine(destinationRoot,
+                    entry.FullName.Replace('/', Path.DirectorySeparatorChar)));
+                var root = Path.GetFullPath(destinationRoot + Path.DirectorySeparatorChar);
+                if (!destination.StartsWith(root, StringComparison.Ordinal))
+                    throw new InvalidDataException("Deployment archive contains an unsafe path.");
+                if (string.IsNullOrEmpty(entry.Name))
+                {
+                    Directory.CreateDirectory(destination);
+                    continue;
+                }
+                Directory.CreateDirectory(Path.GetDirectoryName(destination)!);
+                entry.ExtractToFile(destination, overwrite: true);
+            }
+        }
+
+        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 RestoreDeploymentFile(string destination, string backup)
+        {
+            if (File.Exists(backup))
+                File.Move(backup, destination, overwrite: true);
+        }
+
+        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 RestoreDeploymentDirectory(string destination, string backup)
+        {
+            if (!Directory.Exists(backup))
+                return;
+            if (Directory.Exists(destination))
+                Directory.Delete(destination, recursive: true);
+            Directory.Move(backup, destination);
+        }
+
+        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();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/XTMF2.GUI/App.axaml b/src/XTMF2.GUI/App.axaml
index fe3db5b..71d38d7 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 abca904..5ff63d3 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 72129a3..ebac183 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 58fc97c..b965d52 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 9dac72f..b046fb4 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 0000000..f84fae7
--- /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 ad9a3c6..e1cc819 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
@@ -193,8 +215,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 +278,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 +406,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 +804,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 +815,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 +847,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 +901,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 +952,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 +1066,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 +1600,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 +1640,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 c70d431..7e439d8 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 0000000..bae09e7
--- /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 4626118..ca76a78 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 0000000..dfbe966
--- /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 643af33..0394387 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 8be9faf..93e7267 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 d1de02c..40f5e28 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 ea0732b..32fc7e0 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 5a69499..7f5ea30 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 cdb1382..7dd5701 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 0000000..38c5f63
--- /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 0000000..553614b
--- /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 062346e..284dadb 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 af1bc65..d6578f2 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 0000000..9e3771d
--- /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 0000000..f7e51ab
--- /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 620e400..e2218b7 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 614b754..6912abe 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 7501c5b..e8e8203 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 a9e0b21..81d390f 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/Bus/DeploymentProtocol.cs b/src/XTMF2/Bus/DeploymentProtocol.cs
new file mode 100644
index 0000000..ae7a22a
--- /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 0000000..dc23bcd
--- /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 b43655e..dc2195d 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 0000000..ae8086a
--- /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 71a4742..0c5136d 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 06435f2..fe01f0e 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 319ee1b..a67cc84 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 74603ac..a36332c 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 729adb4..c46cddf 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 7c78b83..14b4ec3 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 0000000..687b92f
--- /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 0000000..657c9b2
--- /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 0000000..b84f5d4
--- /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 0000000..03a1259
--- /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 0000000..dae280d
--- /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 0000000..2b7f570
--- /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 0000000..88e1af0
--- /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 0000000..88e2c6f
--- /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 0000000..95f7f93
--- /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 0000000..6ba4fee
--- /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 0000000..8144892
--- /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 0000000..d7a94ef
--- /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 0000000..413be4c
--- /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 1f8da38..0069029 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 bcaf54c..9bc6edd 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 4136953..d566f5f 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 29b707b..bf6c8d3 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 0000000..2d0bfa9
--- /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 99ce5ef..81e05ae 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 f792650..8ceb4dd 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 23d0012..0d226d2 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 3eaadec..5fb6a15 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 da2121b..05e9fd6 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 2ed9354..8ae1c4e 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 0000000..d2c6102
--- /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 0000000..b0505d7
--- /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 0000000..cfc0fc5
--- /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 0000000..146acf5
--- /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 0000000..abf5ffe
--- /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 0000000..04f8b6f
--- /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 0000000..9fe0cc3
--- /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 0000000..74f9d6a
--- /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 0000000..7ee74e6
--- /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 0000000..e54aedb
--- /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 0000000..2080e4d
--- /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 0000000..83afc9a
--- /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 0000000..50e0ef6
--- /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 0000000..40b5c17
--- /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/TestRunServerSecurity.cs b/tests/XTMF2.UnitTests/Bus/TestRunServerSecurity.cs
new file mode 100644
index 0000000..52ebb45
--- /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/TestSchedulerDrain.cs b/tests/XTMF2.UnitTests/Bus/TestSchedulerDrain.cs
new file mode 100644
index 0000000..72b54c3
--- /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 0000000..9cdf1cb
--- /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 0000000..d089657
--- /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 0000000..377d9fe
--- /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 0000000..40e5304
--- /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 7a4ce87..d3c7dbf 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 0000000..7ca60d1
--- /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 03a5e6d..af49d52 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 61d8b0a..92c4002 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 485d163..45898bd 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 e2d4c58..59e6500 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));
         }