diff --git a/MultiversalDiplomacy/Adjudicate/MovementPhaseAdjudicator.cs b/MultiversalDiplomacy/Adjudicate/MovementPhaseAdjudicator.cs
index f8ec92a..d7dfd0e 100644
--- a/MultiversalDiplomacy/Adjudicate/MovementPhaseAdjudicator.cs
+++ b/MultiversalDiplomacy/Adjudicate/MovementPhaseAdjudicator.cs
@@ -387,7 +387,7 @@ public class MovementPhaseAdjudicator : IPhaseAdjudicator
         Dictionary<string, OrderHistory> newHistory = [];
         foreach (UnitOrder unitOrder in decisions.OfType<IsDislodged>().Select(d => d.Order))
         {
-            newHistory.Ensure(unitOrder.Unit.Season.Designation, () => new());
+            newHistory.Ensure(unitOrder.Unit.Season.Designation, () => new([], [], []));
             OrderHistory history = newHistory[unitOrder.Unit.Season.Designation];
             // TODO does this add every order to every season??
             history.Orders.Add(unitOrder);
diff --git a/MultiversalDiplomacy/Model/OrderHistory.cs b/MultiversalDiplomacy/Model/OrderHistory.cs
index 1621473..775c8cf 100644
--- a/MultiversalDiplomacy/Model/OrderHistory.cs
+++ b/MultiversalDiplomacy/Model/OrderHistory.cs
@@ -1,4 +1,4 @@
-using System.Collections.ObjectModel;
+using System.Text.Json.Serialization;
 
 using MultiversalDiplomacy.Orders;
 
@@ -18,10 +18,7 @@ public class OrderHistory
     /// </summary>
     public Dictionary<string, bool> DoesMoveOutcomes { get; }
 
-    public OrderHistory()
-        : this([], [], [])
-    {}
-
+    [JsonConstructor]
     public OrderHistory(
         List<UnitOrder> orders,
         Dictionary<string, bool> isDislodgedOutcomes,
diff --git a/MultiversalDiplomacy/Orders/Order.cs b/MultiversalDiplomacy/Orders/Order.cs
index a8f1900..fd29151 100644
--- a/MultiversalDiplomacy/Orders/Order.cs
+++ b/MultiversalDiplomacy/Orders/Order.cs
@@ -1,3 +1,5 @@
+using System.Text.Json.Serialization;
+
 using MultiversalDiplomacy.Model;
 
 namespace MultiversalDiplomacy.Orders;
@@ -5,6 +7,16 @@ namespace MultiversalDiplomacy.Orders;
 /// <summary>
 /// A submitted action by a power.
 /// </summary>
+[JsonPolymorphic(TypeDiscriminatorPropertyName = "type")]
+[JsonDerivedType(typeof(BuildOrder), typeDiscriminator: "move")]
+[JsonDerivedType(typeof(ConvoyOrder), typeDiscriminator: "convoy")]
+[JsonDerivedType(typeof(DisbandOrder), typeDiscriminator: "disband")]
+[JsonDerivedType(typeof(HoldOrder), typeDiscriminator: "hold")]
+[JsonDerivedType(typeof(MoveOrder), typeDiscriminator: "move")]
+[JsonDerivedType(typeof(RetreatOrder), typeDiscriminator: "retreat")]
+[JsonDerivedType(typeof(SupportHoldOrder), typeDiscriminator: "supportHold")]
+[JsonDerivedType(typeof(SupportMoveOrder), typeDiscriminator: "supportMove")]
+[JsonDerivedType(typeof(SustainOrder), typeDiscriminator: "sustain")]
 public abstract class Order
 {
     /// <summary>
diff --git a/MultiversalDiplomacy/Orders/UnitOrder.cs b/MultiversalDiplomacy/Orders/UnitOrder.cs
index e6d1f6d..74e03f1 100644
--- a/MultiversalDiplomacy/Orders/UnitOrder.cs
+++ b/MultiversalDiplomacy/Orders/UnitOrder.cs
@@ -1,3 +1,5 @@
+using System.Text.Json.Serialization;
+
 using MultiversalDiplomacy.Model;
 
 namespace MultiversalDiplomacy.Orders;
@@ -5,6 +7,14 @@ namespace MultiversalDiplomacy.Orders;
 /// <summary>
 /// An order given to a specific unit.
 /// </summary>
+[JsonPolymorphic(TypeDiscriminatorPropertyName = "type")]
+[JsonDerivedType(typeof(ConvoyOrder), typeDiscriminator: "convoy")]
+[JsonDerivedType(typeof(DisbandOrder), typeDiscriminator: "disband")]
+[JsonDerivedType(typeof(HoldOrder), typeDiscriminator: "hold")]
+[JsonDerivedType(typeof(MoveOrder), typeDiscriminator: "move")]
+[JsonDerivedType(typeof(RetreatOrder), typeDiscriminator: "retreat")]
+[JsonDerivedType(typeof(SupportHoldOrder), typeDiscriminator: "supportHold")]
+[JsonDerivedType(typeof(SupportMoveOrder), typeDiscriminator: "supportMove")]
 public abstract class UnitOrder : Order
 {
     /// <summary>
diff --git a/MultiversalDiplomacyTests/SerializationTest.cs b/MultiversalDiplomacyTests/SerializationTest.cs
index c96c033..e7ab6e8 100644
--- a/MultiversalDiplomacyTests/SerializationTest.cs
+++ b/MultiversalDiplomacyTests/SerializationTest.cs
@@ -1,6 +1,7 @@
 using System.Text.Json;
 
 using MultiversalDiplomacy.Adjudicate;
+using MultiversalDiplomacy.Adjudicate.Decision;
 using MultiversalDiplomacy.Model;
 
 using NUnit.Framework;
@@ -64,19 +65,20 @@ public class SerializationTest
         Assert.That(tyr0, Is.NotDislodged);
         setup.UpdateWorld();
 
-        Assert.That(setup.World.OrderHistory["a0"].Orders.Count, Is.GreaterThan(0));
-        Assert.That(setup.World.OrderHistory["a0"].DoesMoveOutcomes.Count, Is.GreaterThan(0));
-        Assert.That(setup.World.OrderHistory["a0"].IsDislodgedOutcomes.Count, Is.GreaterThan(0));
+        Assert.That(setup.World.OrderHistory["a0"].Orders.Count, Is.GreaterThan(0), "Missing orders");
+        Assert.That(setup.World.OrderHistory["a0"].DoesMoveOutcomes.Count, Is.GreaterThan(0), "Missing moves");
+        Assert.That(setup.World.OrderHistory["a0"].IsDislodgedOutcomes.Count, Is.GreaterThan(0), "Missing dislodges");
 
         // Serialize and deserialize the world
         string serialized = JsonSerializer.Serialize(setup.World, Options);
-        // Console.WriteLine(serialized);
         World reserialized = JsonSerializer.Deserialize<World>(serialized, Options)
             ?? throw new AssertionException("Failed to reserialize world");
 
-        Assert.That(reserialized.OrderHistory["a0"].Orders.Count, Is.GreaterThan(0));
-        Assert.That(reserialized.OrderHistory["a0"].DoesMoveOutcomes.Count, Is.GreaterThan(0));
-        Assert.That(reserialized.OrderHistory["a0"].IsDislodgedOutcomes.Count, Is.GreaterThan(0));
+        Assert.Multiple(() => {
+            Assert.That(reserialized.OrderHistory["a0"].Orders.Count, Is.GreaterThan(0), "Missing orders");
+            Assert.That(reserialized.OrderHistory["a0"].DoesMoveOutcomes.Count, Is.GreaterThan(0), "Missing moves");
+            Assert.That(reserialized.OrderHistory["a0"].IsDislodgedOutcomes.Count, Is.GreaterThan(0), "Missing dislodges");
+        });
 
         // Resume the test case
         setup = new(reserialized, MovementPhaseAdjudicator.Instance);
@@ -88,10 +90,13 @@ public class SerializationTest
 
         setup.ValidateOrders();
         Assert.That(mun1, Is.Valid);
-        setup.AdjudicateOrders();
+        var adjudications = setup.AdjudicateOrders();
         Assert.That(mun1, Is.NotCut);
-        Assert.That(mun0, Is.Victorious);
-        Assert.That(tyr0, Is.Dislodged);
+        Console.WriteLine(string.Join(", ", adjudications.Select(a => a.ToString())));
+        DoesMove mun0move = adjudications.OfType<DoesMove>().Single(move => move.Order.Unit.Designation == mun0.Order.Unit.Designation);
+        Assert.That(mun0move.Outcome, Is.True);
+        IsDislodged tyr0dislodge = adjudications.OfType<IsDislodged>().Single(dis => dis.Order.Unit.Designation == tyr0.Order.Unit.Designation);
+        Assert.That(tyr0dislodge, Is.True);
 
         // Confirm that an alternate future is created.
         World world = setup.UpdateWorld();