diff --git a/Ares.Core.Grpc/Services/PlannerService.cs b/Ares.Core.Grpc/Services/PlannerService.cs
index b8db951e..b0787ad8 100644
--- a/Ares.Core.Grpc/Services/PlannerService.cs
+++ b/Ares.Core.Grpc/Services/PlannerService.cs
@@ -88,15 +88,16 @@ public override async Task<Empty> RemovePlanner(RemovePlannerRequest request, Se
     return new Empty();
   }
 
-  public override Task<StateResponse> GetState(StateRequest request, ServerCallContext? context)
+  public override async Task<StateResponse> GetState(StateRequest request, ServerCallContext? context)
   {
     var response = new StateResponse();
     var planner = _plannerRepo.GetPlannerById(request.Id) ?? throw new ItemNotFoundException(request.Id, typeof(IPlannerService), "Failed to get state as planned was not found.");
 
+    await planner.Refresh();
     response.State = planner.PlannerServiceState;
     response.StateMessage = planner.StateMessage;
 
-    return Task.FromResult(response);
+    return response;
   }
 
   public override async Task<PlannerInfoResponse> GetInfo(PlannerInfoRequest request, ServerCallContext? context)
diff --git a/Ares.Core.Tests/AnalyzerManagerTests.cs b/Ares.Core.Tests/AnalyzerManagerTests.cs
index 05000409..1299d799 100644
--- a/Ares.Core.Tests/AnalyzerManagerTests.cs
+++ b/Ares.Core.Tests/AnalyzerManagerTests.cs
@@ -25,12 +25,12 @@ public TempAnalyzer(string name, string version) : base(name, "TempAnalyzer", ve
     {
     }
 
-    public override Task<Analysis> Analyze(AnalysisRequest request, CancellationToken cancellationToken)
+    public override Task<AnalysisResponse> Analyze(AnalysisRequest request, CancellationToken cancellationToken)
     {
       throw new NotImplementedException();
     }
 
-    public override Task<Analysis> Analyze(AnalysisRequest request, AresStruct settings, CancellationToken cancellationToken)
+    public override Task<AnalysisResponse> Analyze(AnalysisRequest request, AresStruct settings, CancellationToken cancellationToken)
     {
       throw new NotImplementedException();
     }
@@ -44,5 +44,10 @@ public override Task<AresStructSchema> GetParameters(CancellationToken cancellat
     {
       throw new NotImplementedException();
     }
+
+    public override Task<AresStructSchema> GetObjectiveOutputs(CancellationToken cancellationToken)
+    {
+      throw new NotImplementedException();
+    }
   }
 }
diff --git a/Ares.Core.Tests/Data/Analyzer/TestReplyAnalyzer.cs b/Ares.Core.Tests/Data/Analyzer/TestReplyAnalyzer.cs
index 28d58301..a472b710 100644
--- a/Ares.Core.Tests/Data/Analyzer/TestReplyAnalyzer.cs
+++ b/Ares.Core.Tests/Data/Analyzer/TestReplyAnalyzer.cs
@@ -2,6 +2,7 @@
 using Ares.Datamodel;
 using Ares.Datamodel.Analyzing;
 using Ares.Datamodel.Analyzing.Remote;
+using Ares.Datamodel.Extensions;
 
 namespace Ares.Core.Tests.Data.Analyzer;
 
@@ -11,15 +12,17 @@ public TestReplyAnalyzer() : base("Test Analyzer", "TestAnalyzer", "1.0")
   {
   }
 
-  public override Task<Analysis> Analyze(AnalysisRequest request, CancellationToken cancellationToken)
+  public override Task<AnalysisResponse> Analyze(AnalysisRequest request, CancellationToken cancellationToken)
   {
     var firstData = request.Inputs.Fields["TestAnalyzerInput"];
-    var analysis = new Analysis() { Result = (float)firstData.NumberValue, AnalysisOutcome = Outcome.Success };
+    var objective = new Objective() { ObjectiveName = "Objective", ObjectiveValue = firstData };
+    var analysis = new AnalysisResponse() { Objectives = { objective }, AnalysisOutcome = Outcome.Success };
+
 
     return Task.FromResult(analysis);
   }
 
-  public override Task<Analysis> Analyze(AnalysisRequest request, AresStruct settings, CancellationToken cancellationToken)
+  public override Task<AnalysisResponse> Analyze(AnalysisRequest request, AresStruct settings, CancellationToken cancellationToken)
   {
     return Analyze(request, cancellationToken);
   }
@@ -38,4 +41,14 @@ public override Task<AresStructSchema> GetParameters(CancellationToken cancellat
 
     return Task.FromResult(schema);
   }
+
+  public override Task<AresStructSchema> GetObjectiveOutputs(CancellationToken cancellationToken)
+  {
+    var schema = new AresStructSchema();
+    var testReplySchema = new AresValueSchema() { Optional = false, Type = AresDataType.Number };
+    
+    schema.Fields["TestObjective"] = testReplySchema;
+
+    return Task.FromResult(schema);
+  }
 }
diff --git a/Ares.Core.Tests/DataManagement/DataMappers/CampaignDatasetGeneratorTests.cs b/Ares.Core.Tests/DataManagement/DataMappers/CampaignDatasetGeneratorTests.cs
index e2c28f1f..2a0ae0de 100644
--- a/Ares.Core.Tests/DataManagement/DataMappers/CampaignDatasetGeneratorTests.cs
+++ b/Ares.Core.Tests/DataManagement/DataMappers/CampaignDatasetGeneratorTests.cs
@@ -34,8 +34,8 @@ public async Task GenerateAsync_SortsExperimentRowsAndCreatesFixedColumns()
     var summary = CreateCampaignSummary(
       summaryId,
       "Campaign A",
-      CreateExperiment(secondStart, secondEnd, analysisResult: 2.5),
-      CreateExperiment(firstStart, firstEnd, analysisResult: 1.5));
+      CreateExperiment(secondStart, secondEnd, analysisResult: new List<Objective> { new Objective { ObjectiveName = "Result", ObjectiveValue = AresValueHelper.CreateNumber(2.5) } }),
+      CreateExperiment(firstStart, firstEnd, analysisResult: new List<Objective> { new Objective { ObjectiveName = "Result", ObjectiveValue = AresValueHelper.CreateNumber(1.5) } }));
     var generator = CreateGenerator(summary);
 
     var dataset = GetDataset(await generator.GenerateAsync(summaryId), "Experiments");
@@ -43,30 +43,28 @@ public async Task GenerateAsync_SortsExperimentRowsAndCreatesFixedColumns()
     using(Assert.EnterMultipleScope())
     {
       Assert.That(dataset.Name, Is.EqualTo("Experiments"));
-      Assert.That(dataset.Columns.Take(6).Select(column => column.Name), Is.EqualTo([
+      Assert.That(dataset.Columns.Take(5).Select(column => column.Name), Is.EqualTo([
         "Experiment Number",
         "Experiment Template",
         "Time Started",
         "Time Finished",
-        "Duration Seconds",
-        "Analysis Result"
-      ]));
+        "Duration Seconds"
+        ]));
       Assert.That(ColumnSchema(dataset, "Experiment Number").Type, Is.EqualTo(AresDataType.Int));
       Assert.That(ColumnSchema(dataset, "Time Started").Type, Is.EqualTo(AresDataType.Timestamp));
       Assert.That(ColumnSchema(dataset, "Time Finished").Type, Is.EqualTo(AresDataType.Timestamp));
       Assert.That(ColumnSchema(dataset, "Duration Seconds").Type, Is.EqualTo(AresDataType.Number));
-      Assert.That(ColumnSchema(dataset, "Analysis Result").Type, Is.EqualTo(AresDataType.Number));
-      Assert.That(ColumnSchema(dataset, "Analysis Result").Optional, Is.True);
+      Assert.That(ColumnSchema(dataset, "Objective.Result").Optional, Is.True);
       Assert.That(dataset.Rows[0].Data.Fields["Experiment Number"].IntValue, Is.EqualTo(1));
       Assert.That(dataset.Rows[0].Data.Fields["Time Started"].TimestampValue, Is.EqualTo(Timestamp.FromDateTime(firstStart)));
       Assert.That(dataset.Rows[0].Data.Fields["Time Finished"].TimestampValue, Is.EqualTo(Timestamp.FromDateTime(firstEnd)));
       Assert.That(dataset.Rows[0].Data.Fields["Duration Seconds"].NumberValue, Is.EqualTo(1));
-      Assert.That(dataset.Rows[0].Data.Fields["Analysis Result"].NumberValue, Is.EqualTo(1.5));
+      Assert.That(dataset.Rows[0].Data.Fields["Objective.Result"].NumberValue, Is.EqualTo(1.5));
       Assert.That(dataset.Rows[1].Data.Fields["Experiment Number"].IntValue, Is.EqualTo(2));
       Assert.That(dataset.Rows[1].Data.Fields["Time Started"].TimestampValue, Is.EqualTo(Timestamp.FromDateTime(secondStart)));
       Assert.That(dataset.Rows[1].Data.Fields["Time Finished"].TimestampValue, Is.EqualTo(Timestamp.FromDateTime(secondEnd)));
       Assert.That(dataset.Rows[1].Data.Fields["Duration Seconds"].NumberValue, Is.EqualTo(1));
-      Assert.That(dataset.Rows[1].Data.Fields["Analysis Result"].NumberValue, Is.EqualTo(2.5));
+      Assert.That(dataset.Rows[1].Data.Fields["Objective.Result"].NumberValue, Is.EqualTo(2.5));
     }
   }
 
@@ -532,42 +530,98 @@ public async Task GenerateAsync_CreatesPlannerTransactionRows()
     var summaryId = Guid.NewGuid().ToString();
     var experiment = CreateExperiment(DateTime.UnixEpoch, DateTime.UnixEpoch.AddSeconds(5));
     var nestedOutput = AresValueHelper.CreateStruct();
-    nestedOutput.StructValue.Fields["Value"] = AresValueHelper.CreateNumber(12.5);
+    nestedOutput.StructValue.Fields["Value"] = AresValueHelper.CreateInt(100);
+
+    var nestConcentration = AresValueHelper.CreateStruct();
+    nestConcentration.StructValue.Fields["Value"] = AresValueHelper.CreateFloat(1.6);
+
+    // This helper creates Plan 1 with the Temperature output
     var transaction = CreatePlannerTransaction(
       experiment.ExperimentId,
       DateTime.UnixEpoch.AddSeconds(1),
       DateTime.UnixEpoch.AddSeconds(3),
-      ("Temperature", nestedOutput));
-    transaction.PlanningRequest.AnalysisResults.AddRange([1.5, 2.5]);
-    transaction.PlanningResponse.PlanningOutcome = Outcome.Warning;
-    transaction.PlanningResponse.ErrorString = "planner warning";
+      ("Temperature", nestedOutput),
+      ("Concentration", nestConcentration));
+
+    var objectiveOne = new Objective() 
+    { 
+      ObjectiveValue = AresValueHelper.CreateNumber(1.5), 
+      ObjectiveName = "ObjectiveOne" 
+    };
+
+    var objectiveTwo = new Objective() 
+    { 
+      ObjectiveValue = AresValueHelper.CreateNumber(2.5), 
+      ObjectiveName = "ObjectiveTwo" 
+    };
+
+    var responseOne = new AnalysisData() { AnalysisObjectives = { objectiveOne } };
+    var responseTwo = new AnalysisData() { AnalysisObjectives = { objectiveTwo } };
+
+    var planOne = new Plan() { ErrorString = "planner warning", PlanningOutcome = Outcome.Warning };
+    planOne.PlannedParameters.Add(new PlannedParameter() { ParameterName = "Temperature", ParameterValue = AresValueHelper.CreateInt(200) });
+    planOne.PlannedParameters.Add(new PlannedParameter() { ParameterName = "Concentration", ParameterValue = AresValueHelper.CreateFloat(2.6) });
+
+    var planTwo = new Plan() { ErrorString = "planner error", PlanningOutcome = Outcome.Failure };
+    planTwo.PlannedParameters.Add(new PlannedParameter() { ParameterName = "Temperature", ParameterValue = AresValueHelper.CreateInt(300) });
+    planTwo.PlannedParameters.Add(new PlannedParameter() { ParameterName = "Concentration", ParameterValue = AresValueHelper.CreateFloat(3.6) });
+
+    transaction.PlanningRequest.AnalysisData.AddRange([responseOne, responseTwo]);
+    transaction.PlanningResponse.Plans.AddRange([planOne, planTwo]);
+
     var generator = CreateGenerator(CreateCampaignSummary(summaryId, "Campaign A", experiment), [transaction]);
 
     var dataset = GetDataset(await generator.GenerateAsync(summaryId), "Planner Transactions");
-    var row = dataset.Rows.Single();
+
+    // We now expect 3 distinct rows
+    var rows = dataset.Rows.ToList();
 
     using(Assert.EnterMultipleScope())
     {
+      Assert.That(rows, Has.Count.EqualTo(3));
+
       Assert.That(dataset.Columns.Take(11).Select(column => column.Name), Is.EqualTo([
-        "Experiment Number",
-        "Planner Name",
-        "Planner Type",
-        "Planner Version",
-        "Time Request Sent",
-        "Time Response Received",
-        "Duration Seconds",
-        "Outcome",
-        "Error",
-        "Analysis Results",
-        "Output.Temperature.Value"
+      "Experiment Number",
+      "Plan Number",
+      "Planner Name",
+      "Planner Type",
+      "Planner Version",
+      "Time Request Sent",
+      "Time Response Received",
+      "Duration Seconds",
+      "Outcome",
+      "Error",
+      "Output.Temperature.Value"
       ]));
-      Assert.That(row.Data.Fields["Experiment Number"].IntValue, Is.EqualTo(1));
-      Assert.That(row.Data.Fields["Planner Name"].StringValue, Is.EqualTo("Planner A"));
-      Assert.That(row.Data.Fields["Duration Seconds"].NumberValue, Is.EqualTo(2));
-      Assert.That(row.Data.Fields["Outcome"].StringValue, Is.EqualTo(Outcome.Warning.ToString()));
-      Assert.That(row.Data.Fields["Error"].StringValue, Is.EqualTo("planner warning"));
-      Assert.That(row.Data.Fields["Analysis Results"].ListValue.Values.Select(value => value.NumberValue), Is.EqualTo([1.5, 2.5]));
-      Assert.That(row.Data.Fields["Output.Temperature.Value"].NumberValue, Is.EqualTo(12.5));
+
+      // Transaction-level fields should be identical across all 3 rows
+      foreach(var row in rows)
+      {
+        Assert.That(row.Data.Fields["Experiment Number"].IntValue, Is.EqualTo(1));
+        Assert.That(row.Data.Fields["Planner Name"].StringValue, Is.EqualTo("Planner A"));
+        Assert.That(row.Data.Fields["Duration Seconds"].NumberValue, Is.EqualTo(2));
+        Assert.That(row.Data.Fields["Objective.ObjectiveOne"].NumberValue, Is.EqualTo(1.5));
+        Assert.That(row.Data.Fields["Objective.ObjectiveTwo"].NumberValue, Is.EqualTo(2.5));
+      }
+
+      var rowOne = rows[0];
+      Assert.That(rowOne.Data.Fields["Plan Number"].IntValue, Is.EqualTo(1));
+      Assert.That(rowOne.Data.Fields["Output.Temperature.Value"].IntValue, Is.EqualTo(100));
+      Assert.That(rowOne.Data.Fields["Output.Concentration.Value"].FloatValue, Is.EqualTo(1.6));
+
+      var rowTwo = rows[1];
+      Assert.That(rowTwo.Data.Fields["Plan Number"].IntValue, Is.EqualTo(2));
+      Assert.That(rowTwo.Data.Fields["Outcome"].StringValue, Is.EqualTo(Outcome.Warning.ToString()));
+      Assert.That(rowTwo.Data.Fields["Error"].StringValue, Is.EqualTo("planner warning"));
+      Assert.That(rowTwo.Data.Fields["Output.Temperature"].IntValue, Is.EqualTo(200));
+      Assert.That(rowTwo.Data.Fields["Output.Concentration"].FloatValue, Is.EqualTo(2.6));
+
+      var rowThree = rows[2];
+      Assert.That(rowThree.Data.Fields["Plan Number"].IntValue, Is.EqualTo(3));
+      Assert.That(rowThree.Data.Fields["Outcome"].StringValue, Is.EqualTo(Outcome.Failure.ToString()));
+      Assert.That(rowThree.Data.Fields["Error"].StringValue, Is.EqualTo("planner error"));
+      Assert.That(rowThree.Data.Fields["Output.Temperature"].IntValue, Is.EqualTo(300));
+      Assert.That(rowThree.Data.Fields["Output.Concentration"].FloatValue, Is.EqualTo(3.6));
     }
   }
 
@@ -583,9 +637,10 @@ public async Task GenerateAsync_CreatesAnalyzerTransactionRows()
       DateTime.UnixEpoch.AddSeconds(2),
       DateTime.UnixEpoch.AddSeconds(4),
       ("Measurement", nestedInput));
-    transaction.AnalysisResponse = new Analysis
+
+    transaction.AnalyzerResponse = new AnalysisResponse
     {
-      Result = 9.5f,
+      Objectives = { new Objective() { ObjectiveName = "Result", ObjectiveValue = AresValueHelper.CreateNumber(9.5) } },
       AnalysisOutcome = Outcome.Success,
       ErrorString = "analysis note"
     };
@@ -604,14 +659,14 @@ public async Task GenerateAsync_CreatesAnalyzerTransactionRows()
         "Time Request Sent",
         "Time Response Received",
         "Duration Seconds",
-        "Result",
+        "Objective.Result",
         "Outcome",
         "Error",
         "Input.Measurement.Mass"
       ]));
       Assert.That(row.Data.Fields["Analyzer Version"].StringValue, Is.EqualTo("2.0"));
       Assert.That(row.Data.Fields["Duration Seconds"].NumberValue, Is.EqualTo(2));
-      Assert.That(row.Data.Fields["Result"].NumberValue, Is.EqualTo(9.5));
+      Assert.That(row.Data.Fields["Objective.Result"].NumberValue, Is.EqualTo(9.5));
       Assert.That(row.Data.Fields["Outcome"].StringValue, Is.EqualTo(Outcome.Success.ToString()));
       Assert.That(row.Data.Fields["Input.Measurement.Mass"].QuantityValue.Scalar, Is.EqualTo(4.5));
     }
@@ -741,7 +796,7 @@ private static CampaignExecutionSummary CreateCampaignSummary(
   private static ExperimentExecutionSummary CreateExperiment(
     DateTime timeStarted,
     DateTime timeFinished,
-    double? analysisResult = null,
+    List<Objective>? analysisResult = null,
     (string Name, AresValue Value)[] resultFields = null,
     Parameter[] parameters = null,
     StepExecutionSummary[] steps = null)
@@ -752,7 +807,12 @@ private static ExperimentExecutionSummary CreateExperiment(
     };
 
     if(analysisResult is not null)
-      overview.AnalysisOverview = new AnalysisOverview { Result = analysisResult.Value };
+    {
+      overview.AnalysisOverview = new AnalysisOverview();
+      overview.AnalysisOverview.Objectives.AddRange(analysisResult);
+
+    }
+      
 
     foreach(var field in resultFields ?? [])
     {
@@ -906,14 +966,17 @@ private static PlannerTransaction CreatePlannerTransaction(
           ExperimentId = experimentId
         }
       },
-      PlanningResponse = new PlanningResponse()
+      PlanningResponse = new PlanningResponse() { ObjectiveStatus = ObjectiveStatus.ObjectiveUnachieved }
     };
 
-    transaction.PlanningResponse.PlannedParameters.AddRange(outputs.Select(output => new PlannedParameter
+    var plan = new Plan();
+    plan.PlannedParameters.AddRange(outputs.Select(output => new PlannedParameter
     {
       ParameterName = output.Name,
       ParameterValue = output.Value
     }));
+
+    transaction.PlanningResponse.Plans.Add(plan);
     return transaction;
   }
 
@@ -940,7 +1003,7 @@ private static AnalyzerTransaction CreateAnalyzerTransaction(
           ExperimentId = experimentId
         }
       },
-      AnalysisResponse = new Analysis()
+      AnalyzerResponse = new AnalysisResponse()
     };
 
     foreach(var input in inputs)
diff --git a/Ares.Core.Tests/Execution/CampaignExecutorTests.cs b/Ares.Core.Tests/Execution/CampaignExecutorTests.cs
index 80336507..dcc8547f 100644
--- a/Ares.Core.Tests/Execution/CampaignExecutorTests.cs
+++ b/Ares.Core.Tests/Execution/CampaignExecutorTests.cs
@@ -56,8 +56,8 @@ public void SetUp()
       .Setup(helper => helper.TryResolveParameters(
         It.IsAny<IEnumerable<PlannerAllocation>>(),
         It.IsAny<RequestMetadata>(),
-        It.IsAny<IEnumerable<Parameter>>(),
-        It.IsAny<IEnumerable<Ares.Datamodel.Analyzing.Analysis>>(),
+        It.IsAny<ExperimentTemplate>(),
+        It.IsAny<IEnumerable<Datamodel.Analyzing.AnalysisResponse>>(),
         It.IsAny<IEnumerable<ExperimentOverview>>(),
         It.IsAny<int>(),
         It.IsAny<List<PlanStatusCode>>(),
@@ -220,8 +220,8 @@ public async Task Replan_Composes_And_Executes_Experiment_Again()
     _planningHelper.Verify(helper => helper.TryResolveParameters(
       It.IsAny<IEnumerable<PlannerAllocation>>(),
       It.IsAny<RequestMetadata>(),
-      It.IsAny<IEnumerable<Parameter>>(),
-      It.IsAny<IEnumerable<Ares.Datamodel.Analyzing.Analysis>>(),
+      It.IsAny<ExperimentTemplate>(),
+      It.IsAny<IEnumerable<Datamodel.Analyzing.AnalysisResponse>>(),
       It.IsAny<IEnumerable<ExperimentOverview>>(),
       It.IsAny<int>(),
       It.IsAny<List<PlanStatusCode>>(),
diff --git a/Ares.Core.Tests/ManualPlannerTests.cs b/Ares.Core.Tests/ManualPlannerTests.cs
index c6e43aaa..47a1cb86 100644
--- a/Ares.Core.Tests/ManualPlannerTests.cs
+++ b/Ares.Core.Tests/ManualPlannerTests.cs
@@ -58,6 +58,6 @@ public async Task CorrectNumberOfResults_FileLines()
     var request = new PlanningRequest();
     request.PlanningParameters.AddRange(_parameterMetadatas.Select(m => new PlanningParameter { ParameterName = m.Name }));
     var planResponse = await _manualPlanner.Plan(request, CancellationToken.None);
-    Assert.That(planResponse.PlannedParameters, Has.Exactly(3).Items);
+    Assert.That(planResponse.Plans.First().PlannedParameters, Has.Exactly(3).Items);
   }
 }
diff --git a/Ares.Core/Analyzing/AnalysisHelper.cs b/Ares.Core/Analyzing/AnalysisHelper.cs
index 11971e6b..e9341170 100644
--- a/Ares.Core/Analyzing/AnalysisHelper.cs
+++ b/Ares.Core/Analyzing/AnalysisHelper.cs
@@ -28,7 +28,7 @@ public AnalysisHelper(IAnalyzerRepo analyzerRepo, ILogger<AnalysisHelper> logger
     _notificationHandler = notificationHandler;
   }
 
-  public async Task<Analysis> Analyze(ExperimentTemplate template, ExperimentExecutionSummary experimentSummary, ExperimentExecutionSummary startupSummary, RequestMetadata metadata, CancellationToken cancellationToken)
+  public async Task<AnalysisResponse> Analyze(ExperimentTemplate template, ExperimentExecutionSummary experimentSummary, ExperimentExecutionSummary startupSummary, RequestMetadata metadata, CancellationToken cancellationToken)
   {
     try
     {
@@ -40,7 +40,13 @@ public async Task<Analysis> Analyze(ExperimentTemplate template, ExperimentExecu
       var analyzerInputs = ExperimentOutputToAnalyzerInputs(combinedResult, template.AnalyzerMaps);
 
       if(analyzerInputs is null)
-        return new Analysis { Result = float.NaN, AnalysisOutcome = Outcome.Failure, ErrorString = "Analysis Failure: Failed to assign analysis " };
+      {
+        return new AnalysisResponse
+        {
+          AnalysisOutcome = Outcome.Failure,
+          ErrorString = "Analysis Failure: Failed to assign analysis "
+        };
+      }
 
       var analysisRequest = new AnalysisRequest 
       { 
@@ -60,34 +66,48 @@ public async Task<Analysis> Analyze(ExperimentTemplate template, ExperimentExecu
 
       var analysis = await analyzer.Analyze(analysisRequest, cancellationToken);
       transaction.TimeResponseReceived = DateTime.UtcNow.ToTimestamp();
-      transaction.AnalysisResponse = analysis;
+      transaction.AnalyzerResponse = analysis;
       
       experimentSummary.ExperimentOverview.AnalysisOverview = new AnalysisOverview
       {
         UniqueId = Guid.NewGuid().ToString(),
-        Result = analysis.Result,
         AnalyzerInfo = await analyzer.CreateAnalyzerInfo(),
         ExperimentOverviewId = experimentSummary.ExperimentOverview.UniqueId
       };
 
-      _logger.LogInformation("Analysis completed {Result}", analysis.Result);
+      experimentSummary.ExperimentOverview.AnalysisOverview.Objectives.AddRange(analysis.Objectives);
+
+      _logger.LogInformation("Analysis completed {Result}", analysis.Objectives);
       await LogAnalyzerTransaction(transaction);
       return analysis;
     }
+
     catch(RpcException e)
     {
       if(e.InnerException is OperationCanceledException oce)
       {
-        return new Analysis { Result = float.NaN, AnalysisOutcome = Outcome.Canceled, ErrorString = $" Analysis has been canceled" };
+        return new AnalysisResponse 
+        { 
+          AnalysisOutcome = Outcome.Canceled, 
+          ErrorString = $" Analysis has been canceled" 
+        };
       }
-      return new Analysis {Result = float.NaN, AnalysisOutcome = Outcome.Failure, ErrorString = $"Call to analyzer has failed: {e}" };
+
+      return new AnalysisResponse 
+      { 
+        AnalysisOutcome = Outcome.Failure, 
+        ErrorString = $"Call to analyzer has failed: {e}" 
+      };
     }
+
     catch(Exception e)
     {
-      return new Analysis { Result = float.NaN, AnalysisOutcome = Outcome.Failure, ErrorString = $"Call to analyzer has failed: {e}" };
+      return new AnalysisResponse 
+      { 
+        AnalysisOutcome = Outcome.Failure, 
+        ErrorString = $"Call to analyzer has failed: {e}" 
+      };
     }
-
-    
   }
 
   private IAnalyzer GetAnalyzer(string? analyzerId)
diff --git a/Ares.Core/Analyzing/AnalysisRepo.cs b/Ares.Core/Analyzing/AnalysisRepo.cs
index 990fab39..b335e924 100644
--- a/Ares.Core/Analyzing/AnalysisRepo.cs
+++ b/Ares.Core/Analyzing/AnalysisRepo.cs
@@ -6,9 +6,9 @@ namespace Ares.Core.Analyzing;
 // This is a non-persistent storage of analyses as they come out of analyzers
 // mainly used to instanced functionality like tracking the analysis results to
 // decide when to stop the campaign
-public class AnalysisRepo : Collection<Analysis>
+public class AnalysisRepo : Collection<AnalysisResponse>
 {
-  public void StoreAnalysis(Analysis analysis)
+  public void StoreAnalysis(AnalysisResponse analysis)
   {
     Add(analysis);
   }
diff --git a/Ares.Core/Analyzing/AnalyzerBase.cs b/Ares.Core/Analyzing/AnalyzerBase.cs
index 847551b6..23347c8c 100644
--- a/Ares.Core/Analyzing/AnalyzerBase.cs
+++ b/Ares.Core/Analyzing/AnalyzerBase.cs
@@ -69,12 +69,14 @@ public void UpdateSettings(AresStruct settings)
     }
   }
 
-  public abstract Task<Analysis> Analyze(AnalysisRequest request, CancellationToken cancellationToken);
+  public abstract Task<AnalysisResponse> Analyze(AnalysisRequest request, CancellationToken cancellationToken);
 
-  public abstract Task<Analysis> Analyze(AnalysisRequest request, AresStruct settings, CancellationToken cancellationToken);
+  public abstract Task<AnalysisResponse> Analyze(AnalysisRequest request, AresStruct settings, CancellationToken cancellationToken);
 
   public abstract Task<AresStructSchema> GetParameters(CancellationToken cancellationToken);
 
+  public abstract Task<AresStructSchema> GetObjectiveOutputs(CancellationToken cancellationToken);
+
   private static ParameterValidationResult ValidateParameterTypes(KeyValuePair<string, AresValueSchema> analyzerField, AresStructSchema parameters)
   {
     var result = new ParameterValidationResult();
diff --git a/Ares.Core/Analyzing/IAnalyzer.cs b/Ares.Core/Analyzing/IAnalyzer.cs
index 85d27afb..070780a1 100644
--- a/Ares.Core/Analyzing/IAnalyzer.cs
+++ b/Ares.Core/Analyzing/IAnalyzer.cs
@@ -93,6 +93,13 @@ public interface IAnalyzer
   /// <returns></returns>
   Task<AnalyzerCapabilities> GetCapabilities(CancellationToken cancellationToken = default);
 
+  /// <summary>
+  /// This will return the schema describing the analyzers objective outputs.
+  /// </summary>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  Task<AresStructSchema> GetObjectiveOutputs(CancellationToken cancellationToken = default);
+
   /// <summary>
   /// Does the actual analysis work.
   /// </summary>
@@ -100,7 +107,7 @@ public interface IAnalyzer
   /// <param name="cancellationToken"></param>
   /// <param name="settings">Optional list of settings to influence the analysis</param>
   /// <returns><see cref="Analysis" /> which is the outcome of the analysis performed.</returns>
-  Task<Analysis> Analyze(AnalysisRequest request, AresStruct settings, CancellationToken cancellationToken = default);
+  Task<AnalysisResponse> Analyze(AnalysisRequest request, AresStruct settings, CancellationToken cancellationToken = default);
 
   /// <summary>
   /// Does the actual analysis work.
@@ -108,7 +115,7 @@ public interface IAnalyzer
   /// <param name="request">The analysis request to be sent to the analyzer <see cref="AnalysisRequest" /> proto message</param>
   /// <param name="cancellationToken"></param>
   /// <returns><see cref="Analysis" /> which is the outcome of the analysis performed.</returns>
-  Task<Analysis> Analyze(AnalysisRequest request, CancellationToken cancellationToken);
+  Task<AnalysisResponse> Analyze(AnalysisRequest request, CancellationToken cancellationToken);
 
   /// <summary>
   /// How long do we expect the analyzer to do its analysis before ARES decides that analyzing has failed.
diff --git a/Ares.Core/Analyzing/NoneAnalyzer.cs b/Ares.Core/Analyzing/NoneAnalyzer.cs
index 9e6200f8..529cfef9 100644
--- a/Ares.Core/Analyzing/NoneAnalyzer.cs
+++ b/Ares.Core/Analyzing/NoneAnalyzer.cs
@@ -19,18 +19,17 @@ public NoneAnalyzer() : base("NONE", "NONE :)", "1.0.0")
     AnalyzerState = State.Active;
   }
 
-  public override Task<Analysis> Analyze(AnalysisRequest request, CancellationToken cancellationToken)
+  public override Task<AnalysisResponse> Analyze(AnalysisRequest request, CancellationToken cancellationToken)
   {
-    var analysis = new Analysis
+    var analysis = new AnalysisResponse
     {
-      AnalysisOutcome = Outcome.Success,
-      Result = 0
+      AnalysisOutcome = Outcome.Success
     };
 
     return Task.FromResult(analysis);
   }
 
-  public override Task<Analysis> Analyze(AnalysisRequest request, AresStruct _settings, CancellationToken cancellationToken)
+  public override Task<AnalysisResponse> Analyze(AnalysisRequest request, AresStruct _settings, CancellationToken cancellationToken)
   {
     return Analyze(request, cancellationToken);
   }
@@ -46,4 +45,9 @@ public override Task<AresStructSchema> GetParameters(CancellationToken cancellat
   {
     return Task.FromResult(new AresStructSchema());
   }
+
+  public override Task<AresStructSchema> GetObjectiveOutputs(CancellationToken cancellationToken)
+  {
+    return Task.FromResult(new AresStructSchema());
+  }
 }
diff --git a/Ares.Core/Analyzing/RemoteAnalyzer.cs b/Ares.Core/Analyzing/RemoteAnalyzer.cs
index 4a8894fe..0764acb2 100644
--- a/Ares.Core/Analyzing/RemoteAnalyzer.cs
+++ b/Ares.Core/Analyzing/RemoteAnalyzer.cs
@@ -34,7 +34,7 @@ public RemoteAnalyzer(string name, Uri address, IDatamodelVersionValidator datam
 
   public Uri Address { get; }
 
-  public override async Task<Analysis> Analyze(AnalysisRequest request, CancellationToken cancellationToken = default)
+  public override async Task<AnalysisResponse> Analyze(AnalysisRequest request, CancellationToken cancellationToken = default)
   {
     var client = GetClient();
     var analysis = await client.AnalyzeAsync(request, cancellationToken: cancellationToken);
@@ -49,7 +49,7 @@ public override async Task<Analysis> Analyze(AnalysisRequest request, Cancellati
   /// <param name="settings">These will add-to/override existing settings values if provided. </param>
   /// <param name="cancellationToken"></param>
   /// <returns></returns>
-  public override Task<Analysis> Analyze(AnalysisRequest request, AresStruct settings, CancellationToken cancellationToken = default)
+  public override Task<AnalysisResponse> Analyze(AnalysisRequest request, AresStruct settings, CancellationToken cancellationToken = default)
   {
     var client = GetClient();
     var mergedSettings = Settings.AppendStruct(settings);
@@ -57,6 +57,12 @@ public override Task<Analysis> Analyze(AnalysisRequest request, AresStruct setti
     return client.AnalyzeAsync(request, cancellationToken: cancellationToken).ResponseAsync;
   }
 
+  public override async Task<AresStructSchema> GetObjectiveOutputs(CancellationToken cancellationToken)
+  {
+    var capabilities = await GetCapabilities();
+    return capabilities.ObjectiveOutputSchema;
+  }
+
   public override async Task<AnalyzerCapabilities> GetCapabilities(CancellationToken cancellationToken = default)
   {
     var client = GetClient();
diff --git a/Ares.Core/Ares.Core.csproj b/Ares.Core/Ares.Core.csproj
index bb5f0548..f08b7154 100644
--- a/Ares.Core/Ares.Core.csproj
+++ b/Ares.Core/Ares.Core.csproj
@@ -26,7 +26,7 @@
   </ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="ARES.Datamodel" Version="0.35.0" />
+		<PackageReference Include="ARES.Datamodel" Version="0.36.0" />
 		<PackageReference Include="Ares.Toolkit.Device" Version="1.5.0" />
 	  <PackageReference Include="CsvHelper" Version="33.1.0" />
 	  <PackageReference Include="DynamicData" Version="9.4.33" />
diff --git a/Ares.Core/CoreDatabaseContext.cs b/Ares.Core/CoreDatabaseContext.cs
index 5cf123e0..d02fdfb0 100644
--- a/Ares.Core/CoreDatabaseContext.cs
+++ b/Ares.Core/CoreDatabaseContext.cs
@@ -70,6 +70,9 @@ protected override void ConfigureConventions(ModelConfigurationBuilder configura
     // Utilities
     configurationBuilder.Properties<Timestamp>().HaveConversion<AresTimestampConverter>();
 
+    // Ignores
+    configurationBuilder.IgnoreAny<Objective>();
+
     base.ConfigureConventions(configurationBuilder);
   }
 }
diff --git a/Ares.Core/DataManagement/DataMappers/CampaignDatasetGenerator.cs b/Ares.Core/DataManagement/DataMappers/CampaignDatasetGenerator.cs
index 20ab1726..3d6367d5 100644
--- a/Ares.Core/DataManagement/DataMappers/CampaignDatasetGenerator.cs
+++ b/Ares.Core/DataManagement/DataMappers/CampaignDatasetGenerator.cs
@@ -1,14 +1,10 @@
-using Ares.Core.Execution.Extensions;
 using Ares.Datamodel;
 using Ares.Datamodel.Analyzing;
-using Ares.Datamodel.Analyzing.Remote;
 using Ares.Datamodel.Extensions;
 using Ares.Datamodel.Planning;
 using Ares.Datamodel.Templates;
 using Google.Protobuf.WellKnownTypes;
 using Microsoft.EntityFrameworkCore;
-using YamlDotNet.Serialization.NodeDeserializers;
-using static System.Runtime.InteropServices.JavaScript.JSType;
 
 namespace Ares.Core.DataManagement.DataMappers;
 
@@ -24,10 +20,10 @@ public class CampaignDatasetGenerator(IDbContextFactory<CoreDatabaseContext> _db
   private const string TimeStartedColumnName = "Time Started";
   private const string TimeFinishedColumnName = "Time Finished";
   private const string DurationSecondsColumnName = "Duration Seconds";
-  private const string AnalysisResultColumnName = "Analysis Result";
   private const string StatusColumnName = "Status";
   private const string SuccessColumnName = "Success";
   private const string ErrorColumnName = "Error";
+  private const string PlanNumberColumnName = "Plan Number";
   private const string PlannerNameColumnName = "Planner Name";
   private const string PlannerTypeColumnName = "Planner Type";
   private const string PlannerVersionColumnName = "Planner Version";
@@ -37,8 +33,8 @@ public class CampaignDatasetGenerator(IDbContextFactory<CoreDatabaseContext> _db
   private const string TimeRequestSentColumnName = "Time Request Sent";
   private const string TimeResponseReceivedColumnName = "Time Response Received";
   private const string OutcomeColumnName = "Outcome";
-  private const string AnalysisResultsColumnName = "Analysis Results";
-  private const string ResultColumnName = "Result";
+  private const string ObjectiveStatusColumnName = "Objective Status";
+  private const string ResultColumnName = "Objective.Result";
   private const string InputColumnPrefix = "Input.";
   private const string OutputColumnPrefix = "Output.";
   private const string OutputColumnName = "Output";
@@ -66,16 +62,26 @@ public async ValueTask<AresDataset[]> GenerateAsync(string summaryId, Cancellati
     var campaignEnd = summary.ExecutionInfo?.TimeFinished;
     if(campaignStart is not null && campaignEnd is not null)
     {
-      var plannerTransactions = await ctx.PlannerTransactions
-        .Where(transaction => transaction.TimeRequestSent >= campaignStart && transaction.TimeResponseReceived <= campaignEnd)
-        .ToListAsync(cancellationToken);
-      foreach(var transaction in plannerTransactions)
+      try
       {
-        cancellationToken.ThrowIfCancellationRequested();
-        if(TryCreatePlannerRecord(transaction, summary, experimentNumbers, out var record))
-          plannerRecords.Add(record);
+        var plannerTransactions = await ctx.PlannerTransactions
+          .Where(transaction => transaction.TimeRequestSent >= campaignStart && transaction.TimeResponseReceived <= campaignEnd)
+          .ToListAsync(cancellationToken);
+
+        foreach(var transaction in plannerTransactions)
+        {
+          cancellationToken.ThrowIfCancellationRequested();
+          if(TryCreatePlannerRecord(transaction, summary, experimentNumbers, out var record))
+            plannerRecords.Add(record);
+        }
+      }
+      catch(Exception e)
+      {
+        throw e;
       }
 
+
+
       var analyzerTransactions = await ctx.AnalyzerTransactions
         .Where(transaction => transaction.TimeRequestSent >= campaignStart && transaction.TimeResponseReceived <= campaignEnd)
         .ToListAsync(cancellationToken);
@@ -129,7 +135,8 @@ private static AresDataset CreatePlannerTransactionsDataset(PlannerRecord[] reco
     };
 
     dataset.Columns.AddRange(CreatePlannerTransactionColumns(records, cancellationToken));
-    dataset.Rows.AddRange(records.Select(record => CreatePlannerTransactionRow(record, cancellationToken)));
+    dataset.Rows.AddRange(records.SelectMany(record => CreatePlannerTransactionRows(record, cancellationToken)));
+
     return dataset;
   }
 
@@ -153,8 +160,7 @@ private static IEnumerable<AresDataColumn> CreateExperimentColumns(IEnumerable<E
       CreateColumn(ExperimentTemplateColumnName, AresDataType.String, optional: true),
       CreateColumn(TimeStartedColumnName, AresDataType.Timestamp, optional: true),
       CreateColumn(TimeFinishedColumnName, AresDataType.Timestamp, optional: true),
-      CreateColumn(DurationSecondsColumnName, AresDataType.Number, optional: true),
-      CreateColumn(AnalysisResultColumnName, AresDataType.Number, optional: true)
+      CreateColumn(DurationSecondsColumnName, AresDataType.Number, optional: true)
     };
 
     var dynamicColumns = CreateExperimentDynamicColumns(experiments, cancellationToken);
@@ -188,13 +194,13 @@ private static IEnumerable<AresDataColumn> CreatePlannerTransactionColumns(IEnum
     return
     [
       CreateColumn(ExperimentNumberColumnName, AresDataType.Int),
+      CreateColumn(PlanNumberColumnName, AresDataType.Int, optional: true),
       CreateColumn(PlannerNameColumnName, AresDataType.String, optional: true),
       CreateColumn(PlannerTypeColumnName, AresDataType.String, optional: true),
       CreateColumn(PlannerVersionColumnName, AresDataType.String, optional: true),
       .. CreateTransactionTimingColumns(),
       CreateColumn(OutcomeColumnName, AresDataType.String, optional: true),
       CreateColumn(ErrorColumnName, AresDataType.String, optional: true),
-      CreateColumn(AnalysisResultsColumnName, AresDataType.List, optional: true),
       .. CreatePlannerDynamicColumns(records, cancellationToken)
     ];
   }
@@ -233,6 +239,26 @@ private static IEnumerable<AresDataColumn> CreateExperimentDynamicColumns(IEnume
     {
       cancellationToken.ThrowIfCancellationRequested();
 
+      if(experiment.ExperimentOverview?.AnalysisOverview is not null)
+      {
+        if(experiment.ExperimentOverview.AnalysisOverview.Objectives.Any())
+        {
+          foreach(var objective in experiment.ExperimentOverview.AnalysisOverview.Objectives)
+          {
+            cancellationToken.ThrowIfCancellationRequested();
+            TryAddDynamicColumn(columns, $"Objective.{objective.ObjectiveName}", objective.ObjectiveValue);
+          }
+        }
+
+        // Handle the presence of deprecated result values gracefully
+        else if(experiment.ExperimentOverview.AnalysisOverview.AnalyzerInfo.Name != "NONE")
+        {
+          var aresValueResult = AresValueHelper.CreateNumber(experiment.ExperimentOverview.AnalysisOverview.Result);
+          TryAddDynamicColumn(columns, $"Objective.Result", aresValueResult);
+        }
+
+      }
+
       var resultFields = experiment.ExperimentOverview?.Result?.Fields.OrderBy(field => field.Key)
         ?? Enumerable.Empty<KeyValuePair<string, AresValue>>();
       foreach(var field in resultFields)
@@ -316,11 +342,15 @@ private static IEnumerable<AresDataColumn> CreatePlannerDynamicColumns(IEnumerab
 
     foreach(var record in records)
     {
-      foreach(var parameter in record.Transaction.PlanningResponse?.PlannedParameters ?? [])
+      var plans = record.Transaction.PlanningResponse?.Plans ?? Enumerable.Empty<Plan>();
+      foreach(var plan in plans)
       {
-        cancellationToken.ThrowIfCancellationRequested();
-        if(parameter.ParameterValue is not null)
-          AddDynamicColumns(columns, $"{OutputColumnPrefix}{parameter.ParameterName}", parameter.ParameterValue);
+        foreach(var parameter in plan.PlannedParameters ?? [])
+        {
+          cancellationToken.ThrowIfCancellationRequested();
+          if(parameter.ParameterValue is not null)
+            AddDynamicColumns(columns, $"{OutputColumnPrefix}{parameter.ParameterName}", parameter.ParameterValue);
+        }
       }
     }
 
@@ -434,7 +464,21 @@ private static AresDataRow CreateExperimentRow(ExperimentExecutionSummary experi
     AddExecutionFields(data, experiment.ExecutionInfo);
 
     if(experiment.ExperimentOverview?.AnalysisOverview is not null)
-      data.Fields[AnalysisResultColumnName] = AresValueHelper.CreateNumber(experiment.ExperimentOverview.AnalysisOverview.Result);
+    {
+      if(experiment.ExperimentOverview.AnalysisOverview.Objectives.Any())
+      {
+        foreach(var objective in experiment.ExperimentOverview.AnalysisOverview.Objectives)
+          AddFlattenedValue(data, $"Objective.{objective.ObjectiveName}", objective.ObjectiveValue, cancellationToken);
+      }
+
+      //If we have no listed objectives AND there is an Analyzer assigned, assume it's using the legacy standard
+      else if(experiment.ExperimentOverview.AnalysisOverview.AnalyzerInfo.Name != "NONE")
+      {
+        var aresValueResult = AresValueHelper.CreateNumber(experiment.ExperimentOverview.AnalysisOverview.Result);
+        AddFlattenedValue(data, $"Objective.Result", aresValueResult, cancellationToken);
+      }
+
+    }
 
     foreach(var field in experiment.ExperimentOverview?.Result?.Fields ?? [])
     {
@@ -499,24 +543,70 @@ private static AresDataRow CreateCommandRow(CommandRecord record, CancellationTo
     };
   }
 
-  private static AresDataRow CreatePlannerTransactionRow(PlannerRecord record, CancellationToken cancellationToken)
+  private static IEnumerable<AresDataRow> CreatePlannerTransactionRows(PlannerRecord record, CancellationToken cancellationToken)
   {
     cancellationToken.ThrowIfCancellationRequested();
 
+    var transaction = record.Transaction;
+    var plans = transaction.PlanningResponse?.Plans;
+
+    // If there are no plans, we still output the transaction metadata
+    if(plans is null || plans.Count == 0)
+    {
+      yield return BuildPlanRow(record, null, 0, cancellationToken);
+      yield break;
+    }
+
+    // Yield one row per plan
+    int planIndex = 1;
+    foreach(var plan in plans)
+    {
+      yield return BuildPlanRow(record, plan, planIndex++, cancellationToken);
+    }
+  }
+
+  private static AresDataRow BuildPlanRow(PlannerRecord record, Plan? plan, int planIndex, CancellationToken cancellationToken)
+  {
     var transaction = record.Transaction;
     var data = new AresStruct();
+
     data.Fields[ExperimentNumberColumnName] = AresValueHelper.CreateInt(record.ExperimentNumber);
     AddString(data, PlannerNameColumnName, transaction.PlannerName);
     AddString(data, PlannerTypeColumnName, transaction.PlannerType);
     AddString(data, PlannerVersionColumnName, transaction.PlannerVersion);
+    
+
     AddTransactionTimingFields(data, transaction.TimeRequestSent, transaction.TimeResponseReceived);
 
+    if(plan is not null)
+    {
+      AddString(data, OutcomeColumnName, plan.PlanningOutcome.ToString());
+      AddString(data, ErrorColumnName, plan.ErrorString);
+    }
+
     if(transaction.PlanningResponse is not null)
     {
-      AddString(data, OutcomeColumnName, transaction.PlanningResponse.PlanningOutcome.ToString());
-      AddString(data, ErrorColumnName, transaction.PlanningResponse.ErrorString);
+      AddString(data, ObjectiveStatusColumnName, transaction.PlanningResponse.ObjectiveStatus.ToString());
+    }
+
+    // Base AnalysisData
+    if(transaction.PlanningRequest?.AnalysisData.Count > 0)
+    {
+      foreach(var analysisDataEntry in transaction.PlanningRequest.AnalysisData)
+      {
+        foreach(var objective in analysisDataEntry.AnalysisObjectives)
+          data.Fields[$"Objective.{objective.ObjectiveName}"] = objective.ObjectiveValue;
+      }
+    }
+
+    // Plan-specific data
+    if(plan is not null)
+    {
+      data.Fields["Plan Number"] = AresValueHelper.CreateInt(planIndex);
+      AddString(data, OutcomeColumnName, plan.PlanningOutcome.ToString());
+      AddString(data, ErrorColumnName, plan.ErrorString);
 
-      foreach(var parameter in transaction.PlanningResponse.PlannedParameters)
+      foreach(var parameter in plan.PlannedParameters)
       {
         cancellationToken.ThrowIfCancellationRequested();
         if(parameter.ParameterValue is not null)
@@ -524,9 +614,6 @@ private static AresDataRow CreatePlannerTransactionRow(PlannerRecord record, Can
       }
     }
 
-    if(transaction.PlanningRequest?.AnalysisResults.Count > 0)
-      data.Fields[AnalysisResultsColumnName] = AresValueHelper.CreateList(transaction.PlanningRequest.AnalysisResults.Select(AresValueHelper.CreateNumber));
-
     return new AresDataRow { Data = data };
   }
 
@@ -544,11 +631,22 @@ private static AresDataRow CreateAnalyzerTransactionRow(AnalyzerRecord record, C
 
     if(transaction.AnalysisResponse is not null)
     {
-      data.Fields[ResultColumnName] = AresValueHelper.CreateNumber(transaction.AnalysisResponse.Result);
+      var aresValResult = AresValueHelper.CreateNumber(transaction.AnalysisResponse.Result);
+      AddFlattenedValue(data, "Objective.Result", aresValResult, cancellationToken);
+
       AddString(data, OutcomeColumnName, transaction.AnalysisResponse.AnalysisOutcome.ToString());
       AddString(data, ErrorColumnName, transaction.AnalysisResponse.ErrorString);
     }
 
+    else if(transaction.AnalyzerResponse.Objectives.Any())
+    {
+      foreach(var objective in transaction.AnalyzerResponse.Objectives)
+        AddFlattenedValue(data, $"Objective.{objective.ObjectiveName}", objective.ObjectiveValue, cancellationToken);
+
+      AddString(data, OutcomeColumnName, transaction.AnalyzerResponse.AnalysisOutcome.ToString());
+      AddString(data, ErrorColumnName, transaction.AnalyzerResponse.ErrorString);
+    }
+
     foreach(var input in transaction.AnalysisRequest?.Inputs?.Fields ?? [])
     {
       cancellationToken.ThrowIfCancellationRequested();
diff --git a/Ares.Core/Device/Managers/DeviceManager.cs b/Ares.Core/Device/Managers/DeviceManager.cs
index 75b5de05..17115540 100644
--- a/Ares.Core/Device/Managers/DeviceManager.cs
+++ b/Ares.Core/Device/Managers/DeviceManager.cs
@@ -26,8 +26,7 @@ public class DeviceManager : IDeviceManager
   private readonly IResourceConnectionArbiter _resourceConnectionArbiter;
   private readonly CompositeDisposable _cleanup = new();
 
-  public DeviceManager(
-    IDeviceDriverProvider driverProvider,
+  public DeviceManager(IDeviceDriverProvider driverProvider,
     IAresDeviceRepo deviceRepository,
     INotificationHandler notificationHandler,
     IDeviceConfigProvider configProvider,
@@ -113,14 +112,10 @@ private async Task HandleChangeAsync(Change<DeviceConfig, string> change)
 
         if(!success)
         {
-          var owner = _resourceConnectionArbiter.GetResourceOwner(serialConnectionResource);
-          if(owner?.UniqueId == device.UniqueId)
-          {
-            var message = $"Failed to add device {device.Name} as the resource it tried to use ({serialConnectionResource.ResourceName}) was already in use by another device.";
-            _logger.LogError(message);
-            await _notificationHandler.HandleNotification("Failed to Add Device", message, NotificationSeverityEnum.Error);
-            return null;
-          }
+          var message = $"Failed to add device {device.Name} as the resource it tried to use ({serialConnectionResource.ResourceName}) was already in use by another device.";
+          _logger.LogError(message);
+          await _notificationHandler.HandleNotification("Failed to Add Device", message, NotificationSeverityEnum.Error);
+          return null; 
         }
       }
 
diff --git a/Ares.Core/EntityConfigurations/Analyzer/AnalysisOverviewEntityConfiguration.cs b/Ares.Core/EntityConfigurations/Analyzer/AnalysisOverviewEntityConfiguration.cs
index d2445b28..48d5aa6f 100644
--- a/Ares.Core/EntityConfigurations/Analyzer/AnalysisOverviewEntityConfiguration.cs
+++ b/Ares.Core/EntityConfigurations/Analyzer/AnalysisOverviewEntityConfiguration.cs
@@ -10,5 +10,6 @@ public override void Configure(EntityTypeBuilder<AnalysisOverview> builder)
   {
     base.Configure(builder);
     builder.Property(overview => overview.AnalyzerInfo).HasAnalyzerInfo();
+    builder.Property(overview => overview.Objectives).HasObjectives();
   }
 }
diff --git a/Ares.Core/EntityConfigurations/Analyzer/AnalysisResponseEntityConfiguration.cs b/Ares.Core/EntityConfigurations/Analyzer/AnalysisResponseEntityConfiguration.cs
new file mode 100644
index 00000000..d59ff3fa
--- /dev/null
+++ b/Ares.Core/EntityConfigurations/Analyzer/AnalysisResponseEntityConfiguration.cs
@@ -0,0 +1,16 @@
+using Ares.Core.EntityConfigurations.Helpers;
+using Ares.Datamodel.Analyzing;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Ares.Core.EntityConfigurations.Analyzer;
+
+internal class AnalysisResponseEntityConfiguration : AresEntityTypeBaseConfiguration<AnalysisResponse>
+{
+  public override void Configure(EntityTypeBuilder<AnalysisResponse> builder)
+  {
+    base.Configure(builder);
+    builder.Property(a => a.Objectives).HasObjectives();
+    builder.ToTable("AnalysisResponses");
+  }
+}
diff --git a/Ares.Core/EntityConfigurations/Analyzer/AnalyzerTransactionEntityConfiguration.cs b/Ares.Core/EntityConfigurations/Analyzer/AnalyzerTransactionEntityConfiguration.cs
index a19a5988..4df9569d 100644
--- a/Ares.Core/EntityConfigurations/Analyzer/AnalyzerTransactionEntityConfiguration.cs
+++ b/Ares.Core/EntityConfigurations/Analyzer/AnalyzerTransactionEntityConfiguration.cs
@@ -1,6 +1,5 @@
 using Ares.Core.EntityConfigurations.Helpers;
 using Ares.Datamodel.Analyzing;
-using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
 namespace Ares.Core.EntityConfigurations.Analyzer;
@@ -11,6 +10,7 @@ public override void Configure(EntityTypeBuilder<AnalyzerTransaction> builder)
   {
     base.Configure(builder);
     builder.Property(transaction => transaction.AnalysisRequest).HasAnalysisRequest();
-    builder.Property(transaction => transaction.AnalysisResponse).HasAnalysis();
+    builder.Property(transaction => transaction.AnalysisResponse).HasAnalysis(); //Known depricated field, kept for backwards compatability
+    builder.Property(transaction => transaction.AnalyzerResponse).HasAnalyzerResponse();
   }
 }
diff --git a/Ares.Core/EntityConfigurations/Execution/Experiments/ExperimentTemplateEntityConfiguration.cs b/Ares.Core/EntityConfigurations/Execution/Experiments/ExperimentTemplateEntityConfiguration.cs
index 02ae6ed2..bc086379 100644
--- a/Ares.Core/EntityConfigurations/Execution/Experiments/ExperimentTemplateEntityConfiguration.cs
+++ b/Ares.Core/EntityConfigurations/Execution/Experiments/ExperimentTemplateEntityConfiguration.cs
@@ -20,5 +20,7 @@ public override void Configure(EntityTypeBuilder<ExperimentTemplate> builder)
 
     builder.Navigation(experimentTemplate => experimentTemplate.StepTemplates)
       .AutoInclude();
+
+    builder.Property(template => template.PlanObjectives).HasSerializedRepeatedField();
   }
 }
diff --git a/Ares.Core/EntityConfigurations/Helpers/AnalysisInfoSerializeHelper.cs b/Ares.Core/EntityConfigurations/Helpers/AnalysisInfoSerializeHelper.cs
index 215384c3..a0526886 100644
--- a/Ares.Core/EntityConfigurations/Helpers/AnalysisInfoSerializeHelper.cs
+++ b/Ares.Core/EntityConfigurations/Helpers/AnalysisInfoSerializeHelper.cs
@@ -1,5 +1,6 @@
 using Ares.Datamodel.Analyzing;
 using Ares.Datamodel.Analyzing.Remote;
+using Google.Protobuf.Collections;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 using System.Text.Json;
@@ -28,6 +29,11 @@ public static PropertyBuilder<AnalysisRequest> HasAnalysisRequest(this PropertyB
       .HasColumnType(SerializerSettingsHelper.DetermineColumnType());
   }
 
+  /// <summary>
+  /// A deprecated method used to keep compatability with older versions of ARES for now. Likely to be removed in future major version release.
+  /// </summary>
+  /// <param name="value"></param>
+  /// <returns></returns>
   public static PropertyBuilder<Analysis> HasAnalysis(this PropertyBuilder<Analysis> value)
   {
     var settings = SerializerSettingsHelper.CreateCustomSerializationSettings();
@@ -37,4 +43,24 @@ public static PropertyBuilder<Analysis> HasAnalysis(this PropertyBuilder<Analysi
       v => JsonSerializer.Deserialize<Analysis>(v, settings) ?? new Analysis())
       .HasColumnType(SerializerSettingsHelper.DetermineColumnType());
   }
+
+  public static PropertyBuilder<AnalysisResponse> HasAnalyzerResponse(this PropertyBuilder<AnalysisResponse> value)
+  {
+    var settings = SerializerSettingsHelper.CreateCustomSerializationSettings();
+
+    return value.HasConversion(
+      v => JsonSerializer.Serialize(v, settings),
+      v => JsonSerializer.Deserialize<AnalysisResponse>(v, settings) ?? new AnalysisResponse())
+      .HasColumnType(SerializerSettingsHelper.DetermineColumnType());
+  }
+
+  public static PropertyBuilder<RepeatedField<Objective>> HasObjectives(this PropertyBuilder<RepeatedField<Objective>> value)
+  {
+    var settings = SerializerSettingsHelper.CreateCustomSerializationSettings();
+
+    return value.HasConversion(
+      v => JsonSerializer.Serialize(v, settings),
+      v => JsonSerializer.Deserialize<RepeatedField<Objective>>(v, settings) ?? new RepeatedField<Objective>())
+      .HasColumnType(SerializerSettingsHelper.DetermineColumnType());
+  }
 }
diff --git a/Ares.Core/EntityConfigurations/Helpers/SerializerSettingsHelper.cs b/Ares.Core/EntityConfigurations/Helpers/SerializerSettingsHelper.cs
index ee75b524..288e40a3 100644
--- a/Ares.Core/EntityConfigurations/Helpers/SerializerSettingsHelper.cs
+++ b/Ares.Core/EntityConfigurations/Helpers/SerializerSettingsHelper.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using System.Text.Json.Serialization;
 
 namespace Ares.Core.EntityConfigurations.Helpers;
 
diff --git a/Ares.Core/Execution/Executors/CampaignExecutor.cs b/Ares.Core/Execution/Executors/CampaignExecutor.cs
index fe8cf61e..ac98acbf 100644
--- a/Ares.Core/Execution/Executors/CampaignExecutor.cs
+++ b/Ares.Core/Execution/Executors/CampaignExecutor.cs
@@ -111,7 +111,7 @@ await _stateLoggerManager.EnableOverrideAsync(new Datamodel.Device.DeviceLogging
     try
     {
       var campaignPath = await InitializeCampaign(CampaignStartTime);
-      var analyses = new List<Analysis>();
+      var analyses = new List<AnalysisResponse>();
       
       ResetStatus(token);
       await NotifyCampaignStart();
@@ -193,7 +193,7 @@ private async Task NotifyCampaignStart()
     _logger.LogInformation("Campaign started named {CampaignName}", Template.Name);
   }
 
-  private async Task<(bool Success, ExperimentExecutionSummary Summary)> ExecuteStartup(List<Analysis> analyses, List<ExperimentExecutionSummary> experimentSummaries, ExecutionControlToken token)
+  private async Task<(bool Success, ExperimentExecutionSummary Summary)> ExecuteStartup(List<AnalysisResponse> analyses, List<ExperimentExecutionSummary> experimentSummaries, ExecutionControlToken token)
   {
     _logger.LogDebug("Startup template not null, will run startup script");
     var startupExecutorResult = await GenerateExperimentExecutor(Template.StartupTemplate, analyses, experimentSummaries.Select(es => es.ExperimentOverview), token.CancellationToken);
@@ -213,9 +213,9 @@ private async Task NotifyCampaignStart()
     return (true, startupSummary);
   }
 
-  private async Task<ExperimentLoopOutcome> ExecuteExperimentLoop(string campaignPath, 
-    List<Analysis> analyses, 
-    List<ExperimentExecutionSummary> experimentSummaries, 
+  private async Task<ExperimentLoopOutcome> ExecuteExperimentLoop(string campaignPath,
+    List<AnalysisResponse> analyses, 
+    List<ExperimentExecutionSummary> experimentSummaries,
     ExecutionControlToken token, 
     ExperimentExecutionSummary startupSummary)
   {
@@ -298,7 +298,7 @@ private async Task<ExperimentLoopOutcome> ExecuteExperimentLoop(string campaignP
     }
   }
 
-  private async Task<ExperimentPhase> PrepareExperiment(List<Analysis> analyses, List<ExperimentExecutionSummary> experimentSummaries, ExecutionControlToken token)
+  private async Task<ExperimentPhase> PrepareExperiment(List<AnalysisResponse> analyses, List<ExperimentExecutionSummary> experimentSummaries, ExecutionControlToken token)
   {
     if(_currentExperimentTemplate is null)
     {
@@ -402,7 +402,10 @@ private async Task<ExperimentPhase> ExecuteCurrentExperiment(string currentExper
     }
   }
 
-  private async Task<ExperimentPhase> AnalyzeCurrentExperiment(ExperimentExecutionSummary startupSummary, List<Analysis> analyses, List<ExperimentExecutionSummary> experimentSummaries, ExecutionControlToken token)
+  private async Task<ExperimentPhase> AnalyzeCurrentExperiment(ExperimentExecutionSummary startupSummary, 
+    List<AnalysisResponse> analyses, 
+    List<ExperimentExecutionSummary> experimentSummaries, 
+    ExecutionControlToken token)
   {
     if(token.IsCancelled)
       return ExperimentPhase.Canceled;
@@ -411,6 +414,7 @@ private async Task<ExperimentPhase> AnalyzeCurrentExperiment(ExperimentExecution
       return ExperimentPhase.Failed;
 
     var result = await AnalyzeResult(_currentExecutorResult.ExperimentExecutor, _currentSummary, startupSummary, analyses, token);
+
     if(!result.Continue)
       return result.Success ? ExperimentPhase.Canceled : ExperimentPhase.Failed;
 
@@ -419,7 +423,7 @@ private async Task<ExperimentPhase> AnalyzeCurrentExperiment(ExperimentExecution
     return ExperimentPhase.Complete;
   }
 
-  private async Task<ExperimentPhase> ReplanCurrentExperiment(List<Analysis> analyses, List<ExperimentExecutionSummary> experimentSummaries, ExecutionControlToken token)
+  private async Task<ExperimentPhase> ReplanCurrentExperiment(List<AnalysisResponse> analyses, List<ExperimentExecutionSummary> experimentSummaries, ExecutionControlToken token)
   {
     if(_currentExperimentTemplate is null)
     {
@@ -516,8 +520,6 @@ private async Task<ExperimentPhase> HandleError(CommandExecutionSummary cmdSumma
         return ExperimentPhase.Failed;
     }
   }
-
-
   private void UpdatePlanStatus(CommandStatusCode failCode)
   {
     if(failCode == CommandStatusCode.OutOfRange || failCode == CommandStatusCode.ParametersUnachievable)
@@ -527,9 +529,9 @@ private void UpdatePlanStatus(CommandStatusCode failCode)
       _latestPlanStatusCodes.Add(PlanStatusCode.PlanFailed);
   }
 
-  private async Task<bool> PlanExperiment(List<Analysis> analyses, 
-    ExperimentTemplate currentExperimentTemplate, 
-    List<ExperimentExecutionSummary> experimentSummaries, 
+  private async Task<bool> PlanExperiment(List<AnalysisResponse> analyses,
+    ExperimentTemplate currentExperimentTemplate,
+    List<ExperimentExecutionSummary> experimentSummaries,
     ExecutionControlToken token)
   {
     Status.PlannerState = PlannerState.PlanningInProgress;
@@ -549,7 +551,7 @@ private async Task<bool> PlanExperiment(List<Analysis> analyses,
 
     var resolveSuccess = await _planningHelper.TryResolveParameters(Template.PlannerAllocations,
       metadata,
-      currentExperimentTemplate.GetAllPlannedParameters(),
+      currentExperimentTemplate,
       analyses,
       experimentSummaries.Select(es => es.ExperimentOverview),
       BatchPlanningSize,
@@ -568,7 +570,7 @@ private async Task<bool> PlanExperiment(List<Analysis> analyses,
   private async Task<(bool Success, bool Continue)> AnalyzeResult(ExperimentExecutor experimentExecutor, 
     ExperimentExecutionSummary experimentSummary, 
     ExperimentExecutionSummary startupSummary, 
-    List<Analysis> analyses, 
+    List<AnalysisResponse> analyses, 
     ExecutionControlToken token)
   {
     var metadata = new RequestMetadata 
@@ -593,14 +595,6 @@ private async Task<bool> PlanExperiment(List<Analysis> analyses,
     // The following are top level checks for analysis failure in case the
     // failure is not properly handled on the Analysis itself
     // which also has support for "success" and "error" message
-    if(analysis is null || analysis.Result == float.NaN)
-    {
-      Status.AnalysisState = AnalysisState.AnalysisError;
-      await _notifier.Notify("Analysis Failure", $"Analysis was reported as successful, but no actual analysis was provided. {analysis?.ErrorString ?? "No error string provided"}", NotificationSeverityEnum.Error);
-      _logger.LogError("Failed to analyze. The analysis result came back as {Result}", analysis?.Result);
-      return (false, false);
-    }
-
     if(analysis.AnalysisOutcome == Outcome.Failure)
     {
       Status.AnalysisState = AnalysisState.AnalysisError;
@@ -623,11 +617,20 @@ private async Task<bool> PlanExperiment(List<Analysis> analyses,
       _logger.LogWarning("Analysis completed successfully, but the analyzer emitted a warning! {Warning}", analysis.ErrorString);
     }
 
+    if(analysis is null || !analysis.Objectives.Any())
+    {
+      Status.AnalysisState = AnalysisState.AnalysisError;
+      await _notifier.Notify("Analysis Failure", $"Analysis was reported as successful, but no actual analysis was provided. {analysis?.ErrorString ?? "No error string provided"}", NotificationSeverityEnum.Error);
+      _logger.LogError("Failed to analyze. The analysis result came back as {Result}", analysis?.Objectives);
+      return (false, false);
+    }
+
     Status.AnalysisState = AnalysisState.AnalysisComplete;
     ReportCampaignStatus();
     analyses.Add(analysis);
 
     _analysisRepo.Add(analysis);
+
     // Here the analysis has failed, but the analyzer properly reported why
     // it failed via the analysis result.
     if(analysis.ErrorString != string.Empty && string.IsNullOrEmpty(analysis.ErrorString))
@@ -639,7 +642,7 @@ private async Task<bool> PlanExperiment(List<Analysis> analyses,
     return (true, true);
   }
 
-  private async Task<(bool Success, ExperimentExecutionSummary Summary)> ExecuteCloseout(List<Analysis> analyses, List<ExperimentExecutionSummary> experimentSummaries, ExecutionControlToken token, bool executionSuccess)
+  private async Task<(bool Success, ExperimentExecutionSummary Summary)> ExecuteCloseout(List<AnalysisResponse> analyses, List<ExperimentExecutionSummary> experimentSummaries, ExecutionControlToken token, bool executionSuccess)
   {
     _logger.LogInformation("Closeout template is set. Running the closeout script.");
     var closeoutExecutorResult = await GenerateExperimentExecutor(Template.CloseoutTemplate, analyses, experimentSummaries.Select(es => es.ExperimentOverview), token.CancellationToken);
@@ -739,8 +742,8 @@ private static bool IsAwaitingResponse(ExperimentExecutionStatus status)
     .Any(step => step.CommandExecutionStatuses
     .Any(cmd => cmd.State == ExecutionState.AwaitingUser));
 
-  private async Task<ExperimentExecutorResult> GenerateExperimentExecutor(ExperimentTemplate template,
-    IEnumerable<Analysis> analyses,
+  private async Task<ExperimentExecutorResult> GenerateExperimentExecutor(ExperimentTemplate template, 
+    IEnumerable<AnalysisResponse> analyses, 
     IEnumerable<ExperimentOverview> previousExperiments,
     CancellationToken cancellationToken)
   {
@@ -769,7 +772,7 @@ private async Task<ExperimentExecutorResult> GenerateExperimentExecutor(Experime
 
         var resolveSuccess = await _planningHelper.TryResolveParameters(Template.PlannerAllocations, 
           metadata, 
-          experimentTemplate.GetAllPlannedParameters(), 
+          experimentTemplate, 
           analyses, 
           previousExperiments,
           BatchPlanningSize,
diff --git a/Ares.Core/Execution/StopConditions/DesiredAnalysisResult.cs b/Ares.Core/Execution/StopConditions/DesiredAnalysisResult.cs
index 49e63b62..b68a3fc7 100644
--- a/Ares.Core/Execution/StopConditions/DesiredAnalysisResult.cs
+++ b/Ares.Core/Execution/StopConditions/DesiredAnalysisResult.cs
@@ -24,7 +24,8 @@ public bool ShouldStop()
     if (latestAnalysis is null)
       return false;
 
-    var analysisVal = latestAnalysis.Result;
+    //TODO: Fix to check things properly
+    var analysisVal = latestAnalysis.Objectives.FirstOrDefault()?.ObjectiveValue.FloatValue;
     var resultAchieved = analysisVal >= _desiredResult - _leeway && analysisVal <= _desiredResult + _leeway;
     if (resultAchieved)
       Message = $"Achieved result {analysisVal} which is within {_leeway} of {_desiredResult}";
diff --git a/Ares.Core/Execution/VersionChecking/DatamodelVersionValidator.cs b/Ares.Core/Execution/VersionChecking/DatamodelVersionValidator.cs
index 8297e122..5f101fe1 100644
--- a/Ares.Core/Execution/VersionChecking/DatamodelVersionValidator.cs
+++ b/Ares.Core/Execution/VersionChecking/DatamodelVersionValidator.cs
@@ -86,5 +86,5 @@ public static string NormalizePep440ToSemVer(string rawVersion)
     return Pep440ToSemVerRegex.Replace(rawVersion.Trim(), "$1-$2");
   }
 
-  public static SemanticVersion MinimumRequiredDatamodelVersion { get; set; } = SemanticVersion.Parse("0.33.0");
+  public static SemanticVersion MinimumRequiredDatamodelVersion { get; set; } = SemanticVersion.Parse("0.36.0");
 }
diff --git a/Ares.Core/Planning/IPlannerService.cs b/Ares.Core/Planning/IPlannerService.cs
index 771cf59f..5cc7cb55 100644
--- a/Ares.Core/Planning/IPlannerService.cs
+++ b/Ares.Core/Planning/IPlannerService.cs
@@ -40,6 +40,12 @@ public interface IPlannerService
   /// <returns></returns>
   Task Init();
 
+  /// <summary>
+  /// Refreshes the planners connection, calling this prior to reporting updated information about a planner is ideal
+  /// </summary>
+  /// <returns></returns>
+  Task Refresh();
+
   /// <summary>
   /// Provides an observable for the <see cref="State"/>
   /// </summary>
diff --git a/Ares.Core/Planning/IPlanningHelper.cs b/Ares.Core/Planning/IPlanningHelper.cs
index 99ecec7d..b0f8ac6e 100644
--- a/Ares.Core/Planning/IPlanningHelper.cs
+++ b/Ares.Core/Planning/IPlanningHelper.cs
@@ -20,8 +20,8 @@ public interface IPlanningHelper
   /// <returns>True if planning succeeded, false otherwise</returns>
   Task<bool> TryResolveParameters(IEnumerable<PlannerAllocation> plannerAllocations,
     RequestMetadata metadata,
-    IEnumerable<Parameter> parameters,
-    IEnumerable<Analysis> seedAnalyses,
+    ExperimentTemplate currentTemplate,
+    IEnumerable<AnalysisResponse> seedAnalyses,
     IEnumerable<ExperimentOverview> seedExperiments,
     int batchSize,
     List<PlanStatusCode> codes,
diff --git a/Ares.Core/Planning/ManualPlanner.cs b/Ares.Core/Planning/ManualPlanner.cs
index b3b117fe..1dca2ccf 100644
--- a/Ares.Core/Planning/ManualPlanner.cs
+++ b/Ares.Core/Planning/ManualPlanner.cs
@@ -32,14 +32,19 @@ public Task<PlanningResponse> Plan(PlanningRequest request, CancellationToken __
       var currentParameterSet = _planResultsQueue.Dequeue().ToList();
       var returnList = request.PlanningParameters.Select(param => currentParameterSet.First(result => result.Name == param.ParameterName).ToPlannedParameter(param)).ToList();
       var response = new PlanningResponse();
-      
-      response.PlannedParameters.AddRange(returnList);
-      response.PlanningOutcome = Outcome.Success;
+
+      var plan = new Plan() { PlanningOutcome = Outcome.Success };
+      plan.PlannedParameters.AddRange(returnList);
+      response.Plans.Add(plan);
       return Task.FromResult(response);
     }
     catch(InvalidOperationException e)
     {
-      return Task.FromResult(new PlanningResponse() { ErrorString = $"Exception Occured in Manual Planner: {e.Message}", PlanningOutcome = Outcome.Failure});
+      var errorResponse = new PlanningResponse();
+      var errorPlan = new Plan() { ErrorString = $"Exception Occured in Manual Planner: {e.Message}", PlanningOutcome = Outcome.Failure };
+      errorResponse.Plans.Add(errorPlan);
+
+      return Task.FromResult(errorResponse);
     }
   }
 
@@ -76,6 +81,9 @@ public async Task Reseed()
       await Seed(LatestManualPlannerSeed);
   }
 
+  public Task Refresh() 
+    => Task.CompletedTask;
+
   public void Reset()
   {
     _planResultsQueue.Clear();
diff --git a/Ares.Core/Planning/PlannerServiceBase.cs b/Ares.Core/Planning/PlannerServiceBase.cs
index 5448569e..84b22cb8 100644
--- a/Ares.Core/Planning/PlannerServiceBase.cs
+++ b/Ares.Core/Planning/PlannerServiceBase.cs
@@ -65,6 +65,8 @@ public void UpdateSettings(AresStruct settings)
 
   public abstract Task<PlannerServiceCapabilities> GetCapabilities(CancellationToken cancellationToken);
 
+  public abstract Task Refresh();
+
   public virtual Task Init()
   {
     return Task.CompletedTask;
diff --git a/Ares.Core/Planning/PlanningHelper.cs b/Ares.Core/Planning/PlanningHelper.cs
index 4070d5b1..243c23b0 100644
--- a/Ares.Core/Planning/PlanningHelper.cs
+++ b/Ares.Core/Planning/PlanningHelper.cs
@@ -34,14 +34,15 @@ public PlanningHelper(IPlannerServiceRepo plannerManager,
   }
 
   public async Task<bool> TryResolveParameters(IEnumerable<PlannerAllocation> plannerAllocations,
-    RequestMetadata metadata,
-    IEnumerable<Parameter> parameters,
-    IEnumerable<Analysis> seedAnalyses,
-    IEnumerable<ExperimentOverview> seedExperiments,
-    int batchSize,
-    List<PlanStatusCode> statusCodes,
-    CancellationToken cancellationToken)
+  RequestMetadata metadata,
+  ExperimentTemplate currentTemplate,
+  IEnumerable<AnalysisResponse> seedAnalyses,
+  IEnumerable<ExperimentOverview> seedExperiments,
+  int batchSize,
+  List<PlanStatusCode> codes,
+  CancellationToken cancellationToken)
   {
+    var parameters = currentTemplate.GetAllPlannedParameters();
     var parameterArray = parameters.ToArray();
     var plannerToMetadataMaps = MapParameterMetadataToPlanners(plannerAllocations);
 
@@ -63,7 +64,7 @@ public async Task<bool> TryResolveParameters(IEnumerable<PlannerAllocation> plan
         return true;
       }
 
-      return await RequestNewPlans(planner, grouping, seedExperiments, seedAnalysesArr, statusCodes, metadata, planQueue, parameterArray, batchSize, cancellationToken);
+      return await RequestNewPlans(planner, grouping, seedExperiments, seedAnalysesArr, codes, metadata, planQueue, parameterArray, batchSize, cancellationToken);
     });
 
     var results = await Task.WhenAll(planningTasks);
@@ -86,7 +87,7 @@ public async Task<bool> TryResolveParameters(IEnumerable<PlannerAllocation> plan
   private async Task<bool> RequestNewPlans(IPlannerService planner,
     IGrouping<IPlannerService, (IPlannerService, ParameterMetadata)> grouping,
     IEnumerable<ExperimentOverview> seedExperiments,
-    Analysis[] seedAnalysesArr,
+    AnalysisResponse[] seedAnalysesArr,
     List<PlanStatusCode> statusCodes,
     RequestMetadata metadata,
     ConcurrentQueue<Plan> planQueue,
@@ -130,10 +131,9 @@ private async Task<bool> RequestNewPlans(IPlannerService planner,
 
       else
       {
-        var legacyResponseProcessed = await HandleLegacyPlanResponse(planResponse, parameterArray);
-
-        if(!legacyResponseProcessed)
-          return false;
+        _logger.LogError("Received plan response, but no plans were returned.");
+        await _notifier.Notify("Planner Error!", "Plan response received, but no plans included in response!", NotificationSeverityEnum.Error);
+        return false;
       }
     }
 
@@ -159,15 +159,35 @@ private async Task<bool> RequestNewPlans(IPlannerService planner,
   /// <returns>An ARES <cref><see cref="PlanningRequest"/></cref></returns>
   private PlanningRequest CreatePlanningRequest(ParameterMetadata[] plannableParameters,
     IEnumerable<ExperimentOverview> seedExperiments,
-    Analysis[] seedAnalysesArr,
+    AnalysisResponse[] seedAnalysesArr,
     List<PlanStatusCode> statusCodes,
     int batchSize,
     RequestMetadata metadata)
   {
     //Create the plan request. Store it in the transaction.
+    var relevantExperiments = seedExperiments.ToList();
     var planRequest = new PlanningRequest();
+
     planRequest.PlanningParameters.AddRange(plannableParameters.Select(parameter => ConvertToPlanningParameter(parameter, seedExperiments)));
-    planRequest.AnalysisResults.AddRange(seedAnalysesArr.Select(a => (double)a.Result));
+    for(int i = 0; i < seedAnalysesArr.Length; i++)
+    {
+      var currentAnalysis = seedAnalysesArr.ElementAtOrDefault(i);
+      var currentExp = relevantExperiments.ElementAtOrDefault(i);
+
+      if(currentAnalysis is null || currentExp is null)
+        continue;
+
+      // Add values to the deprecated field for now to ensure backwards compatability
+      // TODO: REMOVE IN NEXT MAJOR VERSION OF ARES/PYARES
+      var defaultObjective = currentAnalysis.Objectives.FirstOrDefault()?.ObjectiveValue;
+
+      //If the objective doesn't have a number value, then the analyzer was built for running the newest system
+      if(defaultObjective is not null && defaultObjective.HasNumberValue)
+        planRequest.AnalysisResults.Add(defaultObjective.NumberValue);
+
+      var analysisData = CreateAnalysisData(currentAnalysis, currentExp);
+      planRequest.AnalysisData.Add(analysisData);
+    }
     planRequest.PreviousPlanStatusCodes.AddRange(statusCodes);
     planRequest.Metadata = metadata;
     planRequest.BatchSize = batchSize;
@@ -197,59 +217,6 @@ private PlanningRequest CreatePlanningRequest(ParameterMetadata[] plannableParam
     return plannerToMetadataMaps;
   }
 
-  /// <summary>
-  /// Handles legacy plan responses
-  /// </summary>
-  /// <param name="planResponse"></param>
-  /// <param name="parameterArray"></param>
-  /// <returns>A bool indicating whether or not resolving variables was a success</returns>
-  private async Task<bool> HandleLegacyPlanResponse(PlanningResponse planResponse, Parameter[] parameterArray)
-  {
-#pragma warning disable CS0612 // Type or member is obsolete
-
-    if(planResponse.PlanningOutcome == Outcome.Failure)
-    {
-      if(string.IsNullOrWhiteSpace(planResponse.ErrorString))
-        await _notifier.Notify("Planner Error!", "Planner reported that planning failed, but did not provide any specific error as to why.", NotificationSeverityEnum.Error);
-
-      else
-        await _notifier.Notify($"Planner Reported Error: {planResponse.ErrorString}", "Planner Error!", NotificationSeverityEnum.Error);
-
-      return false;
-    }
-
-    if(planResponse.PlanningOutcome == Outcome.Warning)
-    {
-      if(string.IsNullOrWhiteSpace(planResponse.ErrorString))
-        await _notifier.Notify("Planner Warning", "Planner reported a warning, but did not provide specific context for that warning.", NotificationSeverityEnum.Warning);
-
-      else
-        await _notifier.Notify("Planner Warning", $"Planner successfully planned, but reported a warning: {planResponse.ErrorString}", NotificationSeverityEnum.Warning);
-    }
-
-    if(planResponse.PlanningOutcome == Outcome.Canceled)
-      await _notifier.Notify("Planning was canceled.", "Planning was canceled.", NotificationSeverityEnum.Info);
-
-    if(!planResponse.PlannedParameters.Any())
-    {
-      await _notifier.Notify("Planning Error!", "Tried to plan for experiment, but planning returned no plan results! Campaign will stop.", NotificationSeverityEnum.Error);
-      return false;
-    }
-
-    foreach(var result in planResponse.PlannedParameters)
-    {
-      var parameterPlanTarget = parameterArray.FirstOrDefault(parameter => parameter.GetPlanningMetadata()?.Name == result.ParameterName);
-
-      if(parameterPlanTarget is null)
-        continue;
-
-      parameterPlanTarget.SetResolvedValue(result.ParameterValue);
-    }
-
-    return true;
-#pragma warning restore CS0612 // Type or member is obsolete
-  }
-
   /// <summary>
   /// Takes in a plan and a parameter array and resolves those parameters using the provided plan
   /// </summary>
@@ -315,6 +282,27 @@ private static PlanningParameter ConvertToPlanningParameter(ParameterMetadata me
     return parameter;
   }
 
+  private AnalysisData CreateAnalysisData(AnalysisResponse analysis, ExperimentOverview experiment)
+  {
+    var newData = new AnalysisData();
+
+    // If no objectives were specified, include all of them.
+    if(experiment.Template.PlanObjectives.Count == 0)
+    {
+      foreach(var objective in analysis.Objectives)
+        newData.AnalysisObjectives.Add(objective);
+    }
+
+    else
+    {
+      foreach(var objective in analysis.Objectives)
+        if(experiment.Template.PlanObjectives.Any(obj => obj == objective.ObjectiveName))
+          newData.AnalysisObjectives.Add(objective);
+    }
+
+    return newData;
+  }
+
   /// <summary>
   /// Logs the planner transaction to the database.
   /// </summary>
diff --git a/Ares.Core/Planning/RemotePlannerService.cs b/Ares.Core/Planning/RemotePlannerService.cs
index b5bc448f..c35db7ed 100644
--- a/Ares.Core/Planning/RemotePlannerService.cs
+++ b/Ares.Core/Planning/RemotePlannerService.cs
@@ -38,6 +38,11 @@ public override async Task Init()
     await VerifyDatamodelCompatability();
     await UpdateState();
     await UpdateCapabilities();
+  }
+
+  public override async Task Refresh()
+  {
+    await UpdateState();
   }
 
   internal async Task UpdateInfo()
diff --git a/Ares.Core/Resources/IResourceConnectionArbiter.cs b/Ares.Core/Resources/IResourceConnectionArbiter.cs
index b132f569..5c7fc9c9 100644
--- a/Ares.Core/Resources/IResourceConnectionArbiter.cs
+++ b/Ares.Core/Resources/IResourceConnectionArbiter.cs
@@ -34,5 +34,5 @@ public interface IResourceConnectionArbiter
   /// </summary>
   /// <param name="resource">The resource to get the owner of.</param>
   /// <returns>The ResourceOwner, or null if the resource is not in use.</returns>
-  IAresDevice? GetResourceOwner(ConnectionResource resource);
+  List<IAresDevice> GetResourceOwners(ConnectionResource resource);
   }
\ No newline at end of file
diff --git a/Ares.Core/Resources/ResourceConnectionArbiter.cs b/Ares.Core/Resources/ResourceConnectionArbiter.cs
index 24dccaec..8f2d171e 100644
--- a/Ares.Core/Resources/ResourceConnectionArbiter.cs
+++ b/Ares.Core/Resources/ResourceConnectionArbiter.cs
@@ -8,38 +8,68 @@ namespace Ares.Core.Resources;
 /// </summary>
 public class ResourceConnectionArbiter : IResourceConnectionArbiter
 {
-  private readonly ConcurrentDictionary<ConnectionResource, IAresDevice> _resourceLocks = new ConcurrentDictionary<ConnectionResource, IAresDevice>();
+  private readonly ConcurrentDictionary<ConnectionResource, List<IAresDevice>> _resourceLocks = new ConcurrentDictionary<ConnectionResource, List<IAresDevice>>();
 
   /// <inheritdoc />
-  public bool TryAcquireResource(ConnectionResource resource, IAresDevice owner)
+  public bool TryAcquireResource(ConnectionResource resource, IAresDevice requester)
   {
-      if(string.IsNullOrEmpty(owner?.UniqueId) || resource == null)
-          return false;
+    if(string.IsNullOrEmpty(requester?.UniqueId) || resource == null)
+      return false;
 
-      return _resourceLocks.TryAdd(resource, owner);
+    if(!IsResourceInUse(resource))
+      return _resourceLocks.TryAdd(resource, [requester]);
+
+    else
+    {
+      var resourceOwners = GetResourceOwners(resource);
+
+      if(resourceOwners is null)
+        return _resourceLocks.TryAdd(resource, [requester]);
+
+      var requestingDeviceType = requester.GetType();
+      var resourceOwnerType = resourceOwners?.First().GetType();
+
+      // If the device is of the exact same type, allow the resource allocation to pass.
+      if(requestingDeviceType.Name == resourceOwnerType?.Name)
+        return true;
+
+      return false;
+    }
   }
 
   /// <inheritdoc />
   public void ReleaseResource(ConnectionResource resource, IAresDevice owner)
   {
-      if(resource == null || owner == null)
-          return;
-          
-      _resourceLocks.TryRemove(new KeyValuePair<ConnectionResource, IAresDevice>(resource, owner));
+    if(resource == null || owner == null)
+        return;
+
+    var ownerList = GetResourceOwners(resource);
+
+    if(ownerList.Count == 0 || ownerList.Count == 1)
+      _resourceLocks.TryRemove(new KeyValuePair<ConnectionResource, List<IAresDevice>>(resource, ownerList));
+
+
+    var updatedOwnerList = ownerList.ToList();
+    updatedOwnerList.Remove(owner);
+    _resourceLocks.TryUpdate(resource, updatedOwnerList, ownerList);
   }
 
   /// <inheritdoc />
   public bool IsResourceInUse(ConnectionResource resource)
   {
-      if(resource == null) return false;
-      return _resourceLocks.ContainsKey(resource);
+    if(resource == null) 
+      return false;
+    
+    return _resourceLocks.ContainsKey(resource);
   }
 
   /// <inheritdoc />
-  public IAresDevice? GetResourceOwner(ConnectionResource resource)
+  public List<IAresDevice> GetResourceOwners(ConnectionResource resource)
   {
-      if(resource == null) return null;
-      _resourceLocks.TryGetValue(resource, out var owner);
-      return owner;
+    if(resource == null) 
+      return [];
+    
+    _resourceLocks.TryGetValue(resource, out var owner);
+    return owner ?? [];
   }
 }
diff --git a/AresScript/AresScript.csproj b/AresScript/AresScript.csproj
index 4e8bf109..adccc18e 100644
--- a/AresScript/AresScript.csproj
+++ b/AresScript/AresScript.csproj
@@ -9,7 +9,7 @@
   <ItemGroup>
     <PackageReference Include="Antlr4.Runtime.Standard" Version="4.13.1" />
     <PackageReference Include="Antlr4BuildTasks" Version="12.14.0" />
-    <PackageReference Include="ARES.Datamodel" Version="0.35.0" />
+    <PackageReference Include="ARES.Datamodel" Version="0.36.0" />
     <PackageReference Include="System.Reactive" Version="7.0.0" /> 
   </ItemGroup>
 
diff --git a/AresService.Migrations.Postgres/Migrations/20260817202202_analyzer-upgrades_AresDbContext.Designer.cs b/AresService.Migrations.Postgres/Migrations/20260817202202_analyzer-upgrades_AresDbContext.Designer.cs
new file mode 100644
index 00000000..a53e8b0f
--- /dev/null
+++ b/AresService.Migrations.Postgres/Migrations/20260817202202_analyzer-upgrades_AresDbContext.Designer.cs
@@ -0,0 +1,2327 @@
+// <auto-generated />
+using System;
+using AresService.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace AresService.Migrations.Postgres.Migrations.AresDb
+{
+    [DbContext(typeof(AresDbContext))]
+    [Migration("20260817202202_analyzer-upgrades_AresDbContext")]
+    partial class analyzerupgrades_AresDbContext
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.10")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Ares.Datamodel.AnalysisOverview", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AnalyzerInfo")
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid?>("ExperimentOverviewId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Objectives")
+                        .HasColumnType("jsonb");
+
+                    b.Property<double>("Result")
+                        .HasColumnType("double precision");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ExperimentOverviewId")
+                        .IsUnique();
+
+                    b.ToTable("AnalysisOverview");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.Analysis", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AnalysisOutcome")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("ErrorString")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<float>("Result")
+                        .HasColumnType("real");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("Analyses", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalysisResponse", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AnalysisOutcome")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("ErrorString")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Objectives")
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalysisResponses", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerCapabilities", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnalyzerInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("ObjectiveOutputSchema")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SettingsSchema")
+                        .HasColumnType("text");
+
+                    b.Property<long>("TimeoutSeconds")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("AnalyzerInfoId")
+                        .IsUnique();
+
+                    b.ToTable("AnalyzerCapabilities");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("Analyzers", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalyzerInfos");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerSettings", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AnalyzerId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Settings")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalyzerSettings");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerTransaction", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AnalysisRequest")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("AnalysisResponse")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("AnalyzerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AnalyzerName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AnalyzerResponse")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("AnalyzerType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AnalyzerVersion")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime?>("TimeRequestSent")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("TimeResponseReceived")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalyzerTransactions");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.AresCampaignTag", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("TagName")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("CampaignTags");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.AresGeneralSettingsConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CommandLatency")
+                        .HasColumnType("jsonb");
+
+                    b.Property<int>("CommandRetryLimit")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<bool>("DisplayCompatabilityWarnings")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("DisplayDataCollectionWidget")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("ExperimentRetryLimit")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("RetryCooldown")
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AresGeneralSettingsConfig", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommand", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("CurrentVersionId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("CustomCommands", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandParameter", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid>("CustomCommandVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Schema")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CustomCommandVersionId");
+
+                    b.ToTable("CustomCommandParameters", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandVersion", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid>("CustomCommandId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OutputSchema")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ScriptBody")
+                        .HasColumnType("text");
+
+                    b.Property<long>("VersionNumber")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CustomCommandId", "VersionNumber")
+                        .IsUnique();
+
+                    b.ToTable("CustomCommandVersions", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CampaignExecutionSummary", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CampaignId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CampaignName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CampaignNotes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CampaignTags")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("CloseoutExecutionSummaryUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid?>("StartupExecutionSummaryUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CloseoutExecutionSummaryUniqueId");
+
+                    b.HasIndex("StartupExecutionSummaryUniqueId");
+
+                    b.ToTable("CampaignExecutionSummaries", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionStatus", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CommandId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CommandName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("DeviceName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("text");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("StatusMessage")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("StepExecutionStatusUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("VariableName")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("StepExecutionStatusUniqueId");
+
+                    b.ToTable("CommandExecutionStatuses", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionSummary", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CommandDescription")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CommandId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CommandName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<int>("StatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("StepExecutionSummaryUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("TemplateId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("VarName")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("StepExecutionSummaryUniqueId");
+
+                    b.ToTable("CommandExecutionSummaries", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandResult", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("AwaitUserInput")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("CommandExecutionSummaryId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("text");
+
+                    b.Property<int>("StatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Success")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CommandExecutionSummaryId")
+                        .IsUnique();
+
+                    b.ToTable("DeviceCommandResults", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceCommandDescriptor", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("DeviceInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("InputSchema")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OutputSchema")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("DeviceInfoId");
+
+                    b.ToTable("DeviceCommandDescriptor");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeviceName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeviceSettings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DriverId")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsSimulated")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid?>("SerialInfoUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("SerialInfoUniqueId");
+
+                    b.ToTable("DeviceConfigs", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SettingsSchema")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceInfos");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceLoggingSettings", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Deltas")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("text");
+
+                    b.Property<long>("IntervalMs")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<bool>("LoggingEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("LoggingType")
+                        .HasColumnType("integer");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceLoggingSettings");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceSettings", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Settings")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceSettings");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceState", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime?>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceStates");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.RemoteDeviceConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("RemoteDevices", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.SerialConnection", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("BaudRate")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("PortName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SerialId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("SerialConnection");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.DeviceErrorHandlingConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Code")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<int>("Handling")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("ErrorHandlingConfigs", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExecutionInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CampaignExecutionSummaryId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CommandExecutionSummaryId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid?>("ExperimentResultId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("LocaltimeOffset")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("StepExecutionSummaryId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("TimeFinished")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("TimeStarted")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Timezone")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignExecutionSummaryId")
+                        .IsUnique();
+
+                    b.HasIndex("CommandExecutionSummaryId")
+                        .IsUnique();
+
+                    b.HasIndex("ExperimentResultId")
+                        .IsUnique();
+
+                    b.HasIndex("StepExecutionSummaryId")
+                        .IsUnique();
+
+                    b.ToTable("ExecutionInfos", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentExecutionSummary", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CampaignExecutionSummaryUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("ExperimentId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("ResultOutputPath")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignExecutionSummaryUniqueId");
+
+                    b.ToTable("ExperimentExecutionSummaries", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentOverview", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid?>("ExperimentResultId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TemplateUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ExperimentResultId")
+                        .IsUnique();
+
+                    b.HasIndex("TemplateUniqueId");
+
+                    b.ToTable("ExperimentOverviews", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Limits", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<double>("Maximum")
+                        .HasColumnType("double precision");
+
+                    b.Property<double>("Minimum")
+                        .HasColumnType("double precision");
+
+                    b.Property<Guid>("ParameterMetadataUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ParameterMetadataUniqueId");
+
+                    b.ToTable("Limits");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.Planner", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("PlannerName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("PlannerServiceCapabilitiesUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("PlannerServiceCapabilitiesUniqueId");
+
+                    b.ToTable("Planner");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerAllocation", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CampaignTemplateUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid?>("ParameterUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("PlannerId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignTemplateUniqueId");
+
+                    b.HasIndex("ParameterUniqueId");
+
+                    b.HasIndex("PlannerId");
+
+                    b.ToTable("PlannerAllocations", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("PlannerServices", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceCapabilities", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<bool>("MultiObjectiveCapable")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("PlannerInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ServiceName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SettingsSchema")
+                        .HasColumnType("text");
+
+                    b.Property<long>("TimeoutSeconds")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("PlannerInfoId")
+                        .IsUnique();
+
+                    b.ToTable("PlannerServiceCapabilities");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("PlannerInfos");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerSettings", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("PlannerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Settings")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("PlannerSettings");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerTransaction", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("PlannerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlannerName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlannerType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlannerVersion")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanningRequest")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("PlanningResponse")
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime?>("TimeRequestSent")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("TimeResponseReceived")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("PlannerTransactions");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Project", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("Projects", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionStatus", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("StepId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("StepName")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("StepExecutionStatuses", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionSummary", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid?>("ExperimentExecutionSummaryUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("StepId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ExperimentExecutionSummaryUniqueId");
+
+                    b.ToTable("StepExecutionSummaries", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CampaignTemplate", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("CampaignTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandMetadata", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("DeviceCommandId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeviceType")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("DeviceCommandId")
+                        .IsUnique();
+
+                    b.ToTable("CommandMetadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandTemplate", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("OutputVarName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("StepTemplateUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("StepTemplateUniqueId");
+
+                    b.ToTable("CommandTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.DeviceCommand", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CommandTemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CommandTemplateId")
+                        .IsUnique();
+
+                    b.ToTable("DeviceCommands", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ExperimentTemplate", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AnalyzerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AnalyzerMaps")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("CampaignCloseoutId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CampaignExperimentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CampaignStartupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanObjectives")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Resolved")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignCloseoutId")
+                        .IsUnique();
+
+                    b.HasIndex("CampaignExperimentId")
+                        .IsUnique();
+
+                    b.HasIndex("CampaignStartupId")
+                        .IsUnique();
+
+                    b.ToTable("ExperimentTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.OutputMetadata", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("DataSchema")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("OutputMetadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.Parameter", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CommandTemplateUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid?>("ExperimentOverviewUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("SourceJson")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("Source");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CommandTemplateUniqueId");
+
+                    b.HasIndex("ExperimentOverviewUniqueId");
+
+                    b.ToTable("Parameters", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ParameterMetadata", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CampaignTemplateUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CommandMetadataUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("InitialValue")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("NotPlannable")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("OutputName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("ParameterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PlannerDescription")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlannerName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Schema")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Unit")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("UseDefault")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignTemplateUniqueId");
+
+                    b.HasIndex("CommandMetadataUniqueId");
+
+                    b.HasIndex("ParameterId")
+                        .IsUnique();
+
+                    b.ToTable("ParameterMetadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.StepTemplate", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid?>("ExperimentTemplateUniqueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsParallel")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ExperimentTemplateUniqueId");
+
+                    b.ToTable("StepTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Visualizing.Local.DeviceVisualizationConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ChartTitle")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<int>("GridH")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("GridW")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("GridX")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("GridY")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<int>("NumberDisplayPoints")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Paths")
+                        .HasColumnType("jsonb");
+
+                    b.Property<int>("PollingRate")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("ShowDataLabels")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("ShowMarkers")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("Style")
+                        .HasColumnType("integer");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceVisualizationConfigs");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Visualizing.Local.VisualizationPath", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AssociatedDeviceId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<int>("DataType")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsPlottable")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("VisualizationPath");
+                });
+
+            modelBuilder.Entity("Ares.Services.DriverInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DriverId")
+                        .HasColumnType("text");
+
+                    b.Property<long>("FileSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("text");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceDrivers");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.AnalysisOverview", b =>
+                {
+                    b.HasOne("Ares.Datamodel.ExperimentOverview", null)
+                        .WithOne("AnalysisOverview")
+                        .HasForeignKey("Ares.Datamodel.AnalysisOverview", "ExperimentOverviewId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerCapabilities", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Analyzing.AnalyzerInfo", null)
+                        .WithOne("Capabilities")
+                        .HasForeignKey("Ares.Datamodel.Analyzing.AnalyzerCapabilities", "AnalyzerInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandParameter", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Automation.CustomCommandVersion", null)
+                        .WithMany("InputParameters")
+                        .HasForeignKey("CustomCommandVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandVersion", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Automation.CustomCommand", null)
+                        .WithMany()
+                        .HasForeignKey("CustomCommandId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CampaignExecutionSummary", b =>
+                {
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", "CloseoutExecutionSummary")
+                        .WithMany()
+                        .HasForeignKey("CloseoutExecutionSummaryUniqueId");
+
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", "StartupExecutionSummary")
+                        .WithMany()
+                        .HasForeignKey("StartupExecutionSummaryUniqueId");
+
+                    b.Navigation("CloseoutExecutionSummary");
+
+                    b.Navigation("StartupExecutionSummary");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionStatus", b =>
+                {
+                    b.HasOne("Ares.Datamodel.StepExecutionStatus", null)
+                        .WithMany("CommandExecutionStatuses")
+                        .HasForeignKey("StepExecutionStatusUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionSummary", b =>
+                {
+                    b.HasOne("Ares.Datamodel.StepExecutionSummary", null)
+                        .WithMany("CommandSummaries")
+                        .HasForeignKey("StepExecutionSummaryUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandResult", b =>
+                {
+                    b.HasOne("Ares.Datamodel.CommandExecutionSummary", null)
+                        .WithOne("Result")
+                        .HasForeignKey("Ares.Datamodel.CommandResult", "CommandExecutionSummaryId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceCommandDescriptor", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Device.DeviceInfo", null)
+                        .WithMany("Commands")
+                        .HasForeignKey("DeviceInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceConfig", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Device.SerialConnection", "SerialInfo")
+                        .WithMany()
+                        .HasForeignKey("SerialInfoUniqueId");
+
+                    b.Navigation("SerialInfo");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExecutionInfo", b =>
+                {
+                    b.HasOne("Ares.Datamodel.CampaignExecutionSummary", null)
+                        .WithOne("ExecutionInfo")
+                        .HasForeignKey("Ares.Datamodel.ExecutionInfo", "CampaignExecutionSummaryId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.CommandExecutionSummary", null)
+                        .WithOne("ExecutionInfo")
+                        .HasForeignKey("Ares.Datamodel.ExecutionInfo", "CommandExecutionSummaryId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", null)
+                        .WithOne("ExecutionInfo")
+                        .HasForeignKey("Ares.Datamodel.ExecutionInfo", "ExperimentResultId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.StepExecutionSummary", null)
+                        .WithOne("ExecutionInfo")
+                        .HasForeignKey("Ares.Datamodel.ExecutionInfo", "StepExecutionSummaryId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentExecutionSummary", b =>
+                {
+                    b.HasOne("Ares.Datamodel.CampaignExecutionSummary", null)
+                        .WithMany("ExperimentSummaries")
+                        .HasForeignKey("CampaignExecutionSummaryUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentOverview", b =>
+                {
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", null)
+                        .WithOne("ExperimentOverview")
+                        .HasForeignKey("Ares.Datamodel.ExperimentOverview", "ExperimentResultId");
+
+                    b.HasOne("Ares.Datamodel.Templates.ExperimentTemplate", "Template")
+                        .WithMany()
+                        .HasForeignKey("TemplateUniqueId");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Limits", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.ParameterMetadata", null)
+                        .WithMany("Constraints")
+                        .HasForeignKey("ParameterMetadataUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.Planner", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Planning.PlannerServiceCapabilities", null)
+                        .WithMany("AvailablePlanners")
+                        .HasForeignKey("PlannerServiceCapabilitiesUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerAllocation", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithMany("PlannerAllocations")
+                        .HasForeignKey("CampaignTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Ares.Datamodel.Templates.ParameterMetadata", "Parameter")
+                        .WithMany()
+                        .HasForeignKey("ParameterUniqueId");
+
+                    b.HasOne("Ares.Datamodel.Planning.PlannerServiceInfo", "Planner")
+                        .WithMany()
+                        .HasForeignKey("PlannerId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.Navigation("Parameter");
+
+                    b.Navigation("Planner");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceCapabilities", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Planning.PlannerServiceInfo", null)
+                        .WithOne("Capabilities")
+                        .HasForeignKey("Ares.Datamodel.Planning.PlannerServiceCapabilities", "PlannerInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionSummary", b =>
+                {
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", null)
+                        .WithMany("StepSummaries")
+                        .HasForeignKey("ExperimentExecutionSummaryUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandMetadata", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.DeviceCommand", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("Ares.Datamodel.Templates.CommandMetadata", "DeviceCommandId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandTemplate", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.StepTemplate", null)
+                        .WithMany("CommandTemplates")
+                        .HasForeignKey("StepTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("Ares.Datamodel.Templates.CustomCommandInvocation", "CustomCommandInvocation", b1 =>
+                        {
+                            b1.Property<Guid>("CommandTemplateUniqueId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("CustomCommandId")
+                                .HasColumnType("text");
+
+                            b1.HasKey("CommandTemplateUniqueId");
+
+                            b1.ToTable("CommandTemplates");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CommandTemplateUniqueId");
+                        });
+
+                    b.OwnsOne("Ares.Datamodel.Templates.SystemCommand", "SystemCommand", b1 =>
+                        {
+                            b1.Property<Guid>("CommandTemplateUniqueId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<int>("Operation")
+                                .HasColumnType("integer");
+
+                            b1.HasKey("CommandTemplateUniqueId");
+
+                            b1.ToTable("CommandTemplates");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CommandTemplateUniqueId");
+                        });
+
+                    b.Navigation("CustomCommandInvocation");
+
+                    b.Navigation("SystemCommand");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.DeviceCommand", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CommandTemplate", null)
+                        .WithOne("DeviceCommand")
+                        .HasForeignKey("Ares.Datamodel.Templates.DeviceCommand", "CommandTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ExperimentTemplate", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithOne("CloseoutTemplate")
+                        .HasForeignKey("Ares.Datamodel.Templates.ExperimentTemplate", "CampaignCloseoutId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithOne("ExperimentTemplate")
+                        .HasForeignKey("Ares.Datamodel.Templates.ExperimentTemplate", "CampaignExperimentId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithOne("StartupTemplate")
+                        .HasForeignKey("Ares.Datamodel.Templates.ExperimentTemplate", "CampaignStartupId")
+                        .OnDelete(DeleteBehavior.NoAction);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.OutputMetadata", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CommandMetadata", null)
+                        .WithOne("OutputMetadata")
+                        .HasForeignKey("Ares.Datamodel.Templates.OutputMetadata", "UniqueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.Parameter", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CommandTemplate", null)
+                        .WithMany("ArgumentBindings")
+                        .HasForeignKey("CommandTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Ares.Datamodel.ExperimentOverview", null)
+                        .WithMany("Parameters")
+                        .HasForeignKey("ExperimentOverviewUniqueId");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ParameterMetadata", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithMany("PlannableParameters")
+                        .HasForeignKey("CampaignTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.Templates.CommandMetadata", null)
+                        .WithMany("ParameterMetadatas")
+                        .HasForeignKey("CommandMetadataUniqueId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.Templates.Parameter", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("Ares.Datamodel.Templates.ParameterMetadata", "ParameterId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.StepTemplate", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.ExperimentTemplate", null)
+                        .WithMany("StepTemplates")
+                        .HasForeignKey("ExperimentTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerInfo", b =>
+                {
+                    b.Navigation("Capabilities");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandVersion", b =>
+                {
+                    b.Navigation("InputParameters");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CampaignExecutionSummary", b =>
+                {
+                    b.Navigation("ExecutionInfo");
+
+                    b.Navigation("ExperimentSummaries");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionSummary", b =>
+                {
+                    b.Navigation("ExecutionInfo");
+
+                    b.Navigation("Result");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceInfo", b =>
+                {
+                    b.Navigation("Commands");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentExecutionSummary", b =>
+                {
+                    b.Navigation("ExecutionInfo");
+
+                    b.Navigation("ExperimentOverview");
+
+                    b.Navigation("StepSummaries");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentOverview", b =>
+                {
+                    b.Navigation("AnalysisOverview");
+
+                    b.Navigation("Parameters");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceCapabilities", b =>
+                {
+                    b.Navigation("AvailablePlanners");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceInfo", b =>
+                {
+                    b.Navigation("Capabilities");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionStatus", b =>
+                {
+                    b.Navigation("CommandExecutionStatuses");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionSummary", b =>
+                {
+                    b.Navigation("CommandSummaries");
+
+                    b.Navigation("ExecutionInfo");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CampaignTemplate", b =>
+                {
+                    b.Navigation("CloseoutTemplate");
+
+                    b.Navigation("ExperimentTemplate");
+
+                    b.Navigation("PlannableParameters");
+
+                    b.Navigation("PlannerAllocations");
+
+                    b.Navigation("StartupTemplate");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandMetadata", b =>
+                {
+                    b.Navigation("OutputMetadata");
+
+                    b.Navigation("ParameterMetadatas");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandTemplate", b =>
+                {
+                    b.Navigation("ArgumentBindings");
+
+                    b.Navigation("DeviceCommand");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.DeviceCommand", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ExperimentTemplate", b =>
+                {
+                    b.Navigation("StepTemplates");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.Parameter", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ParameterMetadata", b =>
+                {
+                    b.Navigation("Constraints");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.StepTemplate", b =>
+                {
+                    b.Navigation("CommandTemplates");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/AresService.Migrations.Postgres/Migrations/20260817202202_analyzer-upgrades_AresDbContext.cs b/AresService.Migrations.Postgres/Migrations/20260817202202_analyzer-upgrades_AresDbContext.cs
new file mode 100644
index 00000000..b82d1d3e
--- /dev/null
+++ b/AresService.Migrations.Postgres/Migrations/20260817202202_analyzer-upgrades_AresDbContext.cs
@@ -0,0 +1,96 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace AresService.Migrations.Postgres.Migrations.AresDb
+{
+  /// <inheritdoc />
+  public partial class analyzerupgrades_AresDbContext : Migration
+  {
+    /// <inheritdoc />
+    protected override void Up(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.AddColumn<string>(
+          name: "PlanObjectives",
+          table: "ExperimentTemplates",
+          type: "text",
+          nullable: true);
+
+      migrationBuilder.AddColumn<bool>(
+          name: "MultiObjectiveCapable",
+          table: "PlannerServiceCapabilities",
+          type: "boolean",
+          nullable: false,
+          defaultValue: false);
+
+      migrationBuilder.AddColumn<string>(
+          name: "AnalyzerResponse",
+          table: "AnalyzerTransactions",
+          type: "text",
+          nullable: false,
+          defaultValue: "{}");
+
+      migrationBuilder.AddColumn<string>(
+          name: "ObjectiveOutputSchema",
+          table: "AnalyzerCapabilities",
+          type: "text",
+          nullable: true);
+
+      migrationBuilder.AddColumn<string>(
+          name: "Objectives",
+          table: "AnalysisOverview",
+          type: "text",
+          nullable: false,
+          defaultValue: "[]");
+
+      migrationBuilder.CreateTable(
+          name: "AnalysisResponses",
+          columns: table => new
+          {
+            UniqueId = table.Column<Guid>(type: "uuid", nullable: false),
+            Objectives = table.Column<string>(type: "text", nullable: true),
+            AnalysisOutcome = table.Column<int>(type: "integer", nullable: false),
+            ErrorString = table.Column<string>(type: "text", nullable: true),
+            CreationTime = table.Column<DateTime>(type: "timestamp with time zone", nullable: false, defaultValueSql: "now()"),
+            LastModified = table.Column<DateTime>(type: "timestamp with time zone", nullable: false, defaultValueSql: "now()")
+          },
+          constraints: table =>
+          {
+            table.PrimaryKey("PK_AnalysisResponses", x => x.UniqueId);
+          });
+    }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.DropTable(
+          name: "AnalysisResponses");
+
+      migrationBuilder.DropColumn(
+          name: "MultiObjectiveCapable",
+          table: "PlannerServiceCapabilities");
+
+      migrationBuilder.DropColumn(
+          name: "PlanObjectives",
+          table: "ExperimentTemplates");
+
+      migrationBuilder.DropColumn(
+          name: "AnalyzerResponse",
+          table: "AnalyzerTransactions");
+
+      migrationBuilder.DropColumn(
+          name: "ObjectiveOutputSchema",
+          table: "AnalyzerCapabilities");
+
+      migrationBuilder.DropColumn(
+          name: "Objectives",
+          table: "AnalysisOverview");
+
+      migrationBuilder.AddColumn<string>(
+          name: "Objectives",
+          table: "Analyses",
+          type: "text",
+          nullable: true);
+    }
+  }
+}
\ No newline at end of file
diff --git a/AresService.Migrations.Postgres/Migrations/20260817202205_analyzer-upgrades_AresIdentityContext.Designer.cs b/AresService.Migrations.Postgres/Migrations/20260817202205_analyzer-upgrades_AresIdentityContext.Designer.cs
new file mode 100644
index 00000000..c0e629ac
--- /dev/null
+++ b/AresService.Migrations.Postgres/Migrations/20260817202205_analyzer-upgrades_AresIdentityContext.Designer.cs
@@ -0,0 +1,277 @@
+// <auto-generated />
+using System;
+using AresService.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace AresService.Migrations.Postgres.Migrations.AresIdentity
+{
+    [DbContext(typeof(AresIdentityContext))]
+    [Migration("20260817202205_analyzer-upgrades_AresIdentityContext")]
+    partial class analyzerupgrades_AresIdentityContext
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.10")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("AresService.Data.AresUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("AresService.Data.AresUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("AresService.Data.AresUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("AresService.Data.AresUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("AresService.Data.AresUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/AresService.Migrations.Postgres/Migrations/20260817202205_analyzer-upgrades_AresIdentityContext.cs b/AresService.Migrations.Postgres/Migrations/20260817202205_analyzer-upgrades_AresIdentityContext.cs
new file mode 100644
index 00000000..24f28aef
--- /dev/null
+++ b/AresService.Migrations.Postgres/Migrations/20260817202205_analyzer-upgrades_AresIdentityContext.cs
@@ -0,0 +1,22 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace AresService.Migrations.Postgres.Migrations.AresIdentity
+{
+    /// <inheritdoc />
+    public partial class analyzerupgrades_AresIdentityContext : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}
diff --git a/AresService.Migrations.Postgres/Migrations/AresDbContextModelSnapshot.cs b/AresService.Migrations.Postgres/Migrations/AresDbContextModelSnapshot.cs
index 94a25908..1f8b1ebb 100644
--- a/AresService.Migrations.Postgres/Migrations/AresDbContextModelSnapshot.cs
+++ b/AresService.Migrations.Postgres/Migrations/AresDbContextModelSnapshot.cs
@@ -44,6 +44,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("timestamp with time zone")
                         .HasDefaultValueSql("NOW()");
 
+                    b.Property<string>("Objectives")
+                        .HasColumnType("jsonb");
+
                     b.Property<double>("Result")
                         .HasColumnType("double precision");
 
@@ -85,6 +88,36 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Analyses", (string)null);
                 });
 
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalysisResponse", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AnalysisOutcome")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("ErrorString")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Objectives")
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalysisResponses", (string)null);
+                });
+
             modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerCapabilities", b =>
                 {
                     b.Property<Guid>("UniqueId")
@@ -104,6 +137,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("timestamp with time zone")
                         .HasDefaultValueSql("NOW()");
 
+                    b.Property<string>("ObjectiveOutputSchema")
+                        .HasColumnType("text");
+
                     b.Property<string>("SettingsSchema")
                         .HasColumnType("text");
 
@@ -226,6 +262,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("AnalyzerName")
                         .HasColumnType("text");
 
+                    b.Property<string>("AnalyzerResponse")
+                        .HasColumnType("jsonb");
+
                     b.Property<string>("AnalyzerType")
                         .HasColumnType("text");
 
@@ -1160,6 +1199,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("timestamp with time zone")
                         .HasDefaultValueSql("NOW()");
 
+                    b.Property<bool>("MultiObjectiveCapable")
+                        .HasColumnType("boolean");
+
                     b.Property<Guid>("PlannerInfoId")
                         .HasColumnType("uuid");
 
@@ -1530,6 +1572,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("Name")
                         .HasColumnType("text");
 
+                    b.Property<string>("PlanObjectives")
+                        .HasColumnType("text");
+
                     b.Property<bool>("Resolved")
                         .HasColumnType("boolean");
 
diff --git a/AresService.Migrations.SqlServer/Migrations/20260817202208_analyzer-upgrades_AresDbContext.Designer.cs b/AresService.Migrations.SqlServer/Migrations/20260817202208_analyzer-upgrades_AresDbContext.Designer.cs
new file mode 100644
index 00000000..dea33aee
--- /dev/null
+++ b/AresService.Migrations.SqlServer/Migrations/20260817202208_analyzer-upgrades_AresDbContext.Designer.cs
@@ -0,0 +1,2341 @@
+// <auto-generated />
+using System;
+using AresService.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace AresService.Migrations.SqlServer.Migrations.AresDb
+{
+    [DbContext(typeof(AresDbContext))]
+    [Migration("20260817202208_analyzer-upgrades_AresDbContext")]
+    partial class analyzerupgrades_AresDbContext
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.10")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("Ares.Datamodel.AnalysisOverview", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("AnalyzerInfo")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<Guid?>("ExperimentOverviewId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Objectives")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<double>("Result")
+                        .HasColumnType("float");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ExperimentOverviewId")
+                        .IsUnique()
+                        .HasFilter("[ExperimentOverviewId] IS NOT NULL");
+
+                    b.ToTable("AnalysisOverview");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.Analysis", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("AnalysisOutcome")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("ErrorString")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<float>("Result")
+                        .HasColumnType("real");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("Analyses", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalysisResponse", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("AnalysisOutcome")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("ErrorString")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Objectives")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalysisResponses", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerCapabilities", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AnalyzerInfoId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("ObjectiveOutputSchema")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SettingsSchema")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("TimeoutSeconds")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("AnalyzerInfoId")
+                        .IsUnique();
+
+                    b.ToTable("AnalyzerCapabilities");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("Analyzers", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalyzerInfos");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerSettings", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("AnalyzerId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Settings")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalyzerSettings");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerTransaction", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("AnalysisRequest")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AnalysisResponse")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AnalyzerId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AnalyzerName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AnalyzerResponse")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AnalyzerType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AnalyzerVersion")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime?>("TimeRequestSent")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("TimeResponseReceived")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalyzerTransactions");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.AresCampaignTag", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("TagName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("CampaignTags");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.AresGeneralSettingsConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("CommandLatency")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("CommandRetryLimit")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<bool>("DisplayCompatabilityWarnings")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("DisplayDataCollectionWidget")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("ExperimentRetryLimit")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("RetryCooldown")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AresGeneralSettingsConfig", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommand", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("CurrentVersionId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("CustomCommands", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandParameter", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<Guid>("CustomCommandVersionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Schema")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CustomCommandVersionId");
+
+                    b.ToTable("CustomCommandParameters", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandVersion", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<Guid>("CustomCommandId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OutputSchema")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ScriptBody")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("VersionNumber")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CustomCommandId", "VersionNumber")
+                        .IsUnique();
+
+                    b.ToTable("CustomCommandVersions", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CampaignExecutionSummary", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("CampaignId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CampaignName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CampaignNotes")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CampaignTags")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid?>("CloseoutExecutionSummaryUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<Guid?>("StartupExecutionSummaryUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CloseoutExecutionSummaryUniqueId");
+
+                    b.HasIndex("StartupExecutionSummaryUniqueId");
+
+                    b.ToTable("CampaignExecutionSummaries", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionStatus", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("CommandId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CommandName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("DeviceName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("StatusMessage")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid?>("StepExecutionStatusUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("VariableName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("StepExecutionStatusUniqueId");
+
+                    b.ToTable("CommandExecutionStatuses", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionSummary", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("CommandDescription")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CommandId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CommandName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<int>("StatusCode")
+                        .HasColumnType("int");
+
+                    b.Property<Guid?>("StepExecutionSummaryUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("TemplateId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("VarName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("StepExecutionSummaryUniqueId");
+
+                    b.ToTable("CommandExecutionSummaries", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandResult", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("AwaitUserInput")
+                        .HasColumnType("bit");
+
+                    b.Property<Guid?>("CommandExecutionSummaryId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StatusCode")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("Success")
+                        .HasColumnType("bit");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CommandExecutionSummaryId")
+                        .IsUnique()
+                        .HasFilter("[CommandExecutionSummaryId] IS NOT NULL");
+
+                    b.ToTable("DeviceCommandResults", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceCommandDescriptor", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("DeviceInfoId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InputSchema")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OutputSchema")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("DeviceInfoId");
+
+                    b.ToTable("DeviceCommandDescriptor");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeviceName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeviceSettings")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DriverId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsSimulated")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<Guid?>("SerialInfoUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("SerialInfoUniqueId");
+
+                    b.ToTable("DeviceConfigs", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SettingsSchema")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceInfos");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceLoggingSettings", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Deltas")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("IntervalMs")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<bool>("LoggingEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("LoggingType")
+                        .HasColumnType("int");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceLoggingSettings");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceSettings", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Settings")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceSettings");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceState", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime?>("Timestamp")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceStates");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.RemoteDeviceConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("RemoteDevices", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.SerialConnection", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("BaudRate")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("PortName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SerialId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("SerialConnection");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.DeviceErrorHandlingConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Code")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<int>("Handling")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("ErrorHandlingConfigs", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExecutionInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("CampaignExecutionSummaryId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("CommandExecutionSummaryId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<Guid?>("ExperimentResultId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("LocaltimeOffset")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid?>("StepExecutionSummaryId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("TimeFinished")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("TimeStarted")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Timezone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignExecutionSummaryId")
+                        .IsUnique()
+                        .HasFilter("[CampaignExecutionSummaryId] IS NOT NULL");
+
+                    b.HasIndex("CommandExecutionSummaryId")
+                        .IsUnique()
+                        .HasFilter("[CommandExecutionSummaryId] IS NOT NULL");
+
+                    b.HasIndex("ExperimentResultId")
+                        .IsUnique()
+                        .HasFilter("[ExperimentResultId] IS NOT NULL");
+
+                    b.HasIndex("StepExecutionSummaryId")
+                        .IsUnique()
+                        .HasFilter("[StepExecutionSummaryId] IS NOT NULL");
+
+                    b.ToTable("ExecutionInfos", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentExecutionSummary", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("CampaignExecutionSummaryUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("ExperimentId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("ResultOutputPath")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignExecutionSummaryUniqueId");
+
+                    b.ToTable("ExperimentExecutionSummaries", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentOverview", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<Guid?>("ExperimentResultId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid?>("TemplateUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ExperimentResultId")
+                        .IsUnique()
+                        .HasFilter("[ExperimentResultId] IS NOT NULL");
+
+                    b.HasIndex("TemplateUniqueId");
+
+                    b.ToTable("ExperimentOverviews", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Limits", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<double>("Maximum")
+                        .HasColumnType("float");
+
+                    b.Property<double>("Minimum")
+                        .HasColumnType("float");
+
+                    b.Property<Guid>("ParameterMetadataUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ParameterMetadataUniqueId");
+
+                    b.ToTable("Limits");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.Planner", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("PlannerName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid?>("PlannerServiceCapabilitiesUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("PlannerServiceCapabilitiesUniqueId");
+
+                    b.ToTable("Planner");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerAllocation", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CampaignTemplateUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<Guid?>("ParameterUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("PlannerId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignTemplateUniqueId");
+
+                    b.HasIndex("ParameterUniqueId");
+
+                    b.HasIndex("PlannerId");
+
+                    b.ToTable("PlannerAllocations", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("PlannerServices", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceCapabilities", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<bool>("MultiObjectiveCapable")
+                        .HasColumnType("bit");
+
+                    b.Property<Guid>("PlannerInfoId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ServiceName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SettingsSchema")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("TimeoutSeconds")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("PlannerInfoId")
+                        .IsUnique();
+
+                    b.ToTable("PlannerServiceCapabilities");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("PlannerInfos");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerSettings", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("PlannerId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Settings")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("PlannerSettings");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerTransaction", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("PlannerId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PlannerName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PlannerType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PlannerVersion")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PlanningRequest")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PlanningResponse")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("TimeRequestSent")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("TimeResponseReceived")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("PlannerTransactions");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Project", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("Projects", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionStatus", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("StepId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("StepName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("StepExecutionStatuses", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionSummary", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<Guid?>("ExperimentExecutionSummaryUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("StepId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ExperimentExecutionSummaryUniqueId");
+
+                    b.ToTable("StepExecutionSummaries", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CampaignTemplate", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("Name")
+                        .IsUnique()
+                        .HasFilter("[Name] IS NOT NULL");
+
+                    b.ToTable("CampaignTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandMetadata", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid?>("DeviceCommandId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeviceType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("DeviceCommandId")
+                        .IsUnique()
+                        .HasFilter("[DeviceCommandId] IS NOT NULL");
+
+                    b.ToTable("CommandMetadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandTemplate", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("OutputVarName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("StepTemplateUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("StepTemplateUniqueId");
+
+                    b.ToTable("CommandTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.DeviceCommand", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("CommandTemplateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CommandTemplateId")
+                        .IsUnique()
+                        .HasFilter("[CommandTemplateId] IS NOT NULL");
+
+                    b.ToTable("DeviceCommands", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ExperimentTemplate", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("AnalyzerId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AnalyzerMaps")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid?>("CampaignCloseoutId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("CampaignExperimentId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("CampaignStartupId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PlanObjectives")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Resolved")
+                        .HasColumnType("bit");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignCloseoutId")
+                        .IsUnique()
+                        .HasFilter("[CampaignCloseoutId] IS NOT NULL");
+
+                    b.HasIndex("CampaignExperimentId")
+                        .IsUnique()
+                        .HasFilter("[CampaignExperimentId] IS NOT NULL");
+
+                    b.HasIndex("CampaignStartupId")
+                        .IsUnique()
+                        .HasFilter("[CampaignStartupId] IS NOT NULL");
+
+                    b.ToTable("ExperimentTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.OutputMetadata", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("DataSchema")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("OutputMetadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.Parameter", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("CommandTemplateUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<Guid?>("ExperimentOverviewUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("SourceJson")
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("Source");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CommandTemplateUniqueId");
+
+                    b.HasIndex("ExperimentOverviewUniqueId");
+
+                    b.ToTable("Parameters", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ParameterMetadata", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("CampaignTemplateUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("CommandMetadataUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("InitialValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("NotPlannable")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("OutputName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid?>("ParameterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("PlannerDescription")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PlannerName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Schema")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Unit")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("UseDefault")
+                        .HasColumnType("bit");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignTemplateUniqueId");
+
+                    b.HasIndex("CommandMetadataUniqueId");
+
+                    b.HasIndex("ParameterId")
+                        .IsUnique()
+                        .HasFilter("[ParameterId] IS NOT NULL");
+
+                    b.ToTable("ParameterMetadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.StepTemplate", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<Guid?>("ExperimentTemplateUniqueId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsParallel")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ExperimentTemplateUniqueId");
+
+                    b.ToTable("StepTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Visualizing.Local.DeviceVisualizationConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ChartTitle")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<int>("GridH")
+                        .HasColumnType("int");
+
+                    b.Property<int>("GridW")
+                        .HasColumnType("int");
+
+                    b.Property<int>("GridX")
+                        .HasColumnType("int");
+
+                    b.Property<int>("GridY")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<int>("NumberDisplayPoints")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Paths")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("PollingRate")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("ShowDataLabels")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("ShowMarkers")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("Style")
+                        .HasColumnType("int");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceVisualizationConfigs");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Visualizing.Local.VisualizationPath", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("AssociatedDeviceId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<int>("DataType")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsPlottable")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("VisualizationPath");
+                });
+
+            modelBuilder.Entity("Ares.Services.DriverInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DriverId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long>("FileSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceDrivers");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.AnalysisOverview", b =>
+                {
+                    b.HasOne("Ares.Datamodel.ExperimentOverview", null)
+                        .WithOne("AnalysisOverview")
+                        .HasForeignKey("Ares.Datamodel.AnalysisOverview", "ExperimentOverviewId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerCapabilities", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Analyzing.AnalyzerInfo", null)
+                        .WithOne("Capabilities")
+                        .HasForeignKey("Ares.Datamodel.Analyzing.AnalyzerCapabilities", "AnalyzerInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandParameter", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Automation.CustomCommandVersion", null)
+                        .WithMany("InputParameters")
+                        .HasForeignKey("CustomCommandVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandVersion", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Automation.CustomCommand", null)
+                        .WithMany()
+                        .HasForeignKey("CustomCommandId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CampaignExecutionSummary", b =>
+                {
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", "CloseoutExecutionSummary")
+                        .WithMany()
+                        .HasForeignKey("CloseoutExecutionSummaryUniqueId");
+
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", "StartupExecutionSummary")
+                        .WithMany()
+                        .HasForeignKey("StartupExecutionSummaryUniqueId");
+
+                    b.Navigation("CloseoutExecutionSummary");
+
+                    b.Navigation("StartupExecutionSummary");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionStatus", b =>
+                {
+                    b.HasOne("Ares.Datamodel.StepExecutionStatus", null)
+                        .WithMany("CommandExecutionStatuses")
+                        .HasForeignKey("StepExecutionStatusUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionSummary", b =>
+                {
+                    b.HasOne("Ares.Datamodel.StepExecutionSummary", null)
+                        .WithMany("CommandSummaries")
+                        .HasForeignKey("StepExecutionSummaryUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandResult", b =>
+                {
+                    b.HasOne("Ares.Datamodel.CommandExecutionSummary", null)
+                        .WithOne("Result")
+                        .HasForeignKey("Ares.Datamodel.CommandResult", "CommandExecutionSummaryId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceCommandDescriptor", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Device.DeviceInfo", null)
+                        .WithMany("Commands")
+                        .HasForeignKey("DeviceInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceConfig", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Device.SerialConnection", "SerialInfo")
+                        .WithMany()
+                        .HasForeignKey("SerialInfoUniqueId");
+
+                    b.Navigation("SerialInfo");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExecutionInfo", b =>
+                {
+                    b.HasOne("Ares.Datamodel.CampaignExecutionSummary", null)
+                        .WithOne("ExecutionInfo")
+                        .HasForeignKey("Ares.Datamodel.ExecutionInfo", "CampaignExecutionSummaryId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.CommandExecutionSummary", null)
+                        .WithOne("ExecutionInfo")
+                        .HasForeignKey("Ares.Datamodel.ExecutionInfo", "CommandExecutionSummaryId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", null)
+                        .WithOne("ExecutionInfo")
+                        .HasForeignKey("Ares.Datamodel.ExecutionInfo", "ExperimentResultId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.StepExecutionSummary", null)
+                        .WithOne("ExecutionInfo")
+                        .HasForeignKey("Ares.Datamodel.ExecutionInfo", "StepExecutionSummaryId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentExecutionSummary", b =>
+                {
+                    b.HasOne("Ares.Datamodel.CampaignExecutionSummary", null)
+                        .WithMany("ExperimentSummaries")
+                        .HasForeignKey("CampaignExecutionSummaryUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentOverview", b =>
+                {
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", null)
+                        .WithOne("ExperimentOverview")
+                        .HasForeignKey("Ares.Datamodel.ExperimentOverview", "ExperimentResultId");
+
+                    b.HasOne("Ares.Datamodel.Templates.ExperimentTemplate", "Template")
+                        .WithMany()
+                        .HasForeignKey("TemplateUniqueId");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Limits", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.ParameterMetadata", null)
+                        .WithMany("Constraints")
+                        .HasForeignKey("ParameterMetadataUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.Planner", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Planning.PlannerServiceCapabilities", null)
+                        .WithMany("AvailablePlanners")
+                        .HasForeignKey("PlannerServiceCapabilitiesUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerAllocation", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithMany("PlannerAllocations")
+                        .HasForeignKey("CampaignTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Ares.Datamodel.Templates.ParameterMetadata", "Parameter")
+                        .WithMany()
+                        .HasForeignKey("ParameterUniqueId");
+
+                    b.HasOne("Ares.Datamodel.Planning.PlannerServiceInfo", "Planner")
+                        .WithMany()
+                        .HasForeignKey("PlannerId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.Navigation("Parameter");
+
+                    b.Navigation("Planner");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceCapabilities", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Planning.PlannerServiceInfo", null)
+                        .WithOne("Capabilities")
+                        .HasForeignKey("Ares.Datamodel.Planning.PlannerServiceCapabilities", "PlannerInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionSummary", b =>
+                {
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", null)
+                        .WithMany("StepSummaries")
+                        .HasForeignKey("ExperimentExecutionSummaryUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandMetadata", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.DeviceCommand", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("Ares.Datamodel.Templates.CommandMetadata", "DeviceCommandId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandTemplate", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.StepTemplate", null)
+                        .WithMany("CommandTemplates")
+                        .HasForeignKey("StepTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("Ares.Datamodel.Templates.CustomCommandInvocation", "CustomCommandInvocation", b1 =>
+                        {
+                            b1.Property<Guid>("CommandTemplateUniqueId")
+                                .HasColumnType("uniqueidentifier");
+
+                            b1.Property<string>("CustomCommandId")
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.HasKey("CommandTemplateUniqueId");
+
+                            b1.ToTable("CommandTemplates");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CommandTemplateUniqueId");
+                        });
+
+                    b.OwnsOne("Ares.Datamodel.Templates.SystemCommand", "SystemCommand", b1 =>
+                        {
+                            b1.Property<Guid>("CommandTemplateUniqueId")
+                                .HasColumnType("uniqueidentifier");
+
+                            b1.Property<int>("Operation")
+                                .HasColumnType("int");
+
+                            b1.HasKey("CommandTemplateUniqueId");
+
+                            b1.ToTable("CommandTemplates");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CommandTemplateUniqueId");
+                        });
+
+                    b.Navigation("CustomCommandInvocation");
+
+                    b.Navigation("SystemCommand");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.DeviceCommand", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CommandTemplate", null)
+                        .WithOne("DeviceCommand")
+                        .HasForeignKey("Ares.Datamodel.Templates.DeviceCommand", "CommandTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ExperimentTemplate", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithOne("CloseoutTemplate")
+                        .HasForeignKey("Ares.Datamodel.Templates.ExperimentTemplate", "CampaignCloseoutId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithOne("ExperimentTemplate")
+                        .HasForeignKey("Ares.Datamodel.Templates.ExperimentTemplate", "CampaignExperimentId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithOne("StartupTemplate")
+                        .HasForeignKey("Ares.Datamodel.Templates.ExperimentTemplate", "CampaignStartupId")
+                        .OnDelete(DeleteBehavior.NoAction);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.OutputMetadata", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CommandMetadata", null)
+                        .WithOne("OutputMetadata")
+                        .HasForeignKey("Ares.Datamodel.Templates.OutputMetadata", "UniqueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.Parameter", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CommandTemplate", null)
+                        .WithMany("ArgumentBindings")
+                        .HasForeignKey("CommandTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Ares.Datamodel.ExperimentOverview", null)
+                        .WithMany("Parameters")
+                        .HasForeignKey("ExperimentOverviewUniqueId");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ParameterMetadata", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithMany("PlannableParameters")
+                        .HasForeignKey("CampaignTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.Templates.CommandMetadata", null)
+                        .WithMany("ParameterMetadatas")
+                        .HasForeignKey("CommandMetadataUniqueId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.Templates.Parameter", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("Ares.Datamodel.Templates.ParameterMetadata", "ParameterId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.StepTemplate", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.ExperimentTemplate", null)
+                        .WithMany("StepTemplates")
+                        .HasForeignKey("ExperimentTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerInfo", b =>
+                {
+                    b.Navigation("Capabilities");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandVersion", b =>
+                {
+                    b.Navigation("InputParameters");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CampaignExecutionSummary", b =>
+                {
+                    b.Navigation("ExecutionInfo");
+
+                    b.Navigation("ExperimentSummaries");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionSummary", b =>
+                {
+                    b.Navigation("ExecutionInfo");
+
+                    b.Navigation("Result");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceInfo", b =>
+                {
+                    b.Navigation("Commands");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentExecutionSummary", b =>
+                {
+                    b.Navigation("ExecutionInfo");
+
+                    b.Navigation("ExperimentOverview");
+
+                    b.Navigation("StepSummaries");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentOverview", b =>
+                {
+                    b.Navigation("AnalysisOverview");
+
+                    b.Navigation("Parameters");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceCapabilities", b =>
+                {
+                    b.Navigation("AvailablePlanners");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceInfo", b =>
+                {
+                    b.Navigation("Capabilities");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionStatus", b =>
+                {
+                    b.Navigation("CommandExecutionStatuses");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionSummary", b =>
+                {
+                    b.Navigation("CommandSummaries");
+
+                    b.Navigation("ExecutionInfo");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CampaignTemplate", b =>
+                {
+                    b.Navigation("CloseoutTemplate");
+
+                    b.Navigation("ExperimentTemplate");
+
+                    b.Navigation("PlannableParameters");
+
+                    b.Navigation("PlannerAllocations");
+
+                    b.Navigation("StartupTemplate");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandMetadata", b =>
+                {
+                    b.Navigation("OutputMetadata");
+
+                    b.Navigation("ParameterMetadatas");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandTemplate", b =>
+                {
+                    b.Navigation("ArgumentBindings");
+
+                    b.Navigation("DeviceCommand");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.DeviceCommand", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ExperimentTemplate", b =>
+                {
+                    b.Navigation("StepTemplates");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.Parameter", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ParameterMetadata", b =>
+                {
+                    b.Navigation("Constraints");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.StepTemplate", b =>
+                {
+                    b.Navigation("CommandTemplates");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/AresService.Migrations.SqlServer/Migrations/20260817202208_analyzer-upgrades_AresDbContext.cs b/AresService.Migrations.SqlServer/Migrations/20260817202208_analyzer-upgrades_AresDbContext.cs
new file mode 100644
index 00000000..66bd44cf
--- /dev/null
+++ b/AresService.Migrations.SqlServer/Migrations/20260817202208_analyzer-upgrades_AresDbContext.cs
@@ -0,0 +1,96 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace AresService.Migrations.SqlServer.Migrations.AresDb
+{
+  /// <inheritdoc />
+  public partial class analyzerupgrades_AresDbContext : Migration
+  {
+    /// <inheritdoc />
+    protected override void Up(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.AddColumn<string>(
+          name: "PlanObjectives",
+          table: "ExperimentTemplates",
+          type: "nvarchar(max)",
+          nullable: true);
+
+      migrationBuilder.AddColumn<bool>(
+          name: "MultiObjectiveCapable",
+          table: "PlannerServiceCapabilities",
+          type: "bit",
+          nullable: false,
+          defaultValue: false);
+
+      migrationBuilder.AddColumn<string>(
+          name: "AnalyzerResponse",
+          table: "AnalyzerTransactions",
+          type: "nvarchar(max)",
+          nullable: false,
+          defaultValue: "{}");
+
+      migrationBuilder.AddColumn<string>(
+          name: "ObjectiveOutputSchema",
+          table: "AnalyzerCapabilities",
+          type: "nvarchar(max)",
+          nullable: true);
+
+      migrationBuilder.AddColumn<string>(
+          name: "Objectives",
+          table: "AnalysisOverview",
+          type: "nvarchar(max)",
+          nullable: false,
+          defaultValue: "[]");
+
+      migrationBuilder.CreateTable(
+          name: "AnalysisResponses",
+          columns: table => new
+          {
+            UniqueId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+            Objectives = table.Column<string>(type: "nvarchar(max)", nullable: true),
+            AnalysisOutcome = table.Column<int>(type: "int", nullable: false),
+            ErrorString = table.Column<string>(type: "nvarchar(max)", nullable: true),
+            CreationTime = table.Column<DateTime>(type: "datetime2", nullable: false, defaultValueSql: "GETUTCDATE()"),
+            LastModified = table.Column<DateTime>(type: "datetime2", nullable: false, defaultValueSql: "GETUTCDATE()")
+          },
+          constraints: table =>
+          {
+            table.PrimaryKey("PK_AnalysisResponses", x => x.UniqueId);
+          });
+    }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.DropTable(
+          name: "AnalysisResponses");
+
+      migrationBuilder.DropColumn(
+          name: "MultiObjectiveCapable",
+          table: "PlannerServiceCapabilities");
+
+      migrationBuilder.DropColumn(
+          name: "PlanObjectives",
+          table: "ExperimentTemplates");
+
+      migrationBuilder.DropColumn(
+          name: "AnalyzerResponse",
+          table: "AnalyzerTransactions");
+
+      migrationBuilder.DropColumn(
+          name: "ObjectiveOutputSchema",
+          table: "AnalyzerCapabilities");
+
+      migrationBuilder.DropColumn(
+          name: "Objectives",
+          table: "AnalysisOverview");
+
+      migrationBuilder.AddColumn<string>(
+          name: "Objectives",
+          table: "Analyses",
+          type: "nvarchar(max)",
+          nullable: true);
+    }
+  }
+}
\ No newline at end of file
diff --git a/AresService.Migrations.SqlServer/Migrations/20260817202211_analyzer-upgrades_AresIdentityContext.Designer.cs b/AresService.Migrations.SqlServer/Migrations/20260817202211_analyzer-upgrades_AresIdentityContext.Designer.cs
new file mode 100644
index 00000000..5eb0ffc9
--- /dev/null
+++ b/AresService.Migrations.SqlServer/Migrations/20260817202211_analyzer-upgrades_AresIdentityContext.Designer.cs
@@ -0,0 +1,279 @@
+// <auto-generated />
+using System;
+using AresService.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace AresService.Migrations.SqlServer.Migrations.AresIdentity
+{
+    [DbContext(typeof(AresIdentityContext))]
+    [Migration("20260817202211_analyzer-upgrades_AresIdentityContext")]
+    partial class analyzerupgrades_AresIdentityContext
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.10")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("AresService.Data.AresUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("AresService.Data.AresUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("AresService.Data.AresUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("AresService.Data.AresUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("AresService.Data.AresUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/AresService.Migrations.SqlServer/Migrations/20260817202211_analyzer-upgrades_AresIdentityContext.cs b/AresService.Migrations.SqlServer/Migrations/20260817202211_analyzer-upgrades_AresIdentityContext.cs
new file mode 100644
index 00000000..8e57236d
--- /dev/null
+++ b/AresService.Migrations.SqlServer/Migrations/20260817202211_analyzer-upgrades_AresIdentityContext.cs
@@ -0,0 +1,22 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace AresService.Migrations.SqlServer.Migrations.AresIdentity
+{
+    /// <inheritdoc />
+    public partial class analyzerupgrades_AresIdentityContext : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}
diff --git a/AresService.Migrations.SqlServer/Migrations/AresDbContextModelSnapshot.cs b/AresService.Migrations.SqlServer/Migrations/AresDbContextModelSnapshot.cs
index 1744d62a..11e62a2b 100644
--- a/AresService.Migrations.SqlServer/Migrations/AresDbContextModelSnapshot.cs
+++ b/AresService.Migrations.SqlServer/Migrations/AresDbContextModelSnapshot.cs
@@ -44,6 +44,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("datetime2")
                         .HasDefaultValueSql("getdate()");
 
+                    b.Property<string>("Objectives")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<double>("Result")
                         .HasColumnType("float");
 
@@ -86,6 +89,36 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Analyses", (string)null);
                 });
 
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalysisResponse", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("AnalysisOutcome")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("ErrorString")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("getdate()");
+
+                    b.Property<string>("Objectives")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalysisResponses", (string)null);
+                });
+
             modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerCapabilities", b =>
                 {
                     b.Property<Guid>("UniqueId")
@@ -105,6 +138,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("datetime2")
                         .HasDefaultValueSql("getdate()");
 
+                    b.Property<string>("ObjectiveOutputSchema")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<string>("SettingsSchema")
                         .HasColumnType("nvarchar(max)");
 
@@ -227,6 +263,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("AnalyzerName")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<string>("AnalyzerResponse")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<string>("AnalyzerType")
                         .HasColumnType("nvarchar(max)");
 
@@ -1167,6 +1206,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("datetime2")
                         .HasDefaultValueSql("getdate()");
 
+                    b.Property<bool>("MultiObjectiveCapable")
+                        .HasColumnType("bit");
+
                     b.Property<Guid>("PlannerInfoId")
                         .HasColumnType("uniqueidentifier");
 
@@ -1540,6 +1582,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("Name")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<string>("PlanObjectives")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<bool>("Resolved")
                         .HasColumnType("bit");
 
diff --git a/AresService.Migrations.Sqlite/Migrations/20260817202156_analyzer-upgrades_AresDbContext.Designer.cs b/AresService.Migrations.Sqlite/Migrations/20260817202156_analyzer-upgrades_AresDbContext.Designer.cs
new file mode 100644
index 00000000..1c5941bd
--- /dev/null
+++ b/AresService.Migrations.Sqlite/Migrations/20260817202156_analyzer-upgrades_AresDbContext.Designer.cs
@@ -0,0 +1,2322 @@
+// <auto-generated />
+using System;
+using AresService.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace AresService.Migrations.Sqlite.Migrations.AresDb
+{
+    [DbContext(typeof(AresDbContext))]
+    [Migration("20260817202156_analyzer-upgrades_AresDbContext")]
+    partial class analyzerupgrades_AresDbContext
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.10");
+
+            modelBuilder.Entity("Ares.Datamodel.AnalysisOverview", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AnalyzerInfo")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<Guid?>("ExperimentOverviewId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Objectives")
+                        .HasColumnType("TEXT");
+
+                    b.Property<double>("Result")
+                        .HasColumnType("REAL");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ExperimentOverviewId")
+                        .IsUnique();
+
+                    b.ToTable("AnalysisOverview");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.Analysis", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AnalysisOutcome")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("ErrorString")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<float>("Result")
+                        .HasColumnType("REAL");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("Analyses", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalysisResponse", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AnalysisOutcome")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("ErrorString")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Objectives")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalysisResponses", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerCapabilities", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AnalyzerInfoId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("ObjectiveOutputSchema")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SettingsSchema")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("TimeoutSeconds")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("AnalyzerInfoId")
+                        .IsUnique();
+
+                    b.ToTable("AnalyzerCapabilities");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("Analyzers", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalyzerInfos");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerSettings", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AnalyzerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Settings")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalyzerSettings");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerTransaction", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AnalysisRequest")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AnalysisResponse")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AnalyzerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AnalyzerName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AnalyzerResponse")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AnalyzerType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AnalyzerVersion")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime?>("TimeRequestSent")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("TimeResponseReceived")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalyzerTransactions");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.AresCampaignTag", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("TagName")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("CampaignTags");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.AresGeneralSettingsConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CommandLatency")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("CommandRetryLimit")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<bool>("DisplayCompatabilityWarnings")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("DisplayDataCollectionWidget")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("ExperimentRetryLimit")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("RetryCooldown")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AresGeneralSettingsConfig", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommand", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("CurrentVersionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("CustomCommands", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandParameter", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<Guid>("CustomCommandVersionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Schema")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CustomCommandVersionId");
+
+                    b.ToTable("CustomCommandParameters", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandVersion", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<Guid>("CustomCommandId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OutputSchema")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ScriptBody")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("VersionNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CustomCommandId", "VersionNumber")
+                        .IsUnique();
+
+                    b.ToTable("CustomCommandVersions", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CampaignExecutionSummary", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CampaignId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CampaignName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CampaignNotes")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CampaignTags")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CloseoutExecutionSummaryUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<Guid?>("StartupExecutionSummaryUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CloseoutExecutionSummaryUniqueId");
+
+                    b.HasIndex("StartupExecutionSummaryUniqueId");
+
+                    b.ToTable("CampaignExecutionSummaries", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionStatus", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CommandId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CommandName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("DeviceName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("StatusMessage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("StepExecutionStatusUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("VariableName")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("StepExecutionStatusUniqueId");
+
+                    b.ToTable("CommandExecutionStatuses", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionSummary", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CommandDescription")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CommandId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CommandName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<int>("StatusCode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("StepExecutionSummaryUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TemplateId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("VarName")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("StepExecutionSummaryUniqueId");
+
+                    b.ToTable("CommandExecutionSummaries", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandResult", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("AwaitUserInput")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("CommandExecutionSummaryId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("StatusCode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("Success")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CommandExecutionSummaryId")
+                        .IsUnique();
+
+                    b.ToTable("DeviceCommandResults", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceCommandDescriptor", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("DeviceInfoId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("InputSchema")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OutputSchema")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("DeviceInfoId");
+
+                    b.ToTable("DeviceCommandDescriptor");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceSettings")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DriverId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsSimulated")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<Guid?>("SerialInfoUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("SerialInfoUniqueId");
+
+                    b.ToTable("DeviceConfigs", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SettingsSchema")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceInfos");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceLoggingSettings", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Deltas")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("IntervalMs")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<bool>("LoggingEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LoggingType")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceLoggingSettings");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceSettings", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Settings")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceSettings");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceState", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime?>("Timestamp")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceStates");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.RemoteDeviceConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("RemoteDevices", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.SerialConnection", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("BaudRate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("PortName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SerialId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("SerialConnection");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.DeviceErrorHandlingConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Code")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<int>("Handling")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("ErrorHandlingConfigs", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExecutionInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CampaignExecutionSummaryId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CommandExecutionSummaryId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<Guid?>("ExperimentResultId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("LocaltimeOffset")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("StepExecutionSummaryId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("TimeFinished")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("TimeStarted")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Timezone")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignExecutionSummaryId")
+                        .IsUnique();
+
+                    b.HasIndex("CommandExecutionSummaryId")
+                        .IsUnique();
+
+                    b.HasIndex("ExperimentResultId")
+                        .IsUnique();
+
+                    b.HasIndex("StepExecutionSummaryId")
+                        .IsUnique();
+
+                    b.ToTable("ExecutionInfos", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentExecutionSummary", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CampaignExecutionSummaryUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("ExperimentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("ResultOutputPath")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignExecutionSummaryUniqueId");
+
+                    b.ToTable("ExperimentExecutionSummaries", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentOverview", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<Guid?>("ExperimentResultId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("TemplateUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ExperimentResultId")
+                        .IsUnique();
+
+                    b.HasIndex("TemplateUniqueId");
+
+                    b.ToTable("ExperimentOverviews", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Limits", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<double>("Maximum")
+                        .HasColumnType("REAL");
+
+                    b.Property<double>("Minimum")
+                        .HasColumnType("REAL");
+
+                    b.Property<Guid>("ParameterMetadataUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ParameterMetadataUniqueId");
+
+                    b.ToTable("Limits");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.Planner", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("PlannerName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("PlannerServiceCapabilitiesUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("PlannerServiceCapabilitiesUniqueId");
+
+                    b.ToTable("Planner");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerAllocation", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("CampaignTemplateUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<Guid?>("ParameterUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("PlannerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignTemplateUniqueId");
+
+                    b.HasIndex("ParameterUniqueId");
+
+                    b.HasIndex("PlannerId");
+
+                    b.ToTable("PlannerAllocations", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("PlannerServices", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceCapabilities", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<bool>("MultiObjectiveCapable")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("PlannerInfoId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ServiceName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SettingsSchema")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("TimeoutSeconds")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("PlannerInfoId")
+                        .IsUnique();
+
+                    b.ToTable("PlannerServiceCapabilities");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("PlannerInfos");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerSettings", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("PlannerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Settings")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("PlannerSettings");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerTransaction", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("PlannerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlannerName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlannerType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlannerVersion")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlanningRequest")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlanningResponse")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("TimeRequestSent")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("TimeResponseReceived")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("PlannerTransactions");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Project", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("Projects", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionStatus", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("StepId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("StepName")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("StepExecutionStatuses", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionSummary", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<Guid?>("ExperimentExecutionSummaryUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("StepId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ExperimentExecutionSummaryUniqueId");
+
+                    b.ToTable("StepExecutionSummaries", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CampaignTemplate", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("CampaignTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandMetadata", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("DeviceCommandId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("DeviceCommandId")
+                        .IsUnique();
+
+                    b.ToTable("CommandMetadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandTemplate", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("OutputVarName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("StepTemplateUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("StepTemplateUniqueId");
+
+                    b.ToTable("CommandTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.DeviceCommand", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CommandTemplateId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CommandTemplateId")
+                        .IsUnique();
+
+                    b.ToTable("DeviceCommands", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ExperimentTemplate", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AnalyzerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AnalyzerMaps")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CampaignCloseoutId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CampaignExperimentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CampaignStartupId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlanObjectives")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Resolved")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignCloseoutId")
+                        .IsUnique();
+
+                    b.HasIndex("CampaignExperimentId")
+                        .IsUnique();
+
+                    b.HasIndex("CampaignStartupId")
+                        .IsUnique();
+
+                    b.ToTable("ExperimentTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.OutputMetadata", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("DataSchema")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("OutputMetadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.Parameter", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CommandTemplateUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<Guid?>("ExperimentOverviewUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("SourceJson")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("Source");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CommandTemplateUniqueId");
+
+                    b.HasIndex("ExperimentOverviewUniqueId");
+
+                    b.ToTable("Parameters", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ParameterMetadata", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CampaignTemplateUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("CommandMetadataUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("InitialValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("NotPlannable")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OutputName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ParameterId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlannerDescription")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlannerName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Schema")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Unit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("UseDefault")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("CampaignTemplateUniqueId");
+
+                    b.HasIndex("CommandMetadataUniqueId");
+
+                    b.HasIndex("ParameterId")
+                        .IsUnique();
+
+                    b.ToTable("ParameterMetadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.StepTemplate", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<Guid?>("ExperimentTemplateUniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsParallel")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.HasIndex("ExperimentTemplateUniqueId");
+
+                    b.ToTable("StepTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Visualizing.Local.DeviceVisualizationConfig", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ChartTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<int>("GridH")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("GridW")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("GridX")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("GridY")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<int>("NumberDisplayPoints")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Paths")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PollingRate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowDataLabels")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowMarkers")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Style")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceVisualizationConfigs");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Visualizing.Local.VisualizationPath", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AssociatedDeviceId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<int>("DataType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsPlottable")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("VisualizationPath");
+                });
+
+            modelBuilder.Entity("Ares.Services.DriverInfo", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DriverId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("FileSizeBytes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("DeviceDrivers");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.AnalysisOverview", b =>
+                {
+                    b.HasOne("Ares.Datamodel.ExperimentOverview", null)
+                        .WithOne("AnalysisOverview")
+                        .HasForeignKey("Ares.Datamodel.AnalysisOverview", "ExperimentOverviewId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerCapabilities", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Analyzing.AnalyzerInfo", null)
+                        .WithOne("Capabilities")
+                        .HasForeignKey("Ares.Datamodel.Analyzing.AnalyzerCapabilities", "AnalyzerInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandParameter", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Automation.CustomCommandVersion", null)
+                        .WithMany("InputParameters")
+                        .HasForeignKey("CustomCommandVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandVersion", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Automation.CustomCommand", null)
+                        .WithMany()
+                        .HasForeignKey("CustomCommandId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CampaignExecutionSummary", b =>
+                {
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", "CloseoutExecutionSummary")
+                        .WithMany()
+                        .HasForeignKey("CloseoutExecutionSummaryUniqueId");
+
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", "StartupExecutionSummary")
+                        .WithMany()
+                        .HasForeignKey("StartupExecutionSummaryUniqueId");
+
+                    b.Navigation("CloseoutExecutionSummary");
+
+                    b.Navigation("StartupExecutionSummary");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionStatus", b =>
+                {
+                    b.HasOne("Ares.Datamodel.StepExecutionStatus", null)
+                        .WithMany("CommandExecutionStatuses")
+                        .HasForeignKey("StepExecutionStatusUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionSummary", b =>
+                {
+                    b.HasOne("Ares.Datamodel.StepExecutionSummary", null)
+                        .WithMany("CommandSummaries")
+                        .HasForeignKey("StepExecutionSummaryUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandResult", b =>
+                {
+                    b.HasOne("Ares.Datamodel.CommandExecutionSummary", null)
+                        .WithOne("Result")
+                        .HasForeignKey("Ares.Datamodel.CommandResult", "CommandExecutionSummaryId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceCommandDescriptor", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Device.DeviceInfo", null)
+                        .WithMany("Commands")
+                        .HasForeignKey("DeviceInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceConfig", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Device.SerialConnection", "SerialInfo")
+                        .WithMany()
+                        .HasForeignKey("SerialInfoUniqueId");
+
+                    b.Navigation("SerialInfo");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExecutionInfo", b =>
+                {
+                    b.HasOne("Ares.Datamodel.CampaignExecutionSummary", null)
+                        .WithOne("ExecutionInfo")
+                        .HasForeignKey("Ares.Datamodel.ExecutionInfo", "CampaignExecutionSummaryId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.CommandExecutionSummary", null)
+                        .WithOne("ExecutionInfo")
+                        .HasForeignKey("Ares.Datamodel.ExecutionInfo", "CommandExecutionSummaryId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", null)
+                        .WithOne("ExecutionInfo")
+                        .HasForeignKey("Ares.Datamodel.ExecutionInfo", "ExperimentResultId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.StepExecutionSummary", null)
+                        .WithOne("ExecutionInfo")
+                        .HasForeignKey("Ares.Datamodel.ExecutionInfo", "StepExecutionSummaryId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentExecutionSummary", b =>
+                {
+                    b.HasOne("Ares.Datamodel.CampaignExecutionSummary", null)
+                        .WithMany("ExperimentSummaries")
+                        .HasForeignKey("CampaignExecutionSummaryUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentOverview", b =>
+                {
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", null)
+                        .WithOne("ExperimentOverview")
+                        .HasForeignKey("Ares.Datamodel.ExperimentOverview", "ExperimentResultId");
+
+                    b.HasOne("Ares.Datamodel.Templates.ExperimentTemplate", "Template")
+                        .WithMany()
+                        .HasForeignKey("TemplateUniqueId");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Limits", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.ParameterMetadata", null)
+                        .WithMany("Constraints")
+                        .HasForeignKey("ParameterMetadataUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.Planner", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Planning.PlannerServiceCapabilities", null)
+                        .WithMany("AvailablePlanners")
+                        .HasForeignKey("PlannerServiceCapabilitiesUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerAllocation", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithMany("PlannerAllocations")
+                        .HasForeignKey("CampaignTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Ares.Datamodel.Templates.ParameterMetadata", "Parameter")
+                        .WithMany()
+                        .HasForeignKey("ParameterUniqueId");
+
+                    b.HasOne("Ares.Datamodel.Planning.PlannerServiceInfo", "Planner")
+                        .WithMany()
+                        .HasForeignKey("PlannerId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.Navigation("Parameter");
+
+                    b.Navigation("Planner");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceCapabilities", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Planning.PlannerServiceInfo", null)
+                        .WithOne("Capabilities")
+                        .HasForeignKey("Ares.Datamodel.Planning.PlannerServiceCapabilities", "PlannerInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionSummary", b =>
+                {
+                    b.HasOne("Ares.Datamodel.ExperimentExecutionSummary", null)
+                        .WithMany("StepSummaries")
+                        .HasForeignKey("ExperimentExecutionSummaryUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandMetadata", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.DeviceCommand", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("Ares.Datamodel.Templates.CommandMetadata", "DeviceCommandId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandTemplate", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.StepTemplate", null)
+                        .WithMany("CommandTemplates")
+                        .HasForeignKey("StepTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("Ares.Datamodel.Templates.CustomCommandInvocation", "CustomCommandInvocation", b1 =>
+                        {
+                            b1.Property<Guid>("CommandTemplateUniqueId")
+                                .HasColumnType("TEXT");
+
+                            b1.Property<string>("CustomCommandId")
+                                .HasColumnType("TEXT");
+
+                            b1.HasKey("CommandTemplateUniqueId");
+
+                            b1.ToTable("CommandTemplates");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CommandTemplateUniqueId");
+                        });
+
+                    b.OwnsOne("Ares.Datamodel.Templates.SystemCommand", "SystemCommand", b1 =>
+                        {
+                            b1.Property<Guid>("CommandTemplateUniqueId")
+                                .HasColumnType("TEXT");
+
+                            b1.Property<int>("Operation")
+                                .HasColumnType("INTEGER");
+
+                            b1.HasKey("CommandTemplateUniqueId");
+
+                            b1.ToTable("CommandTemplates");
+
+                            b1.WithOwner()
+                                .HasForeignKey("CommandTemplateUniqueId");
+                        });
+
+                    b.Navigation("CustomCommandInvocation");
+
+                    b.Navigation("SystemCommand");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.DeviceCommand", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CommandTemplate", null)
+                        .WithOne("DeviceCommand")
+                        .HasForeignKey("Ares.Datamodel.Templates.DeviceCommand", "CommandTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ExperimentTemplate", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithOne("CloseoutTemplate")
+                        .HasForeignKey("Ares.Datamodel.Templates.ExperimentTemplate", "CampaignCloseoutId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithOne("ExperimentTemplate")
+                        .HasForeignKey("Ares.Datamodel.Templates.ExperimentTemplate", "CampaignExperimentId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithOne("StartupTemplate")
+                        .HasForeignKey("Ares.Datamodel.Templates.ExperimentTemplate", "CampaignStartupId")
+                        .OnDelete(DeleteBehavior.NoAction);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.OutputMetadata", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CommandMetadata", null)
+                        .WithOne("OutputMetadata")
+                        .HasForeignKey("Ares.Datamodel.Templates.OutputMetadata", "UniqueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.Parameter", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CommandTemplate", null)
+                        .WithMany("ArgumentBindings")
+                        .HasForeignKey("CommandTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Ares.Datamodel.ExperimentOverview", null)
+                        .WithMany("Parameters")
+                        .HasForeignKey("ExperimentOverviewUniqueId");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ParameterMetadata", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.CampaignTemplate", null)
+                        .WithMany("PlannableParameters")
+                        .HasForeignKey("CampaignTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.Templates.CommandMetadata", null)
+                        .WithMany("ParameterMetadatas")
+                        .HasForeignKey("CommandMetadataUniqueId")
+                        .OnDelete(DeleteBehavior.ClientCascade);
+
+                    b.HasOne("Ares.Datamodel.Templates.Parameter", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("Ares.Datamodel.Templates.ParameterMetadata", "ParameterId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.StepTemplate", b =>
+                {
+                    b.HasOne("Ares.Datamodel.Templates.ExperimentTemplate", null)
+                        .WithMany("StepTemplates")
+                        .HasForeignKey("ExperimentTemplateUniqueId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerInfo", b =>
+                {
+                    b.Navigation("Capabilities");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Automation.CustomCommandVersion", b =>
+                {
+                    b.Navigation("InputParameters");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CampaignExecutionSummary", b =>
+                {
+                    b.Navigation("ExecutionInfo");
+
+                    b.Navigation("ExperimentSummaries");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.CommandExecutionSummary", b =>
+                {
+                    b.Navigation("ExecutionInfo");
+
+                    b.Navigation("Result");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Device.DeviceInfo", b =>
+                {
+                    b.Navigation("Commands");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentExecutionSummary", b =>
+                {
+                    b.Navigation("ExecutionInfo");
+
+                    b.Navigation("ExperimentOverview");
+
+                    b.Navigation("StepSummaries");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.ExperimentOverview", b =>
+                {
+                    b.Navigation("AnalysisOverview");
+
+                    b.Navigation("Parameters");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceCapabilities", b =>
+                {
+                    b.Navigation("AvailablePlanners");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Planning.PlannerServiceInfo", b =>
+                {
+                    b.Navigation("Capabilities");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionStatus", b =>
+                {
+                    b.Navigation("CommandExecutionStatuses");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.StepExecutionSummary", b =>
+                {
+                    b.Navigation("CommandSummaries");
+
+                    b.Navigation("ExecutionInfo");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CampaignTemplate", b =>
+                {
+                    b.Navigation("CloseoutTemplate");
+
+                    b.Navigation("ExperimentTemplate");
+
+                    b.Navigation("PlannableParameters");
+
+                    b.Navigation("PlannerAllocations");
+
+                    b.Navigation("StartupTemplate");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandMetadata", b =>
+                {
+                    b.Navigation("OutputMetadata");
+
+                    b.Navigation("ParameterMetadatas");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.CommandTemplate", b =>
+                {
+                    b.Navigation("ArgumentBindings");
+
+                    b.Navigation("DeviceCommand");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.DeviceCommand", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ExperimentTemplate", b =>
+                {
+                    b.Navigation("StepTemplates");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.Parameter", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.ParameterMetadata", b =>
+                {
+                    b.Navigation("Constraints");
+                });
+
+            modelBuilder.Entity("Ares.Datamodel.Templates.StepTemplate", b =>
+                {
+                    b.Navigation("CommandTemplates");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/AresService.Migrations.Sqlite/Migrations/20260817202156_analyzer-upgrades_AresDbContext.cs b/AresService.Migrations.Sqlite/Migrations/20260817202156_analyzer-upgrades_AresDbContext.cs
new file mode 100644
index 00000000..22aaa00c
--- /dev/null
+++ b/AresService.Migrations.Sqlite/Migrations/20260817202156_analyzer-upgrades_AresDbContext.cs
@@ -0,0 +1,96 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace AresService.Migrations.Sqlite.Migrations.AresDb
+{
+    /// <inheritdoc />
+    public partial class analyzerupgrades_AresDbContext : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "PlanObjectives",
+                table: "ExperimentTemplates",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<bool>(
+              name: "MultiObjectiveCapable",
+              table: "PlannerServiceCapabilities",
+              type: "INTEGER",
+              nullable: false,
+              defaultValue: false);
+
+            migrationBuilder.AddColumn<string>(
+                name: "AnalyzerResponse",
+                table: "AnalyzerTransactions",
+                type: "TEXT",
+                nullable: false,
+                defaultValue: "{}");
+
+            migrationBuilder.AddColumn<string>(
+                name: "ObjectiveOutputSchema",
+                table: "AnalyzerCapabilities",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Objectives",
+                table: "AnalysisOverview",
+                type: "TEXT",
+                nullable: false,
+                defaultValue: "[]");
+
+            migrationBuilder.CreateTable(
+                name: "AnalysisResponses",
+                columns: table => new
+                {
+                    UniqueId = table.Column<Guid>(type: "TEXT", nullable: false),
+                    Objectives = table.Column<string>(type: "TEXT", nullable: true),
+                    AnalysisOutcome = table.Column<int>(type: "INTEGER", nullable: false),
+                    ErrorString = table.Column<string>(type: "TEXT", nullable: true),
+                    CreationTime = table.Column<DateTime>(type: "TEXT", nullable: false, defaultValueSql: "DATETIME('now')"),
+                    LastModified = table.Column<DateTime>(type: "TEXT", nullable: false, defaultValueSql: "DATETIME('now')")
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AnalysisResponses", x => x.UniqueId);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "AnalysisResponses");
+
+            migrationBuilder.DropColumn(
+                name: "MultiObjectiveCapable",
+                table: "PlannerServiceCapabilities");
+
+            migrationBuilder.DropColumn(
+                name: "PlanObjectives",
+                table: "ExperimentTemplates");
+
+            migrationBuilder.DropColumn(
+                name: "AnalyzerResponse",
+                table: "AnalyzerTransactions");
+
+            migrationBuilder.DropColumn(
+                name: "ObjectiveOutputSchema",
+                table: "AnalyzerCapabilities");
+
+            migrationBuilder.DropColumn(
+                name: "Objectives",
+                table: "AnalysisOverview");
+
+            migrationBuilder.AddColumn<string>(
+                name: "Objectives",
+                table: "Analyses",
+                type: "TEXT",
+                nullable: true);
+        }
+    }
+}
diff --git a/AresService.Migrations.Sqlite/Migrations/20260817202159_analyzer-upgrades_AresIdentityContext.Designer.cs b/AresService.Migrations.Sqlite/Migrations/20260817202159_analyzer-upgrades_AresIdentityContext.Designer.cs
new file mode 100644
index 00000000..659faa95
--- /dev/null
+++ b/AresService.Migrations.Sqlite/Migrations/20260817202159_analyzer-upgrades_AresIdentityContext.Designer.cs
@@ -0,0 +1,268 @@
+// <auto-generated />
+using System;
+using AresService.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace AresService.Migrations.Sqlite.Migrations.AresIdentity
+{
+    [DbContext(typeof(AresIdentityContext))]
+    [Migration("20260817202159_analyzer-upgrades_AresIdentityContext")]
+    partial class analyzerupgrades_AresIdentityContext
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.10");
+
+            modelBuilder.Entity("AresService.Data.AresUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("AresService.Data.AresUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("AresService.Data.AresUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("AresService.Data.AresUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("AresService.Data.AresUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/AresService.Migrations.Sqlite/Migrations/20260817202159_analyzer-upgrades_AresIdentityContext.cs b/AresService.Migrations.Sqlite/Migrations/20260817202159_analyzer-upgrades_AresIdentityContext.cs
new file mode 100644
index 00000000..08cce0fd
--- /dev/null
+++ b/AresService.Migrations.Sqlite/Migrations/20260817202159_analyzer-upgrades_AresIdentityContext.cs
@@ -0,0 +1,22 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace AresService.Migrations.Sqlite.Migrations.AresIdentity
+{
+    /// <inheritdoc />
+    public partial class analyzerupgrades_AresIdentityContext : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}
diff --git a/AresService.Migrations.Sqlite/Migrations/AresDbContextModelSnapshot.cs b/AresService.Migrations.Sqlite/Migrations/AresDbContextModelSnapshot.cs
index 243d6fef..42c2c8c1 100644
--- a/AresService.Migrations.Sqlite/Migrations/AresDbContextModelSnapshot.cs
+++ b/AresService.Migrations.Sqlite/Migrations/AresDbContextModelSnapshot.cs
@@ -39,6 +39,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("TEXT")
                         .HasDefaultValueSql("DATETIME('now')");
 
+                    b.Property<string>("Objectives")
+                        .HasColumnType("TEXT");
+
                     b.Property<double>("Result")
                         .HasColumnType("REAL");
 
@@ -80,6 +83,36 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Analyses", (string)null);
                 });
 
+            modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalysisResponse", b =>
+                {
+                    b.Property<Guid>("UniqueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AnalysisOutcome")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("CreationTime")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("ErrorString")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastModified")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValueSql("DATETIME('now')");
+
+                    b.Property<string>("Objectives")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UniqueId");
+
+                    b.ToTable("AnalysisResponses", (string)null);
+                });
+
             modelBuilder.Entity("Ares.Datamodel.Analyzing.AnalyzerCapabilities", b =>
                 {
                     b.Property<Guid>("UniqueId")
@@ -99,6 +132,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("TEXT")
                         .HasDefaultValueSql("DATETIME('now')");
 
+                    b.Property<string>("ObjectiveOutputSchema")
+                        .HasColumnType("TEXT");
+
                     b.Property<string>("SettingsSchema")
                         .HasColumnType("TEXT");
 
@@ -221,6 +257,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("AnalyzerName")
                         .HasColumnType("TEXT");
 
+                    b.Property<string>("AnalyzerResponse")
+                        .HasColumnType("TEXT");
+
                     b.Property<string>("AnalyzerType")
                         .HasColumnType("TEXT");
 
@@ -1155,6 +1194,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("TEXT")
                         .HasDefaultValueSql("DATETIME('now')");
 
+                    b.Property<bool>("MultiObjectiveCapable")
+                        .HasColumnType("INTEGER");
+
                     b.Property<Guid>("PlannerInfoId")
                         .HasColumnType("TEXT");
 
@@ -1525,6 +1567,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("Name")
                         .HasColumnType("TEXT");
 
+                    b.Property<string>("PlanObjectives")
+                        .HasColumnType("TEXT");
+
                     b.Property<bool>("Resolved")
                         .HasColumnType("INTEGER");
 
diff --git a/DemoRemoteAnalyzer/DemoRemoteAnalyzer.csproj b/DemoRemoteAnalyzer/DemoRemoteAnalyzer.csproj
index 54e84ca4..385765e1 100644
--- a/DemoRemoteAnalyzer/DemoRemoteAnalyzer.csproj
+++ b/DemoRemoteAnalyzer/DemoRemoteAnalyzer.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ARES.Datamodel" Version="0.35.0" />
+    <PackageReference Include="ARES.Datamodel" Version="0.36.0" />
     <PackageReference Include="Grpc.AspNetCore" Version="2.80.0" />
   </ItemGroup>
 
diff --git a/DemoRemoteAnalyzer/Services/DemoAnalyzerService.cs b/DemoRemoteAnalyzer/Services/DemoAnalyzerService.cs
index 997320a1..8d9b3119 100644
--- a/DemoRemoteAnalyzer/Services/DemoAnalyzerService.cs
+++ b/DemoRemoteAnalyzer/Services/DemoAnalyzerService.cs
@@ -2,6 +2,7 @@
 using Ares.Datamodel.Analyzing;
 using Ares.Datamodel.Analyzing.Remote;
 using Ares.Datamodel.Connection;
+using Ares.Datamodel.Extensions;
 using Google.Protobuf.WellKnownTypes;
 using Grpc.Core;
 
@@ -17,18 +18,19 @@ public override Task<StateResponse> GetState(Empty request, ServerCallContext co
     return Task.FromResult(new StateResponse { State = State.Active, StateMessage = "The Demo Analyzer is Active!" });
   }
 
-  public override Task<Analysis> Analyze(AnalysisRequest request, ServerCallContext context)
+  public override Task<AnalysisResponse> Analyze(AnalysisRequest request, ServerCallContext context)
   {
     Console.WriteLine("Analysis requested");
     var numInput = request.Inputs.Fields[DemoDataTypes.InputNumber.Key];
     var input = numInput.NumberValue;
     Console.WriteLine($"Analysis input: {input}");
-    var analysis = new Analysis
+    var analysis = new AnalysisResponse
     {
-      Result = (float)input,
       AnalysisOutcome = Outcome.Success,
     };
 
+    analysis.Objectives.Add(new Objective() { ObjectiveName = "Result", ObjectiveValue = AresValueHelper.CreateNumber(input) });
+
     var numOperand = request.Inputs.Fields.GetValueOrDefault(DemoDataTypes.Operand.Key);
     if(numOperand is null)
     {
@@ -40,13 +42,15 @@ public override Task<Analysis> Analyze(AnalysisRequest request, ServerCallContex
     var operation = request.Settings.Fields[DemoDataTypes.Operation.Key];
     var operationValue = operation.StringValue;
 
-    analysis.Result = operationValue switch
+    var resultValue = operationValue switch
     {
-      "Multiply" => (float)(analysis.Result * operand),
-      "Divide" => (float)(analysis.Result / operand),
-      _ => 0,// you broke it :(
+      "Multiply" => AresValueHelper.CreateNumber(analysis.Objectives.First().ObjectiveValue.NumberValue * operand),
+      "Divide" => AresValueHelper.CreateNumber(analysis.Objectives.First().ObjectiveValue.NumberValue / operand),
+      _ => AresValueHelper.CreateNumber(0),// you broke it :(
     };
 
+    analysis.Objectives.Add(new Objective() { ObjectiveValue = resultValue, ObjectiveName = "Result"});
+
     return Task.FromResult(analysis);
   }
 
diff --git a/DemoRemoteDevice/DemoRemoteDevice.csproj b/DemoRemoteDevice/DemoRemoteDevice.csproj
index 94be5fbf..f9d54735 100644
--- a/DemoRemoteDevice/DemoRemoteDevice.csproj
+++ b/DemoRemoteDevice/DemoRemoteDevice.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ARES.Datamodel" Version="0.35.0" />
+    <PackageReference Include="ARES.Datamodel" Version="0.36.0" />
     <PackageReference Include="Grpc.AspNetCore" Version="2.80.0" />
   </ItemGroup>
 
diff --git a/DemoRemotePlanner/DemoRemotePlanner.csproj b/DemoRemotePlanner/DemoRemotePlanner.csproj
index 54e84ca4..385765e1 100644
--- a/DemoRemotePlanner/DemoRemotePlanner.csproj
+++ b/DemoRemotePlanner/DemoRemotePlanner.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ARES.Datamodel" Version="0.35.0" />
+    <PackageReference Include="ARES.Datamodel" Version="0.36.0" />
     <PackageReference Include="Grpc.AspNetCore" Version="2.80.0" />
   </ItemGroup>
 
diff --git a/DemoRemotePlanner/Services/DemoPlannerService.cs b/DemoRemotePlanner/Services/DemoPlannerService.cs
index 1b8a5ea6..fbe94b0d 100644
--- a/DemoRemotePlanner/Services/DemoPlannerService.cs
+++ b/DemoRemotePlanner/Services/DemoPlannerService.cs
@@ -38,7 +38,8 @@ public override async Task<PlanningResponse> Plan(PlanningRequest request, Serve
     Console.WriteLine("Planning Requested!");
     var inputs = request.PlanningParameters;
     Console.WriteLine($"Received a total of {inputs.Count} parameters to plan for.");
-    var response = new PlanningResponse();
+    var response = new PlanningResponse();
+    var newPlan = new Plan();
 
     foreach(var parameter in inputs)
     {
@@ -47,25 +48,27 @@ public override async Task<PlanningResponse> Plan(PlanningRequest request, Serve
         case "Random Planner":
           {
             var plannedParam = await RandomPlanner(parameter);
-            response.PlannedParameters.Add(plannedParam);
+            newPlan.PlannedParameters.Add(plannedParam);
             break;
           }
         case "Gradual Planner":
           {
             var gradualPlannedParam = await GradualPlanner(parameter);
-            response.PlannedParameters.Add(gradualPlannedParam);
+            newPlan.PlannedParameters.Add(gradualPlannedParam);
             break;
           }
         default:
           {
             Console.WriteLine("Unrecognized Planned Requested! Defaulting to random planner...");
             var plannedParam = await RandomPlanner(parameter);
-            response.PlannedParameters.Add(plannedParam);
+            newPlan.PlannedParameters.Add(plannedParam);
             break;
           }
       }
     }
-
+
+    newPlan.PlanningOutcome = Outcome.Success;
+    response.Plans.Add(newPlan);
     return response;
   }
 
diff --git a/UI/Components/Layouts/MainLayout.razor b/UI/Components/Layouts/MainLayout.razor
index 4986085c..79678a93 100644
--- a/UI/Components/Layouts/MainLayout.razor
+++ b/UI/Components/Layouts/MainLayout.razor
@@ -124,6 +124,8 @@
   private CancellationTokenSource _cts = new();
   private string _loadingMessage = "Initializing ARES OS...";
   private IDisposable? _driverSubscription;
+  private IDisposable? _notificationSubscription;
+  private bool _isDisposed;
   private List<string> _approvedCssPaths = new();
   public bool HasUnreadNotifications = false;
 
@@ -153,7 +155,7 @@
     notificationService.OnNotificationReceived += HandleBackgroundNotification;
     HasUnreadNotifications = notificationProvider.GetAllNotifications().Any(n => !n.IsRead);
 
-    notificationProvider.Connect()
+    _notificationSubscription = notificationProvider.Connect()
     .Throttle(TimeSpan.FromMilliseconds(500))
     .Subscribe(_ => InvokeAsync(NotificationsUpdated));
 
@@ -168,6 +170,9 @@
 
   private Task NotificationsUpdated()
   {
+    if(_isDisposed)
+      return Task.CompletedTask;
+
     HasUnreadNotifications = notificationProvider.GetAllNotifications().Any(n => !n.IsRead);
     StateHasChanged();
     return Task.CompletedTask;
@@ -274,8 +279,12 @@
 
   public void Dispose()
   {
+    _isDisposed = true;
+
     Tracker.OnSystemReady -= HandleSystemReady;
     notificationService.OnNotificationReceived -= HandleBackgroundNotification;
+
+    _notificationSubscription?.Dispose();
     _driverSubscription?.Dispose();
 
     _cts.Cancel();
diff --git a/UI/Features/CampaignEdit/Factories/PlanningDesignerFactory.cs b/UI/Features/CampaignEdit/Factories/PlanningDesignerFactory.cs
index c886bdaa..a4f0f505 100644
--- a/UI/Features/CampaignEdit/Factories/PlanningDesignerFactory.cs
+++ b/UI/Features/CampaignEdit/Factories/PlanningDesignerFactory.cs
@@ -1,9 +1,9 @@
 using Ares.Datamodel.Templates;
-using Ares.Services;
 using Ares.Core.Grpc.Services;
 using Google.Protobuf.WellKnownTypes;
 using UI.Features.CampaignEdit.ViewModels;
 using UI.Application.Notifications;
+using Ares.Core.Analyzing;
 
 
 namespace UI.Features.CampaignEdit.Factories;
@@ -12,17 +12,21 @@ public class PlanningDesignerFactory
 {
   private readonly PlannerService _client;
   private readonly IUiNotificationService _notificationService;
+  private readonly IAnalyzerRepo _analyzerRepo;
 
-  public PlanningDesignerFactory(PlannerService client, IUiNotificationService notificationService)
+  public PlanningDesignerFactory(PlannerService client, IUiNotificationService notificationService, IAnalyzerRepo analyzerRepo)
   {
     _client = client;
     _notificationService = notificationService;
+    _analyzerRepo = analyzerRepo;
   }
 
   public async Task<PlanningViewModel> Create(CampaignTemplate template)
   {
+    var matchingAnalyzer = _analyzerRepo.GetAnalyzerById(template.ExperimentTemplate.AnalyzerId);
+
     var planners = await _client.GetAllPlanners(new Empty(), null);
-    return new PlanningViewModel(template, planners.Planners, _client, _notificationService);
+    return new PlanningViewModel(template, planners.Planners, _client, _notificationService, matchingAnalyzer);
   }
 }
 
diff --git a/UI/Features/CampaignEdit/ViewModels/AnalyzerDesignerViewModel.cs b/UI/Features/CampaignEdit/ViewModels/AnalyzerDesignerViewModel.cs
index 602e1b1f..77c9e0c5 100644
--- a/UI/Features/CampaignEdit/ViewModels/AnalyzerDesignerViewModel.cs
+++ b/UI/Features/CampaignEdit/ViewModels/AnalyzerDesignerViewModel.cs
@@ -143,6 +143,9 @@ public void Save()
 
     _experimentTemplate.AnalyzerMaps.Clear();
     _experimentTemplate.AnalyzerMaps.AddRange(analyzerMappings);
+    if(_experimentTemplate.AnalyzerId != AnalyzerId)
+      _experimentTemplate.PlanObjectives.Clear();
+
     _experimentTemplate.AnalyzerId = AnalyzerId;
   }
 
diff --git a/UI/Features/CampaignEdit/ViewModels/CampaignDesignerViewModel.cs b/UI/Features/CampaignEdit/ViewModels/CampaignDesignerViewModel.cs
index a2ba24c5..b78352b6 100644
--- a/UI/Features/CampaignEdit/ViewModels/CampaignDesignerViewModel.cs
+++ b/UI/Features/CampaignEdit/ViewModels/CampaignDesignerViewModel.cs
@@ -50,41 +50,86 @@ public CampaignDesignerViewModel(
     };
   }
 
-  [Reactive] public partial bool IsCreatingCampaign { get; set; }
+  [Reactive] 
+  public partial bool IsCreatingCampaign { get; set; }
 
-  [Reactive] public partial bool IsNotCreatingCampaign { get; set; }
+  [Reactive] 
+  public partial bool IsNotCreatingCampaign { get; set; }
 
-  [Reactive] public partial string Placeholder { get; set; }
+  [Reactive] 
+  public partial string Placeholder { get; set; }
 
-  public PlannableParameterDesignerViewModel? PlannableParameterDesigner { get; private set; }
+  [Reactive]
+  public partial PlannableParameterDesignerViewModel? PlannableParameterDesigner { get; private set; }
 
-  public ExperimentDesignerViewModel? ExperimentDesigner { get; private set; }
+  [Reactive]
+  public partial ExperimentDesignerViewModel? ExperimentDesigner { get; private set; }
 
-  public StartupDesignerViewModel? StartupDesigner { get; private set; }
+  [Reactive]
+  public partial StartupDesignerViewModel? StartupDesigner { get; private set; }
 
-  public CloseoutDesignerViewModel? CloseoutDesigner { get; private set; }
+  [Reactive]
+  public partial CloseoutDesignerViewModel? CloseoutDesigner { get; private set; }
 
-  public PlanningViewModel? PlanningDesigner { get; private set; }
+  [Reactive]
+  public partial PlanningViewModel? PlanningDesigner { get; private set; }
 
-  public AnalyzerDesignerViewModel? AnalyzerDesignerViewModel { get; private set; }
+  [Reactive]
+  public partial AnalyzerDesignerViewModel? AnalyzerDesignerViewModel { get; private set; }
 
   public string CampaignName { get; set; } = "Unnamed Campaign";
 
-  public CampaignTemplate CampaignTemplate
+  public CampaignTemplate CampaignTemplate { get; private set; } = null!;
+
+  [Reactive] 
+  public partial bool CreationIsErrorFree { get; set; }
+
+  [Reactive] 
+  public partial string? CreationErrorText { get; set; }
+
+  public async Task InitializeNewCampaignAsync()
   {
-    private get => _campaignTemplate;
+    var template = new CampaignTemplate
+    {
+      Name = Placeholder,
+      UniqueId = Guid.NewGuid().ToString(),
+      ExperimentTemplate = new ExperimentTemplate { UniqueId = Guid.NewGuid().ToString(), Name = "New Experiment" }
+    };
 
-    set
+    await LoadCampaignTemplateAsync(template);
+  }
+
+  public async Task SelectCampaignById(Guid campaignId)
+  {
+    var request = new CampaignRequest
     {
-      _campaignTemplate = value;
-      _editContext.CurrentlyEditingCampaign = value;
-      _ = Init(value);
-    }
+      UniqueId = campaignId.ToString(),
+    };
+
+    var template = await _automationClient.GetSingleCampaign(request, null);
+    await LoadCampaignTemplateAsync(template);
   }
 
-  [Reactive] public partial bool CreationIsErrorFree { get; set; }
+  public async Task LoadCampaignTemplateAsync(CampaignTemplate campaignTemplate)
+  {
+    CampaignTemplate = campaignTemplate;
+    _editContext.CurrentlyEditingCampaign = campaignTemplate;
+    CampaignName = campaignTemplate.Name;
+
+    PlannableParameterDesigner = _plannableParameterDesignerFactory.Create(campaignTemplate.PlannableParameters, campaignTemplate.ExperimentTemplate);
+    ExperimentDesigner = _experimentDesignerFactory.Create(campaignTemplate.ExperimentTemplate);
+    StartupDesigner = _startupDesignerFactory.Create(campaignTemplate.StartupTemplate);
+    CloseoutDesigner = _closeoutDesignerFactory.Create(campaignTemplate.CloseoutTemplate);
+    PlanningDesigner = await _planningDesignerFactory.Create(campaignTemplate);
+
+    var commandDesigners = ExperimentDesigner?.StepDesigners?.SelectMany(sd => sd.CommandDesigners) ?? [];
+    var startupDesigners = StartupDesigner?.StartupStepDesigners?.SelectMany(ssd => ssd.CommandDesigners) ?? [];
 
-  [Reactive] public partial string? CreationErrorText { get; set; }
+    if(campaignTemplate.ExperimentTemplate is not null)
+    {
+      AnalyzerDesignerViewModel = _analyzerInputDesignerFactory.Create(campaignTemplate.ExperimentTemplate, commandDesigners, startupDesigners);
+    }
+  }
 
   private async Task Init(CampaignTemplate campaignTemplate)
   {
@@ -126,16 +171,6 @@ public CampaignTemplate Save()
     return CampaignTemplate;
   }
 
-  public async Task SelectCampaignById(Guid campaignId)
-  {
-    var request = new CampaignRequest
-    {
-      UniqueId = campaignId.ToString(),
-    };
-
-    CampaignTemplate = await _automationClient.GetSingleCampaign(request, null);
-  }
-
   public async Task Update()
   {
     if(string.IsNullOrEmpty(CampaignName))
diff --git a/UI/Features/CampaignEdit/ViewModels/PlannerAllocationEditorViewModel.cs b/UI/Features/CampaignEdit/ViewModels/PlannerAllocationEditorViewModel.cs
index 38f6a40f..b5aad2f1 100644
--- a/UI/Features/CampaignEdit/ViewModels/PlannerAllocationEditorViewModel.cs
+++ b/UI/Features/CampaignEdit/ViewModels/PlannerAllocationEditorViewModel.cs
@@ -12,7 +12,7 @@ public partial class PlannerAllocationEditorViewModel : ReactiveObject
 {
   private readonly PlannerService _plannerClient;
   private readonly IUiNotificationService _notificationService;
-  private PlannerServiceInfo? _selectedAdapter;
+  private PlannerServiceInfo? _selectedService;
 
   public PlannerAllocationEditorViewModel(ParameterMetadata metadata,
     PlannerServiceInfo? plannerInfo,
@@ -27,13 +27,26 @@ public PlannerAllocationEditorViewModel(ParameterMetadata metadata,
     _plannerClient = plannerClient;
     _notificationService = notificationService;
 
+    // Initialize to empty by default
+    PlannerOptions = Enumerable.Empty<Planner>();
+
     if(plannerInfo is not null)
     {
-      SelectedService = plannerInfo;
-      SelectedPlannerOption = plannerInfo.Capabilities.AvailablePlanners.FirstOrDefault(p => p.PlannerName == metadata.PlannerName);
+      // Match against the fresh live adapter collection instead of using the stale deserialized snapshot
+      var liveService = plannerArray.FirstOrDefault(p => p.UniqueId == plannerInfo.UniqueId || p.Name == plannerInfo.Name);
+
+      SelectedService = liveService ?? plannerInfo;
+
+      // Restore specific planner option selection if specified in metadata
+      if(!string.IsNullOrEmpty(metadata.PlannerName))
+      {
+        var matchedOption = PlannerOptions.FirstOrDefault(p => p.PlannerName == metadata.PlannerName);
+        if(matchedOption != null)
+        {
+          SelectedPlannerOption = matchedOption;
+        }
+      }
     }
-
-    PlannerOptions = Enumerable.Empty<Planner>();
   }
 
   public PlannerAllocation? Save()
@@ -61,22 +74,20 @@ public async Task UpdatePlannerOptions()
 
     var updatedInfo = await _plannerClient.GetInfo(new PlannerInfoRequest { PlannerId = SelectedService.UniqueId }, null);
 
-    if(updatedInfo.Info.Name != string.Empty)
+    if(updatedInfo?.Info is not null && !string.IsNullOrEmpty(updatedInfo.Info.Name))
     {
-      PlannerOptions = updatedInfo.Info.Capabilities.AvailablePlanners;
-
-      //Not all adapters will have multiple options, if not auto assign the value
-      if(PlannerOptions.Count() == 1)
-        SelectedPlannerOption = SelectedService.Capabilities.AvailablePlanners.First();  
+      // Update the SelectedService reference with the fresh gRPC response
+      SelectedService = updatedInfo.Info;
     }
-
     else
     {
-      var notification = new UiNotificationMessage();
-      notification.Summary = "Assigned Planner Unavailable!";
-      notification.Detail = $"This template uses a planner that ARES no longer has a connection with. The template won't be usable until this is resolved.";
-      notification.Severity = UiNotificationSeverity.Warning;
-      notification.CloseOnClick = true;
+      var notification = new UiNotificationMessage
+      {
+        Summary = "Assigned Planner Unavailable!",
+        Detail = "This template uses a planner that ARES no longer has a connection with. The template won't be usable until this is resolved.",
+        Severity = UiNotificationSeverity.Warning,
+        CloseOnClick = true
+      };
 
       _notificationService.Notify(notification);
     }
@@ -84,18 +95,13 @@ public async Task UpdatePlannerOptions()
 
   public PlannerServiceInfo? SelectedService
   {
-    get => _selectedAdapter;
-
+    get => _selectedService;
     set
     {
-      if(value is null || _selectedAdapter == value)
-        return;
-
-      if(_selectedAdapter is not null)
-        SelectedPlannerOption = _selectedAdapter.Capabilities.AvailablePlanners.FirstOrDefault();
+      this.RaiseAndSetIfChanged(ref _selectedService, value);
 
-      _selectedAdapter = value;
-      _ = UpdatePlannerOptions();
+      PlannerOptions = _selectedService?.Capabilities?.AvailablePlanners?.ToList() ?? new List<Planner>();
+      SelectedPlannerOption = PlannerOptions.FirstOrDefault();
     }
   }
 
@@ -106,6 +112,4 @@ public PlannerServiceInfo? SelectedService
   public partial IEnumerable<Planner> PlannerOptions { get; set; }
   [Reactive]
   public partial Planner? SelectedPlannerOption { get; set; }
-}
-
-
+}
\ No newline at end of file
diff --git a/UI/Features/CampaignEdit/ViewModels/PlanningViewModel.cs b/UI/Features/CampaignEdit/ViewModels/PlanningViewModel.cs
index 60c23c75..01fa0d4b 100644
--- a/UI/Features/CampaignEdit/ViewModels/PlanningViewModel.cs
+++ b/UI/Features/CampaignEdit/ViewModels/PlanningViewModel.cs
@@ -1,34 +1,67 @@
 using ReactiveUI;
 using System.Collections.ObjectModel;
 using Ares.Datamodel.Templates;
-using Ares.Services;
 using Ares.Datamodel.Planning;
 using Ares.Core.Grpc.Services;
 using UI.Application.Notifications;
+using Ares.Core.Analyzing;
+using Ares.Datamodel;
+using ReactiveUI.SourceGenerators;
 
 namespace UI.Features.CampaignEdit.ViewModels;
 
-public class PlanningViewModel : ReactiveObject
+public partial class PlanningViewModel : ReactiveObject
 {
   private readonly CampaignTemplate _template;
   private readonly PlannerService _client;
   private readonly IUiNotificationService _notificationService;
+  private readonly IAnalyzer? _selectedAnalyzer;
 
   public PlanningViewModel(CampaignTemplate template, 
     IEnumerable<PlannerServiceInfo> plannerAdapters, 
     PlannerService client,
-    IUiNotificationService notificationService)
+    IUiNotificationService notificationService,
+    IAnalyzer? selectedAnalyzer)
   {
     _template = template;
     _client = client;
     _notificationService = notificationService;
+    _selectedAnalyzer = selectedAnalyzer;
     PlannerAdapters = new ReadOnlyCollection<PlannerServiceInfo>(plannerAdapters.ToList());
     PlannerAllocationEditors = template.PlannableParameters.Select(metadata => new PlannerAllocationEditorViewModel(metadata, template.PlannerAllocations.FirstOrDefault(allocation => allocation.Parameter.Equals(metadata))?.Planner, PlannerAdapters, client, notificationService)).ToArray();
   }
 
-  public IEnumerable<PlannerAllocationEditorViewModel> PlannerAllocationEditors { get; private set; }
+  public async Task UpdateAnalyzerObjectives()
+  {
+    if(_selectedAnalyzer is not null)
+      AvailableObjectives = await _selectedAnalyzer.GetObjectiveOutputs();
+
+    SelectedObjectives = AvailableObjectives?.Fields.Where(obj => _template.ExperimentTemplate.PlanObjectives.Contains(obj.Key)).ToList() ?? [];
+  }
+
+  public void RefreshMultiObjectiveCompatability()
+    => MultiObjectiveAllowed = PlannerAllocationEditors.All(editor => editor.SelectedService?.Capabilities.MultiObjectiveCapable ?? false);
+  
+
+  [Reactive]
+  public partial IEnumerable<PlannerAllocationEditorViewModel> PlannerAllocationEditors { get; private set; } = [];
+
+  [Reactive]
+  public partial IEnumerable<PlannerServiceInfo> PlannerAdapters { get; private set; } = [];
 
-  public IEnumerable<PlannerServiceInfo> PlannerAdapters { get; }
+  [Reactive]
+  public partial AresStructSchema? AvailableObjectives { get; private set; }
+
+  [Reactive]
+  public partial List<KeyValuePair<string, AresValueSchema>> SelectedObjectives { get; private set; } = [];
+
+  [Reactive]
+  public partial List<string> IncludedObjectives { get; private set; } = [];
+
+  public string AnalyzerName => _selectedAnalyzer?.Name ?? "NONE";
+
+  [Reactive]
+  public partial bool MultiObjectiveAllowed { get; private set; } = false;
 
   public void Save()
   {
@@ -40,6 +73,8 @@ public void Save()
       .Where(allocation => allocation is not null)
       .Where(allocation => _template.PlannableParameters.Any(meta => meta.UniqueId == allocation!.Parameter.UniqueId)));
 
+    _template.ExperimentTemplate.PlanObjectives.AddRange(SelectedObjectives.Select(obj => obj.Key));
+
     PlannerAllocationEditors = _template.PlannableParameters
     .Select(metadata => new PlannerAllocationEditorViewModel(metadata, _template.PlannerAllocations
     .FirstOrDefault(allocation => allocation.Parameter.Equals(metadata))?.Planner, PlannerAdapters, _client, _notificationService))
diff --git a/UI/Features/CampaignEdit/Views/AnalyzerInputDesigner.razor b/UI/Features/CampaignEdit/Views/AnalyzerInputDesigner.razor
index 1400352a..0e8f44ff 100644
--- a/UI/Features/CampaignEdit/Views/AnalyzerInputDesigner.razor
+++ b/UI/Features/CampaignEdit/Views/AnalyzerInputDesigner.razor
@@ -2,10 +2,11 @@
 
 @inherits ReactiveUI.Blazor.ReactiveComponentBase<UI.Features.CampaignEdit.ViewModels.AnalyzerDesignerViewModel>
 
-@if(DesignerLoading)
+@if(_designerLoading)
 {
-  <div>Loading...</div>
+  <LoadingSpinner SpinnerSize="SpinnerSize.Large" />
 }
+
 else
 {
   <div class="d-flex flex-column h-100">
@@ -37,14 +38,27 @@ else
 }
 
 @code {
-  protected bool DesignerLoading { get; set; } = false;
+  private bool _designerLoading = true;
+  private AnalyzerDesignerViewModel? _lastViewModel;
 
-  protected override async Task OnInitializedAsync()
+  protected override async Task OnParametersSetAsync()
   {
-    DesignerLoading = true;
-    await ViewModel!.UpdateAvailableAnalyzers();
-    await ViewModel!.UpdateMappings();
-    DesignerLoading = false;
-    StateHasChanged();
+    // Only run if ViewModel is present and has actually changed
+    if(ViewModel is not null && ViewModel != _lastViewModel)
+    {
+      _lastViewModel = ViewModel;
+      _designerLoading = true;
+
+      try
+      {
+        await ViewModel.UpdateAvailableAnalyzers();
+        await ViewModel.UpdateMappings();
+      }
+      finally
+      {
+        _designerLoading = false;
+        StateHasChanged();
+      }
+    }
   }
 }
diff --git a/UI/Features/CampaignEdit/Views/CampaignDesigner.razor b/UI/Features/CampaignEdit/Views/CampaignDesigner.razor
index af3f3cce..a8b3221e 100644
--- a/UI/Features/CampaignEdit/Views/CampaignDesigner.razor
+++ b/UI/Features/CampaignEdit/Views/CampaignDesigner.razor
@@ -14,47 +14,39 @@
             <RadzenIcon Icon="edit"/>
         </button>
     </div>
-    <div class="btn-group" role="group">
-        <input type="radio" class="btn-check m-1" name="btnradio" id="btnradio1" autocomplete="off" @onclick="SelectParam" checked/>
-        <label class="btn btn-outline-secondary" for="btnradio1">Parameter Designer</label>
-        <input type="radio" class="btn-check m-1" name="btnradio" id="btnradio2" autocomplete="off" @onclick="SelectStartup"/>
-        <label class="btn btn-outline-secondary" for="btnradio2">Startup Script</label>
-        <input type="radio" class="btn-check" name="btnradio" id="btnradio3" autocomplete="off" @onclick="SelectExp"/>
-        <label class="btn btn-outline-secondary" for="btnradio3">Experiment Template</label>
-        <input type="radio" class="btn-check m-1" name="btnradio" id="btnradio4" autocomplete="off" @onclick="SelectCloseout" />
-        <label class="btn btn-outline-secondary" for="btnradio4">Closeout Script</label>
-        <input type="radio" class="btn-check" name="btnradio" id="btnradio5" autocomplete="off" @onclick="SelectPlan"/>
-        <label class="btn btn-outline-secondary" for="btnradio5">Planning</label>
-        <input type="radio" class="btn-check" name="btnradio" id="btnradio6" autocomplete="off" @onclick="SelectAnalyzer"/>
-        <label class="btn btn-outline-secondary" for="btnradio6">Analyzer Inputs</label>
-    </div>
-    <div class="my-2 flex-grow-1 overflow-auto">
-        @if (SelectedSubOption1)
-        {
-          <div class="w-50">
-            <PlannableParameterDesigner ViewModel="@ViewModel!.PlannableParameterDesigner"/>
-          </div>
-        }
-        @if (SelectedSubOption2)
-        {
-            <ExperimentDesigner ViewModel="@ViewModel!.ExperimentDesigner"/>
-        }
-        @if (SelectedSubOption3)
-        {
-            <Planning ViewModel="@ViewModel!.PlanningDesigner"/>
-        }
-        @if (SelectedSubOption4)
-        {
-            <StartupScriptDesigner ViewModel="@ViewModel!.StartupDesigner"/>
-        }
-        @if (SelectedSubOption5)
-        {
-            <CloseoutScriptDesigner ViewModel="@ViewModel!.CloseoutDesigner"/>
-        }
-        @if (SelectedSubOption6)
-        {
-          <AnalyzerInputDesigner ViewModel="@ViewModel!.AnalyzerDesignerViewModel" /> 
-        }
+  <div class="btn-group" role="group">
+    <button class="btn @(ActiveTab == DesignerTab.Parameters ? "btn-secondary" : "btn-outline-secondary")" @onclick="() => ActiveTab = DesignerTab.Parameters">Parameter Designer</button>
+    <button class="btn @(ActiveTab == DesignerTab.Startup ? "btn-secondary" : "btn-outline-secondary")" @onclick="() => ActiveTab = DesignerTab.Startup">Startup Script</button>
+    <button class="btn @(ActiveTab == DesignerTab.Experiment ? "btn-secondary" : "btn-outline-secondary")" @onclick="() => ActiveTab = DesignerTab.Experiment">Experiment Template</button>
+    <button class="btn @(ActiveTab == DesignerTab.Closeout ? "btn-secondary" : "btn-outline-secondary")" @onclick="() => ActiveTab = DesignerTab.Closeout">Closeout Script</button>
+    <button class="btn @(ActiveTab == DesignerTab.Analyzer ? "btn-secondary" : "btn-outline-secondary")" @onclick="() => ActiveTab = DesignerTab.Analyzer">Analyzer Inputs</button>
+    <button class="btn @(ActiveTab == DesignerTab.Planning ? "btn-secondary" : "btn-outline-secondary")" @onclick="() => ActiveTab = DesignerTab.Planning">Planning</button>
+  </div>
+
+  <div class="my-2 flex-grow-1 overflow-auto">
+    @switch(ActiveTab)
+    {
+      case DesignerTab.Parameters:
+      <div class="w-50">
+        <PlannableParameterDesigner ViewModel="@ViewModel!.PlannableParameterDesigner" />
+      </div>
+      break;
+      case DesignerTab.Experiment:
+        <ExperimentDesigner ViewModel="@ViewModel!.ExperimentDesigner" />
+        break;
+      case DesignerTab.Planning:
+        <Planning ViewModel="@ViewModel!.PlanningDesigner" />
+        break;
+      case DesignerTab.Startup:
+        <StartupScriptDesigner ViewModel="@ViewModel!.StartupDesigner" />
+        break;
+      case DesignerTab.Closeout:
+        <CloseoutScriptDesigner ViewModel="@ViewModel!.CloseoutDesigner" />
+        break;
+      case DesignerTab.Analyzer:
+        <AnalyzerInputDesigner ViewModel="@ViewModel!.AnalyzerDesignerViewModel" />
+        break;
+    }
   </div>
     <div class="d-flex justify-content-end">
         <button @onclick="SaveClick" class="btn btn-primary">Save</button>
@@ -70,8 +62,19 @@
 
   protected override async Task OnInitializedAsync()
   {
-    if (CampaignId.HasValue)
+    if(CampaignId.HasValue)
+      await ViewModel!.SelectCampaignById(CampaignId.Value);
+  }
+
+  private bool _isLoading = true;
+
+  protected override async Task OnParametersSetAsync()
+  {
+    if(CampaignId.HasValue)
       await ViewModel!.SelectCampaignById(CampaignId.Value);
+    
+    else
+      await ViewModel!.InitializeNewCampaignAsync();
   }
 
   public bool SelectedSubOption1 { get; set; } = true;
@@ -81,8 +84,6 @@
   public bool SelectedSubOption5 { get; set; }
   public bool SelectedSubOption6 { get; set; }
 
-
-
   public void SelectParam() 
   {
     SelectedSubOption1 = true;
@@ -93,55 +94,55 @@
     SelectedSubOption6 = false;
   }
 
-    public void SelectExp()
-    {
-        SelectedSubOption2 = true;
-        SelectedSubOption1 = false;
-        SelectedSubOption3 = false;
-        SelectedSubOption4 = false;
-        SelectedSubOption5 = false;
-        SelectedSubOption6 = false;
-    }
+  public void SelectExp()
+  {
+    SelectedSubOption2 = true;
+    SelectedSubOption1 = false;
+    SelectedSubOption3 = false;
+    SelectedSubOption4 = false;
+    SelectedSubOption5 = false;
+    SelectedSubOption6 = false;
+  }
 
-    public void SelectPlan()
-    {
-        SelectedSubOption2 = false;
-        SelectedSubOption1 = false;
-        SelectedSubOption3 = true;
-        SelectedSubOption4 = false;
-        SelectedSubOption5 = false;
-        SelectedSubOption6 = false;
-    }
+  public void SelectPlan()
+  {
+    SelectedSubOption2 = false;
+    SelectedSubOption1 = false;
+    SelectedSubOption3 = true;
+    SelectedSubOption4 = false;
+    SelectedSubOption5 = false;
+    SelectedSubOption6 = false;
+  }
 
-    public void SelectStartup()
-    {
-        SelectedSubOption1 = false;
-        SelectedSubOption2 = false;
-        SelectedSubOption3 = false;
-        SelectedSubOption4 = true;
-        SelectedSubOption5 = false;
-        SelectedSubOption6 = false;
-    }
+  public void SelectStartup()
+  {
+    SelectedSubOption1 = false;
+    SelectedSubOption2 = false;
+    SelectedSubOption3 = false;
+    SelectedSubOption4 = true;
+    SelectedSubOption5 = false;
+    SelectedSubOption6 = false;
+  }
 
-    public void SelectCloseout()
-    {
-        SelectedSubOption1 = false;
-        SelectedSubOption2 = false;
-        SelectedSubOption3 = false;
-        SelectedSubOption4 = false;
-        SelectedSubOption5 = true;
-        SelectedSubOption6 = false;
-    }
+  public void SelectCloseout()
+  {
+    SelectedSubOption1 = false;
+    SelectedSubOption2 = false;
+    SelectedSubOption3 = false;
+    SelectedSubOption4 = false;
+    SelectedSubOption5 = true;
+    SelectedSubOption6 = false;
+  }
 
-    public void SelectAnalyzer()
-    {
-        SelectedSubOption1 = false;
-        SelectedSubOption2 = false;
-        SelectedSubOption3 = false;
-        SelectedSubOption4 = false;
-        SelectedSubOption5 = false;
-        SelectedSubOption6 = true;
-    }
+  public void SelectAnalyzer()
+  {
+    SelectedSubOption1 = false;
+    SelectedSubOption2 = false;
+    SelectedSubOption3 = false;
+    SelectedSubOption4 = false;
+    SelectedSubOption5 = false;
+    SelectedSubOption6 = true;
+  }
     
   private async Task SaveClick()
   {
@@ -156,44 +157,40 @@
     }
   }
 
-    private async void TitleClicked(MouseEventArgs obj)
-    {
-      string newName = ViewModel!.CampaignName;
-      var result = await DialogService.OpenAsync("Campaign Name Edit", ds =>
-          @<div class="d-flex flex-column">
-              <div class="input-group mb-3">
-                  <div class="input-group-prepend">
-                      <span class="input-group-text" id="inputGroup-sizing-default">Campaign Name</span>
-                  </div>
-                  @if(newName == "New Campaign 1")
-                  {
-                    newName = "";
-                    <input @bind="newName" type="text" class="form-control" aria-label="Default" aria-describedby="inputGroup-sizing-default">
-                  }
-
-                  else
-                  {
-                    <input @bind="newName" type="text" class="form-control" aria-label="Default" aria-describedby="inputGroup-sizing-default">
-                  }
-
-              </div>
-              <div class="d-flex">
-                  <button class="btn btn-primary btn-outline-light" @onclick="() => ds.Close(true)">Save</button>
-                  <button class="btn btn-danger btn-outline-light" @onclick="() => ds.Close(false)">Cancel</button>
-              </div>
+  private async Task TitleClicked(MouseEventArgs obj)
+  {
+    string currentName = ViewModel!.CampaignName;
+    string newName = currentName == "New Campaign 1" ? "" : currentName;
+
+    var result = await DialogService.OpenAsync("Campaign Name Edit", ds =>
+        @<div class="d-flex flex-column">
+          <div class="input-group mb-3">
+            <span class="input-group-text">Campaign Name</span>
+            <input @bind="newName" type="text" class="form-control" />
           </div>
-          );
-        
-        if(newName == "")
-        {
-          ViewModel!.CampaignName = "New Campaign 1";
-        }
-        
-        else if(result ?? false)
-        {
-            ViewModel!.CampaignName = newName;
-        }
+          <div class="d-flex gap-2">
+            <button class="btn btn-primary" @onclick="() => ds.Close(true)">Save</button>
+            <button class="btn btn-secondary" @onclick="() => ds.Close(false)">Cancel</button>
+          </div>
+        </div>
+    );
+
+    if(result == true)
+    {
+      ViewModel!.CampaignName = string.IsNullOrWhiteSpace(newName) ? "New Campaign 1" : newName;
     }
+  }
+
+  public enum DesignerTab
+  {
+    Parameters,
+    Startup,
+    Experiment,
+    Closeout,
+    Analyzer,
+    Planning
+  }
 
+  public DesignerTab ActiveTab { get; set; } = DesignerTab.Parameters;
 }
 
diff --git a/UI/Features/CampaignEdit/Views/PlannerAllocationEditor.razor b/UI/Features/CampaignEdit/Views/PlannerAllocationEditor.razor
index 2bc806a0..7dbd74fc 100644
--- a/UI/Features/CampaignEdit/Views/PlannerAllocationEditor.razor
+++ b/UI/Features/CampaignEdit/Views/PlannerAllocationEditor.razor
@@ -10,7 +10,13 @@
       </RadzenRow>
       <RadzenRow AlignItems="AlignItems.Center">
           <RadzenLabel Text="Select Service:" Component="PlannerServiceDropDown" Style="min-width: 115px"/>
-          <RadzenDropDown TValue="PlannerServiceInfo" Data="@ViewModel!.PlannerServices" @bind-Value="@ViewModel!.SelectedService" Name="PlannerServiceDropDown" Style="min-width: 15rem">
+          <RadzenDropDown TValue="PlannerServiceInfo" 
+            Data="@ViewModel!.PlannerServices" 
+            @bind-Value="@ViewModel!.SelectedService"
+            Change="@OnSelectionChanged"
+            Name="PlannerServiceDropDown" 
+            Style="min-width: 15rem">
+            
             <Template>
               @context.Name (@context.Version)
             </Template>
@@ -21,7 +27,12 @@
         @if(ViewModel!.PlannerOptions.Count() > 1)
         {
           <RadzenLabel Text="Select Planner:" Component="PlannerOptionDropDown" Style="min-width: 115px" />
-          <RadzenDropDown TValue="Planner" Data="@ViewModel!.PlannerOptions" @bind-Value="@ViewModel!.SelectedPlannerOption" Name="PlannerOptionDropDown" Style="min-width: 15rem">
+          <RadzenDropDown TValue="Planner" 
+            Data="@ViewModel!.PlannerOptions" 
+            @bind-Value="@ViewModel!.SelectedPlannerOption" 
+            Change="@OnSelectionChanged"
+            Name="PlannerOptionDropDown" 
+            Style="min-width: 15rem">
             <Template>
               @context.PlannerName
             </Template>
@@ -43,14 +54,25 @@
 </div>
 
 @code {
+
+  [Parameter]
+  public EventCallback OnPlannerChanged { get; set; }
+
+  private async Task OnSelectionChanged()
+  {
+    if(OnPlannerChanged.HasDelegate)
+    {
+      await OnPlannerChanged.InvokeAsync();
+    }
+  }
+
   private async Task ShowPlannerOptionTip()
   {
     await DialogService.OpenAsync("Planner Selection", ds =>
-  @<div>
-   In ARES, some planner services report the capability of using multiple types of planners. 
-   In this scenario, a seperate dropdown allows you to choose what planning method to use from the services advertised options.
-  </div>
-  , new DialogOptions() { CloseDialogOnOverlayClick = true });
+      @<div>
+        In ARES, some planner services report the capability of using multiple types of planners. 
+        In this scenario, a seperate dropdown allows you to choose what planning method to use from the services advertised options.
+      </div>
+    , new DialogOptions() { CloseDialogOnOverlayClick = true });
   }
-
 }
diff --git a/UI/Features/CampaignEdit/Views/Planning.razor b/UI/Features/CampaignEdit/Views/Planning.razor
index 46213ad3..c4e48e6f 100644
--- a/UI/Features/CampaignEdit/Views/Planning.razor
+++ b/UI/Features/CampaignEdit/Views/Planning.razor
@@ -1,16 +1,137 @@
-@using UI.Features.CampaignEdit.ViewModels
+@using Ares.Datamodel
+@using UI.Features.CampaignEdit.ViewModels
 @inherits ReactiveUI.Blazor.ReactiveComponentBase<PlanningViewModel>
 
-
 <div>
-  <p>Planning</p>
-  @foreach (var editor in ViewModel!.PlannerAllocationEditors)
+  @if(ViewModel is null)
   {
-    <PlannerAllocationEditor ViewModel="editor" />
+    <LoadingSpinner SpinnerSize="SpinnerSize.Large" />
   }
-</div>
+  else
+  {
+    <div class="two-column-container">
+      <div class="column left-column">
+        <h2>Planner Assignment</h2>
+        @if(ViewModel?.PlannerAllocationEditors is null)
+        {
+          <p><em>Loading allocations...</em></p>
+        }
+        else
+        {
+          @foreach(var editor in ViewModel.PlannerAllocationEditors)
+          {
+            <PlannerAllocationEditor ViewModel="editor" OnPlannerChanged="HandlePlannerAllocationChanged" />
+          }
+        }
+      </div>
+
+      <div class="column right-column">
+        <h2>Analyzer Objectives</h2>
+
+        @if(ViewModel is not null && !ViewModel.MultiObjectiveAllowed)
+        {
+          <RadzenAlert AlertStyle="AlertStyle.Info" Variant="Variant.Flat" Shade="Shade.Lighter" Size="AlertSize.Small" AllowClose="false" class="mb-2">
+            The currently selected planner does not support multi-objective optimization. Selecting an objective will replace your current selection.
+          </RadzenAlert>
+        }
+
+        @if(ViewModel?.AvailableObjectives is not null)
+        {
+          @foreach(var item in ViewModel.AvailableObjectives.Fields)
+          {
+            var isSelected = ViewModel!.SelectedObjectives.Contains(item);
+
+            <div class="card border-primary rounded-1 p-2 m-1">
+              <RadzenStack Orientation="Orientation.Horizontal" JustifyContent="JustifyContent.Start" Gap="0.5rem">
+                <RadzenColumn>
+                  <RadzenRow Style="padding-bottom: 0.5rem">
+                    Objective Name: @item.Key
+                  </RadzenRow>
 
+                  <RadzenRow Style="padding-bottom: 0.5rem">
+                    Objective Description: @item.Value.Description
+                  </RadzenRow>
+
+                  <RadzenRow Style="padding-bottom: 0.5rem">
+                    <RadzenLabel Component="IncludeInPlanningCheck" Text="Include in Planning? " />
+                    <RadzenCheckBox TValue="bool"
+                                    Name="IncludeInPlanningCheck"
+                                    Value="@isSelected"
+                                    Change="@(_ => ToggleSelection(item))"
+                                    @onclick:stopPropagation="true" />
+                  </RadzenRow>
+                </RadzenColumn>
+              </RadzenStack>
+            </div>
+          }
+        }
+        else
+        {
+          if(ViewModel!.AnalyzerName == "NONE")
+          {
+            <p>Select an Analyzer to See Objectives</p>
+          }
+          else
+          {
+            <p>Your Selected Analyer (@ViewModel!.AnalyzerName) Doesn't Report Any Objective Outputs</p>
+            <p>If your Analyzer was built prior to the multi-objective updates this is normal. Consider updating your Analyzer.</p>
+          }
+        }
+      </div>
+    </div>
+  }
+</div>
 
 @code {
+  protected override async Task OnInitializedAsync()
+  {
+    if(ViewModel is not null)
+    {
+      await ViewModel!.UpdateAnalyzerObjectives();
+      ViewModel!.RefreshMultiObjectiveCompatability();
+    }
     
+
+    await base.OnInitializedAsync();
+  }
+
+  private void ToggleSelection(KeyValuePair<string, AresValueSchema> item)
+  {
+    if(ViewModel is null)
+      return;
+
+    if(ViewModel.SelectedObjectives.Contains(item))
+    {
+      ViewModel.SelectedObjectives.Remove(item);
+    }
+    else
+    {
+      if(!ViewModel.MultiObjectiveAllowed)
+      {
+        ViewModel.SelectedObjectives.Clear();
+      }
+
+      ViewModel.SelectedObjectives.Add(item);
+    }
+
+    StateHasChanged();
+  }
+
+  private async Task HandlePlannerAllocationChanged()
+  {
+    if(ViewModel is null)
+      return;
+
+    ViewModel!.RefreshMultiObjectiveCompatability();
+
+    // If switching to a single-objective planner while multiple are selected, trim down to the first selection
+    if(!ViewModel.MultiObjectiveAllowed && ViewModel.SelectedObjectives.Count > 1)
+    {
+      var primarySelection = ViewModel.SelectedObjectives.First();
+      ViewModel.SelectedObjectives.Clear();
+      ViewModel.SelectedObjectives.Add(primarySelection);
+    }
+
+    StateHasChanged();
+  }
 }
\ No newline at end of file
diff --git a/UI/Features/CampaignEdit/Views/Planning.razor.css b/UI/Features/CampaignEdit/Views/Planning.razor.css
new file mode 100644
index 00000000..a8ee85bb
--- /dev/null
+++ b/UI/Features/CampaignEdit/Views/Planning.razor.css
@@ -0,0 +1,28 @@
+.two-column-container {
+	display: grid;
+	grid-template-columns: 1fr 1fr;
+	gap: 1.5rem;
+	width: 100%;
+	min-height: calc(100vh - 4rem);
+	padding: 0.5rem;
+	box-sizing: border-box;
+}
+
+.column {
+	border-radius: 1px;
+	overflow-y: auto;
+}
+
+.rz-switch .rz-switch-circle {
+	background: green !important;
+}
+
+.rz-switch.rz-switch-checked .rz-switch-circle {
+	background: red !important;
+}
+
+@media (max-width: 768px) {
+	.two-column-container {
+		grid-template-columns: 1fr;
+	}
+}
diff --git a/UI/Features/DataExplorer/AresDatasetTable.razor b/UI/Features/DataExplorer/AresDatasetTable.razor
index 1125295e..e92997ac 100644
--- a/UI/Features/DataExplorer/AresDatasetTable.razor
+++ b/UI/Features/DataExplorer/AresDatasetTable.razor
@@ -101,13 +101,59 @@ else
             : column.Name;
     }
 
-    private static string GetCellDisplayValue(AresDataRow row, AresDataColumn column)
+  private static string GetCellDisplayValue(AresDataRow row, AresDataColumn column)
+  {
+    if(row.Data?.Fields is null || string.IsNullOrEmpty(column.Name))
+      return string.Empty;
+
+    if(row.Data.Fields.TryGetValue(column.Name, out var directValue))
+      return directValue.Stringify();
+
+    if(column.Name.Contains('.'))
     {
-        if (row.Data?.Fields.TryGetValue(column.Name, out var value) != true)
+      var parts = column.Name.Split('.');
+      var currentStruct = row.Data;
+      AresValue? targetValue = null;
+
+      for(var i = 0; i < parts.Length; i++)
+      {
+        var part = parts[i];
+        if(currentStruct is null)
+          break;
+
+        if(!currentStruct.Fields.TryGetValue(part, out var childValue))
         {
-            return string.Empty;
+          var matchedKey = currentStruct.Fields.Keys
+              .FirstOrDefault(k => string.Equals(k, part, StringComparison.OrdinalIgnoreCase));
+
+          if(matchedKey is null || !currentStruct.Fields.TryGetValue(matchedKey, out childValue))
+            break;
         }
 
-        return value.Stringify();
+        if(i == parts.Length - 1)
+        {
+          targetValue = childValue;
+        }
+        else if(childValue.KindCase == AresValue.KindOneofCase.StructValue)
+        {
+          currentStruct = childValue.StructValue;
+        }
+        else
+        {
+          break;
+        }
+      }
+
+      if(targetValue is not null)
+        return targetValue.Stringify();
     }
+
+    var fallbackKey = row.Data.Fields.Keys
+        .FirstOrDefault(k => string.Equals(k, column.Name, StringComparison.OrdinalIgnoreCase));
+
+    if(fallbackKey is not null && row.Data.Fields.TryGetValue(fallbackKey, out var fallbackValue))
+      return fallbackValue.Stringify();
+
+    return string.Empty;
+  }
 }
diff --git a/UI/Features/Execution/Execution.razor b/UI/Features/Execution/Execution.razor
index f6d53649..bdb40c62 100644
--- a/UI/Features/Execution/Execution.razor
+++ b/UI/Features/Execution/Execution.razor
@@ -494,15 +494,26 @@
                 {
                   <RadzenChart Style="height: 260px; width: 100%;">
                     <RadzenChartTooltipOptions Shared="false" />
-                    <RadzenLineSeries Data="@ViewModel!.AnalyzerMetrics"
-                                      TItem="ChartMetricPoint"
-                                      CategoryProperty="ExecutionIndex"
-                                      ValueProperty="RawValue"
-                                      Title="Objective Score"
-                                      Stroke="#ff8db3">
-                      <RadzenMarkers MarkerType="MarkerType.Square" />
+                    @foreach(var analyzerSeries in ViewModel!.AnalyzerMetrics)
+                    {
+                      <RadzenLineSeries Data="@analyzerSeries.Value" TItem="ChartMetricPoint" CategoryProperty="ExecutionIndex" ValueProperty="PlotValue" Title="@analyzerSeries.Key" Stroke="#ff8db3">
+                        <ChildContent>
+                          <RadzenMarkers Visible="true" MarkerType="MarkerType.Circle" Size="6"/>
+                        </ChildContent>
+
+                        <TooltipTemplate Context="data">
+                          <div class="chart-tooltip">
+                            <span>@analyzerSeries.Key: </span>
+                            <strong>@data.RawValue</strong>
+                          </div>
+                        </TooltipTemplate>
                     </RadzenLineSeries>
+                    }
+
                     <RadzenCategoryAxis Step="1" />
+                      <RadzenValueAxis Min="0" Max="100" Step="25">
+                        <RadzenGridLines Visible="false" />
+                      </RadzenValueAxis>
                   </RadzenChart>
                 }
                 else
diff --git a/UI/Features/Execution/ExecutionViewModel.cs b/UI/Features/Execution/ExecutionViewModel.cs
index 856815f1..a550d04e 100644
--- a/UI/Features/Execution/ExecutionViewModel.cs
+++ b/UI/Features/Execution/ExecutionViewModel.cs
@@ -401,11 +401,7 @@ public async Task UpdatePlannerTransactions()
 
   public void OnPlannerTransactionReceived(PlannerTransaction transaction, int currentTurn)
   {
-    if(transaction.PlanningResponse.PlannedParameters.Any())
-      foreach(var field in transaction.PlanningResponse.PlannedParameters)
-        ProcessTransactionParameterData(field, transaction, currentTurn);
-
-    else if(transaction.PlanningResponse.Plans.Any())
+    if(transaction.PlanningResponse.Plans.Any())
     {
       foreach(var plan in transaction.PlanningResponse.Plans)
       {
@@ -422,13 +418,7 @@ private int DeterminePlanCount(IEnumerable<PlannerTransaction> transactionList)
     var count = 0;
 
     foreach(var transaction in transactionList)
-    {
-      if(transaction.PlanningResponse.PlannedParameters.Any())
-        count++;
-
-      else
-        count += transaction.PlanningResponse.Plans.Count();
-    }
+     count += transaction.PlanningResponse.Plans.Count();
 
     return count;
   }
@@ -463,11 +453,22 @@ private void ProcessTransactionParameterData(PlannedParameter field, PlannerTran
 
   public void OnAnalyzerTransactionReceived(AnalyzerTransaction transaction, int currentTurn)
   {
-    AnalyzerMetrics.Add(new ChartMetricPoint
+    foreach(var objective in transaction.AnalyzerResponse.Objectives)
     {
-      ExecutionIndex = currentTurn,
-      RawValue = transaction.AnalysisResponse.Result
-    }); 
+      var found = objective.ObjectiveValue.TryGetNumericValue(out var numericValue);
+      if(!found)
+        return;
+
+      if(!AnalyzerMetrics.ContainsKey(objective.ObjectiveName))
+        AnalyzerMetrics[objective.ObjectiveName] = new List<ChartMetricPoint>();
+
+      AnalyzerMetrics[objective.ObjectiveName].Add(new ChartMetricPoint
+      {
+        ExecutionIndex = currentTurn,
+        RawValue = numericValue,
+        PlotValue = numericValue
+      });      
+    }
   }
 
   public bool TryGetChartableValue(AresValue aresValue, out double result)
@@ -813,7 +814,7 @@ public int ActiveExperimentNumber
   [Reactive]
   public partial Dictionary<string, List<ChartMetricPoint>> PlannerMetricsMap { get; private set; }
   [Reactive]
-  public partial List<ChartMetricPoint> AnalyzerMetrics { get; private set; }
+  public partial Dictionary<string, List<ChartMetricPoint>> AnalyzerMetrics { get; private set; }
   [Reactive]
   public partial IList<ExperimentExecutionStatus> ExperimentExecutionStatuses { get; private set; }
   [Reactive]
diff --git a/UI/Features/Planning/Settings/Layout/PlannerSettingsContainer.razor b/UI/Features/Planning/Settings/Layout/PlannerSettingsContainer.razor
index 3995e9ce..c66353c4 100644
--- a/UI/Features/Planning/Settings/Layout/PlannerSettingsContainer.razor
+++ b/UI/Features/Planning/Settings/Layout/PlannerSettingsContainer.razor
@@ -4,8 +4,8 @@
   <h5 class="planner-settings-name">@Name</h5>
   @if(PlannerStatusGetter is not null)
   {
-    <div class="planner-status d-flex">
-      <button class="btn btn-sm border-0 rounded-circle btn-outline-primary mx-1" @onclick="UpdatePlannerStatus">
+    <div class="planner-status d-flex align-items-start">
+      <button class="btn btn-sm border-0 rounded-circle btn-outline-primary mx-1" @onclick="UpdatePlannerStatus" title="Refresh Status">
         <RadzenIcon Icon="refresh" />
       </button>
       @if(_plannerStatus is not null)
@@ -14,22 +14,34 @@
           <div class="planner-status-@_plannerStatus.State.ToString().ToLower()">
             @_plannerStatus.State.ToString()
           </div>
-          <div>
-            @if(_plannerStatus.State == State.Active && _plannerStatus.StateMessage == string.Empty)
+          
+          <div class="d-flex align-items-center gap-1">
+            @if(_plannerStatus.State == State.Active)
             {
-              <div>
-                Planner is Active!
-              </div>
+              <span>Planner is Active!</span>
             }
-
             else
             {
-              <div>
-                @_plannerStatus.StateMessage
-              </div>  
+              <span>Planner is Inactive</span>
+
+              <button class="btn btn-sm text-white d-inline-flex align-items-center gap-1 px-2 py-1 rounded"
+                      style="background-color: #343a40; border: 1px solid #222222; font-size: 0.85rem; color: #ffffff"
+                      type="button"
+                      @onclick="ToggleMessage"
+                      title="@(_isMessageExpanded ? "Hide Details" : "Show Details")">
+
+                <RadzenIcon Icon="@(_isMessageExpanded ? "expand_less" : "expand_more")" Style="font-size: 1rem; color: #ffffff;" />
+              </button>
             }
-            
           </div>
+
+          @if(_isMessageExpanded && !string.IsNullOrWhiteSpace(_plannerStatus.StateMessage))
+          {
+            <div class="small rounded p-2 mt-1 text-break text-white"
+                 style="max-width: 320px; background-color: #212529; border: 1px solid #343a40;">
+              @_plannerStatus.StateMessage
+            </div>
+          }
         </div>
       }
       else
@@ -72,6 +84,9 @@
   [Parameter]
   public Func<Task<StateResponse?>>? PlannerStatusGetter { get; set; }
 
+  private StateResponse? _plannerStatus;
+  private bool _isMessageExpanded;
+
   protected override async Task OnInitializedAsync()
   {
     if(PlannerStatusGetter is not null)
@@ -81,7 +96,10 @@
     }
   }
 
-  private StateResponse? _plannerStatus; 
+  private void ToggleMessage()
+  {
+    _isMessageExpanded = !_isMessageExpanded;
+  }
 
   private Task EditClicked()
   {
@@ -116,4 +134,4 @@
     await ActivateCallback();
     await UpdatePlannerStatus();
   }
-}
+}
\ No newline at end of file
diff --git a/UI/Infrastructure/Devices/RemoteDeviceAdapter.cs b/UI/Infrastructure/Devices/RemoteDeviceAdapter.cs
index a8c53856..353edcbf 100644
--- a/UI/Infrastructure/Devices/RemoteDeviceAdapter.cs
+++ b/UI/Infrastructure/Devices/RemoteDeviceAdapter.cs
@@ -95,7 +95,7 @@ public async Task StartStateStream()
             return Task.CompletedTask;
         });
 
-        _logger.LogInformation("Started device state stream for device {}.", Name);
+        _logger.LogInformation("Started device state stream for device {name}.", Name);
         UpdateStatusIfChanged(ConnectionStatus.ConnectedToService);
 
         await _devicesClient.GetDeviceStateStream(new DeviceStateStreamRequest { DeviceId = Id, PollingSettings = _pollingSettings }, streamWriter, null);
diff --git a/UI/UI.csproj b/UI/UI.csproj
index 7fa99e00..b0823978 100644
--- a/UI/UI.csproj
+++ b/UI/UI.csproj
@@ -37,7 +37,7 @@
   </ItemGroup>
 
   <ItemGroup>
-		<PackageReference Include="ARES.Datamodel" Version="0.35.0" />
+		<PackageReference Include="ARES.Datamodel" Version="0.36.0" />
 		<PackageReference Include="BlazorMonaco" Version="3.5.0" />
     <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.2" />
     <PackageReference Include="CsvHelper" Version="33.1.0" />