diff --git a/src/AcDream.Core.Net/Messages/AllegianceRequests.cs b/src/AcDream.Core.Net/Messages/AllegianceRequests.cs
new file mode 100644
index 0000000..a7bac79
--- /dev/null
+++ b/src/AcDream.Core.Net/Messages/AllegianceRequests.cs
@@ -0,0 +1,57 @@
+using System.Buffers.Binary;
+
+namespace AcDream.Core.Net.Messages;
+
+/// <summary>
+/// Outbound allegiance GameActions. Both Swear and Break carry a
+/// single <c>uint32</c> target-guid payload inside the standard
+/// <c>0xF7B1</c> GameAction envelope.
+///
+/// <para>
+/// Wire layout (r11 §2.1 / §2.3):
+/// <code>
+///   u32 0xF7B1
+///   u32 gameActionSequence
+///   u32 subOpcode (0x001D or 0x001E)
+///   u32 targetGuid
+/// </code>
+/// </para>
+///
+/// <para>
+/// Server replies with <c>GameEventAllegianceUpdate</c> (0x0020) and
+/// <c>GameEventAllegianceAllegianceUpdateDone</c> (0x01C8) on success,
+/// or a <c>WeenieError</c> on failure (already sworn, already maxed
+/// vassals, target not online, etc — see r11 §2.1 for the full list).
+/// </para>
+/// </summary>
+public static class AllegianceRequests
+{
+    public const uint GameActionEnvelope = 0xF7B1u;
+    public const uint SwearOpcode = 0x001Du;
+    public const uint BreakOpcode = 0x001Eu;
+
+    /// <summary>Pledge yourself to the given patron.</summary>
+    public static byte[] BuildSwear(uint gameActionSequence, uint patronGuid)
+    {
+        return Build(gameActionSequence, SwearOpcode, patronGuid);
+    }
+
+    /// <summary>
+    /// Break your pledge to <paramref name="targetGuid"/>. Target can be
+    /// your patron (breaking from) OR your vassal (breaking them away).
+    /// </summary>
+    public static byte[] BuildBreak(uint gameActionSequence, uint targetGuid)
+    {
+        return Build(gameActionSequence, BreakOpcode, targetGuid);
+    }
+
+    private static byte[] Build(uint seq, uint sub, uint targetGuid)
+    {
+        byte[] body = new byte[16];
+        BinaryPrimitives.WriteUInt32LittleEndian(body,            GameActionEnvelope);
+        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(4),  seq);
+        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(8),  sub);
+        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(12), targetGuid);
+        return body;
+    }
+}
diff --git a/src/AcDream.Core/Allegiance/AllegianceTree.cs b/src/AcDream.Core/Allegiance/AllegianceTree.cs
new file mode 100644
index 0000000..2d68dd9
--- /dev/null
+++ b/src/AcDream.Core/Allegiance/AllegianceTree.cs
@@ -0,0 +1,183 @@
+using System;
+using System.Collections.Generic;
+
+namespace AcDream.Core.Allegiance;
+
+/// <summary>
+/// Per-character allegiance node. Retail allegiance is a strict tree:
+/// one patron per character, max 11 direct vassals, recursive depth.
+/// Rank capped at 10 (r11 §1, §4).
+///
+/// <para>
+/// Nodes know their own name + rank + allegiance XP pass-through
+/// history. The root (monarch) has <see cref="PatronGuid"/> = 0.
+/// </para>
+/// </summary>
+public sealed class AllegianceNode
+{
+    public uint Guid;
+    public string Name = "";
+    public uint PatronGuid;                 // 0 if this node IS the monarch
+    public int Rank;                        // 0 = unpledged / monarch; capped at 10
+    public long ExperienceCached;           // XP the client has seen pass up so far
+    public List<uint> VassalGuids { get; } = new();   // direct vassals only
+}
+
+/// <summary>
+/// Client-side mirror of the player's allegiance tree. Updates come
+/// from <see cref="AcDream.Core.Net.Messages.GameEventType.AllegianceUpdate"/>
+/// (0x0020). The full wire blob is complex — r11 §5 — so this class
+/// exposes a minimal API the UI can grow into:
+///
+/// <list type="bullet">
+///   <item><description>
+///     <c>UpsertNode</c> — called by the AllegianceUpdate handler
+///     when the server pushes a node refresh.
+///   </description></item>
+///   <item><description>
+///     <c>SetMonarch</c> — establishes the root.
+///   </description></item>
+///   <item><description>
+///     <c>RemoveNode</c> — handles break / leave.
+///   </description></item>
+///   <item><description>
+///     <c>GetAncestors</c> — walks up to the monarch.
+///   </description></item>
+///   <item><description>
+///     <c>GetDescendants</c> — flattens the subtree.
+///   </description></item>
+/// </list>
+///
+/// <para>
+/// Thread safety: single-threaded use from the render thread. Clone
+/// before reading from another thread.
+/// </para>
+/// </summary>
+public sealed class AllegianceTree
+{
+    private readonly Dictionary<uint, AllegianceNode> _byGuid = new();
+
+    public uint MonarchGuid { get; private set; }
+    public uint PlayerGuid { get; set; }      // whose-allegiance-this-is
+
+    public event Action? TreeChanged;
+
+    public int NodeCount => _byGuid.Count;
+
+    public AllegianceNode? Get(uint guid) =>
+        _byGuid.TryGetValue(guid, out var n) ? n : null;
+
+    public void SetMonarch(uint guid, string name)
+    {
+        MonarchGuid = guid;
+        var node = UpsertNodeInternal(guid, name, 0, rank: 0);
+        TreeChanged?.Invoke();
+    }
+
+    public AllegianceNode UpsertNode(uint guid, string name, uint patronGuid, int rank)
+    {
+        var node = UpsertNodeInternal(guid, name, patronGuid, rank);
+        TreeChanged?.Invoke();
+        return node;
+    }
+
+    private AllegianceNode UpsertNodeInternal(uint guid, string name, uint patronGuid, int rank)
+    {
+        if (!_byGuid.TryGetValue(guid, out var node))
+        {
+            node = new AllegianceNode { Guid = guid };
+            _byGuid[guid] = node;
+        }
+        node.Name = name;
+        node.PatronGuid = patronGuid;
+        node.Rank = Math.Clamp(rank, 0, 10);
+
+        // Keep parent's vassal list in sync with this node's declared
+        // patron. A node that changes patron is removed from the old
+        // patron's list and added to the new one.
+        if (patronGuid != 0 && _byGuid.TryGetValue(patronGuid, out var parent))
+        {
+            if (!parent.VassalGuids.Contains(guid))
+                parent.VassalGuids.Add(guid);
+        }
+
+        return node;
+    }
+
+    public bool RemoveNode(uint guid)
+    {
+        if (!_byGuid.TryGetValue(guid, out var node)) return false;
+        if (node.PatronGuid != 0 && _byGuid.TryGetValue(node.PatronGuid, out var parent))
+            parent.VassalGuids.Remove(guid);
+        _byGuid.Remove(guid);
+        // Cascade: orphaned descendants stay in the map with their
+        // patron pointer dangling; the UI can hide them or the next
+        // AllegianceUpdate will refresh them.
+        TreeChanged?.Invoke();
+        return true;
+    }
+
+    /// <summary>
+    /// Walk from <paramref name="guid"/> up to the monarch. Yields node
+    /// then patron then grand-patron, etc. Includes the starting node.
+    /// Stops if a cycle is detected (shouldn't happen — server enforces
+    /// acyclicity — but be defensive).
+    /// </summary>
+    public IEnumerable<AllegianceNode> GetAncestors(uint guid)
+    {
+        var seen = new HashSet<uint>();
+        uint cursor = guid;
+        while (cursor != 0 && seen.Add(cursor) && _byGuid.TryGetValue(cursor, out var node))
+        {
+            yield return node;
+            cursor = node.PatronGuid;
+        }
+    }
+
+    /// <summary>
+    /// Flatten the subtree rooted at <paramref name="rootGuid"/> in BFS
+    /// order. Includes the root itself.
+    /// </summary>
+    public IEnumerable<AllegianceNode> GetDescendants(uint rootGuid)
+    {
+        if (!_byGuid.TryGetValue(rootGuid, out var root)) yield break;
+        var queue = new Queue<AllegianceNode>();
+        queue.Enqueue(root);
+        while (queue.Count > 0)
+        {
+            var node = queue.Dequeue();
+            yield return node;
+            foreach (var vGuid in node.VassalGuids)
+                if (_byGuid.TryGetValue(vGuid, out var vassal))
+                    queue.Enqueue(vassal);
+        }
+    }
+
+    public void Clear()
+    {
+        _byGuid.Clear();
+        MonarchGuid = 0;
+        TreeChanged?.Invoke();
+    }
+}
+
+/// <summary>
+/// Retail XP passup formula (r11 §3.2). Vassal passes up a fraction of
+/// their earned XP each level:
+/// <code>
+///   passup = ((50 + 22.5 × loyaltyLevel) / 291) ×
+///            (1 + realTimeDays/730 × inGameDays/720) × earnedXp
+/// </code>
+/// </summary>
+public static class AllegianceMath
+{
+    public static long ComputePassup(long earnedXp, int loyaltyLevel,
+        double realTimeDays, double inGameDays)
+    {
+        double loyaltyScale = (50.0 + 22.5 * loyaltyLevel) / 291.0;
+        double ageScale     = 1.0 + (realTimeDays / 730.0) * (inGameDays / 720.0);
+        double passup       = earnedXp * loyaltyScale * ageScale;
+        if (passup < 0) passup = 0;
+        return (long)Math.Round(passup);
+    }
+}
diff --git a/tests/AcDream.Core.Net.Tests/Messages/AllegianceRequestsTests.cs b/tests/AcDream.Core.Net.Tests/Messages/AllegianceRequestsTests.cs
new file mode 100644
index 0000000..848d79c
--- /dev/null
+++ b/tests/AcDream.Core.Net.Tests/Messages/AllegianceRequestsTests.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Buffers.Binary;
+using AcDream.Core.Net.Messages;
+using Xunit;
+
+namespace AcDream.Core.Net.Tests.Messages;
+
+public sealed class AllegianceRequestsTests
+{
+    [Fact]
+    public void BuildSwear_EncodesOpcodeAndTarget()
+    {
+        byte[] body = AllegianceRequests.BuildSwear(gameActionSequence: 3, patronGuid: 0xAAAAu);
+
+        Assert.Equal(16, body.Length);
+        Assert.Equal(AllegianceRequests.GameActionEnvelope,
+            BinaryPrimitives.ReadUInt32LittleEndian(body));
+        Assert.Equal(3u,
+            BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(4)));
+        Assert.Equal(AllegianceRequests.SwearOpcode,
+            BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(8)));
+        Assert.Equal(0xAAAAu,
+            BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(12)));
+    }
+
+    [Fact]
+    public void BuildBreak_EncodesOpcodeAndTarget()
+    {
+        byte[] body = AllegianceRequests.BuildBreak(gameActionSequence: 5, targetGuid: 0xBBBBu);
+        Assert.Equal(AllegianceRequests.BreakOpcode,
+            BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(8)));
+        Assert.Equal(0xBBBBu,
+            BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(12)));
+    }
+}
diff --git a/tests/AcDream.Core.Tests/Allegiance/AllegianceTreeTests.cs b/tests/AcDream.Core.Tests/Allegiance/AllegianceTreeTests.cs
new file mode 100644
index 0000000..826e3fa
--- /dev/null
+++ b/tests/AcDream.Core.Tests/Allegiance/AllegianceTreeTests.cs
@@ -0,0 +1,110 @@
+using System.Linq;
+using AcDream.Core.Allegiance;
+using Xunit;
+
+namespace AcDream.Core.Tests.Allegiance;
+
+public sealed class AllegianceTreeTests
+{
+    [Fact]
+    public void SetMonarch_RegistersNode_FiresEvent()
+    {
+        var tree = new AllegianceTree();
+        int changes = 0;
+        tree.TreeChanged += () => changes++;
+
+        tree.SetMonarch(0xAA, "Bael'Zharon");
+        Assert.Equal(1, changes);
+        Assert.Equal(0xAAu, tree.MonarchGuid);
+        Assert.Equal(1, tree.NodeCount);
+    }
+
+    [Fact]
+    public void UpsertNode_NewPatron_AddsToVassalList()
+    {
+        var tree = new AllegianceTree();
+        tree.SetMonarch(0xAA, "Monarch");
+        tree.UpsertNode(0xBB, "Vassal", patronGuid: 0xAA, rank: 1);
+
+        var monarch = tree.Get(0xAA);
+        Assert.NotNull(monarch);
+        Assert.Contains(0xBBu, monarch!.VassalGuids);
+    }
+
+    [Fact]
+    public void UpsertNode_RankClamp_CapsAt10()
+    {
+        var tree = new AllegianceTree();
+        tree.SetMonarch(0xAA, "M");
+        var node = tree.UpsertNode(0xBB, "V", 0xAA, rank: 50);
+        Assert.Equal(10, node.Rank);
+    }
+
+    [Fact]
+    public void RemoveNode_RemovesFromParentVassalList()
+    {
+        var tree = new AllegianceTree();
+        tree.SetMonarch(0xAA, "M");
+        tree.UpsertNode(0xBB, "V", 0xAA, 1);
+        Assert.Single(tree.Get(0xAA)!.VassalGuids);
+
+        tree.RemoveNode(0xBB);
+        Assert.Empty(tree.Get(0xAA)!.VassalGuids);
+    }
+
+    [Fact]
+    public void GetAncestors_WalksToMonarch()
+    {
+        var tree = new AllegianceTree();
+        tree.SetMonarch(0xAA, "M");
+        tree.UpsertNode(0xBB, "V", 0xAA, 1);
+        tree.UpsertNode(0xCC, "VV", 0xBB, 2);
+        tree.UpsertNode(0xDD, "VVV", 0xCC, 3);
+
+        var chain = tree.GetAncestors(0xDD).Select(n => n.Name).ToArray();
+        Assert.Equal(new[] { "VVV", "VV", "V", "M" }, chain);
+    }
+
+    [Fact]
+    public void GetAncestors_HandlesCycleWithoutLooping()
+    {
+        // Corrupt data: defensive path. Treat a cycle as a stop.
+        var tree = new AllegianceTree();
+        tree.UpsertNode(0xAA, "A", patronGuid: 0xBB, rank: 1);
+        tree.UpsertNode(0xBB, "B", patronGuid: 0xAA, rank: 1);   // cycle
+
+        var walk = tree.GetAncestors(0xAA).Select(n => n.Guid).ToArray();
+        Assert.Equal(2, walk.Length);   // visits each exactly once
+    }
+
+    [Fact]
+    public void GetDescendants_BfsOrder()
+    {
+        var tree = new AllegianceTree();
+        tree.SetMonarch(0xAA, "M");
+        tree.UpsertNode(0xB0, "B0", 0xAA, 1);
+        tree.UpsertNode(0xB1, "B1", 0xAA, 1);
+        tree.UpsertNode(0xC0, "C0", 0xB0, 2);
+
+        var bfs = tree.GetDescendants(0xAA).Select(n => n.Name).ToArray();
+        Assert.Equal(new[] { "M", "B0", "B1", "C0" }, bfs);
+    }
+
+    [Fact]
+    public void AllegianceMath_Passup_KnownCase()
+    {
+        // 1000 XP, loyalty 10, 100 real-time days, 100 in-game days.
+        // loyaltyScale = (50 + 225) / 291 = 0.9450
+        // ageScale     = 1 + (100/730)*(100/720) = 1 + 0.0190 = 1.0190
+        // passup       = 1000 * 0.9450 * 1.0190 ≈ 963
+        long passup = AllegianceMath.ComputePassup(1000, 10, 100, 100);
+        Assert.InRange(passup, 960, 965);
+    }
+
+    [Fact]
+    public void AllegianceMath_Passup_ZeroClamp()
+    {
+        // Negative XP shouldn't be possible; passup is clamped at 0.
+        Assert.Equal(0, AllegianceMath.ComputePassup(-1000, 10, 0, 0));
+    }
+}