diff --git a/src/Dapr/GuildServer.Host/GuildServerController.cs b/src/Dapr/GuildServer.Host/GuildServerController.cs
index 7254e1e636..c5d1b808c4 100644
--- a/src/Dapr/GuildServer.Host/GuildServerController.cs
+++ b/src/Dapr/GuildServer.Host/GuildServerController.cs
@@ -170,7 +170,7 @@ public ValueTask ChangeGuildMemberPositionAsync([FromBody] GuildMemberRoleChange
     [HttpPost(nameof(IGuildServer.ChangeGuildMemberPositionByNameAsync))]
     public ValueTask<bool> ChangeGuildMemberPositionByNameAsync([FromBody] GuildMemberRoleChangeByNameArguments data)
     {
-        return this._guildServer.ChangeGuildMemberPositionByNameAsync(data.GuildId, data.CharacterName, data.NewRole);
+        return this._guildServer.ChangeGuildMemberPositionByNameAsync(data.GuildId, data.CharacterName, data.NewRole, data.MasterTotalLevel);
     }
 
     /// <summary>
diff --git a/src/Dapr/ServerClients/GuildMemberRoleChangeByNameArguments.cs b/src/Dapr/ServerClients/GuildMemberRoleChangeByNameArguments.cs
index 259debd99c..6867bbcabb 100644
--- a/src/Dapr/ServerClients/GuildMemberRoleChangeByNameArguments.cs
+++ b/src/Dapr/ServerClients/GuildMemberRoleChangeByNameArguments.cs
@@ -9,4 +9,4 @@ namespace MUnique.OpenMU.ServerClients;
 /// <summary>
 /// Arguments for a guild member role change by character name.
 /// </summary>
-public record GuildMemberRoleChangeByNameArguments(uint GuildId, string CharacterName, GuildPosition NewRole);
+public record GuildMemberRoleChangeByNameArguments(uint GuildId, string CharacterName, GuildPosition NewRole, int MasterTotalLevel);
diff --git a/src/Dapr/ServerClients/GuildServer.cs b/src/Dapr/ServerClients/GuildServer.cs
index 60f57957bd..bd09213826 100644
--- a/src/Dapr/ServerClients/GuildServer.cs
+++ b/src/Dapr/ServerClients/GuildServer.cs
@@ -202,11 +202,11 @@ public async ValueTask ChangeGuildMemberPositionAsync(uint guildId, Guid charact
     }
 
     /// <inheritdoc />
-    public async ValueTask<bool> ChangeGuildMemberPositionByNameAsync(uint guildId, string characterName, GuildPosition role)
+    public async ValueTask<bool> ChangeGuildMemberPositionByNameAsync(uint guildId, string characterName, GuildPosition role, int masterTotalLevel)
     {
         try
         {
-            return await this._daprClient.InvokeMethodAsync<GuildMemberRoleChangeByNameArguments, bool>(this._targetAppId, nameof(this.ChangeGuildMemberPositionByNameAsync), new GuildMemberRoleChangeByNameArguments(guildId, characterName, role)).ConfigureAwait(false);
+            return await this._daprClient.InvokeMethodAsync<GuildMemberRoleChangeByNameArguments, bool>(this._targetAppId, nameof(this.ChangeGuildMemberPositionByNameAsync), new GuildMemberRoleChangeByNameArguments(guildId, characterName, role, masterTotalLevel)).ConfigureAwait(false);
         }
         catch (Exception ex)
         {
diff --git a/src/Directory.Packages.props b/src/Directory.Packages.props
index 94383d0c9b..28d7c55138 100644
--- a/src/Directory.Packages.props
+++ b/src/Directory.Packages.props
@@ -20,6 +20,7 @@
     <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="10.0.2" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.2" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore.Tools" Version="10.0.2" />
+    <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="10.0.2" />
     <PackageVersion Include="Microsoft.Extensions.Configuration.FileExtensions" Version="10.0.2" />
     <PackageVersion Include="Microsoft.Extensions.Configuration.Json" Version="10.0.2" />
     <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.2" />
diff --git a/src/Interfaces/GuildPositionComparer.cs b/src/Interfaces/GuildPositionComparer.cs
index 88c8b3c548..7af557e013 100644
--- a/src/Interfaces/GuildPositionComparer.cs
+++ b/src/Interfaces/GuildPositionComparer.cs
@@ -22,23 +22,6 @@ private GuildPositionComparer()
     /// </summary>
     public static GuildPositionComparer Instance { get; } = new();
 
-    /// <summary>
-    /// Gets the numerical rank for ordering purposes. A lower value means a higher rank.
-    /// </summary>
-    /// <param name="position">The guild position.</param>
-    /// <returns>The rank of the position.</returns>
-    private static int GetRank(GuildPosition position)
-    {
-        return position switch
-        {
-            GuildPosition.GuildMaster => 0,
-            GuildPosition.AssistantMaster => 1,
-            GuildPosition.BattleMaster => 2,
-            GuildPosition.NormalMember => 3,
-            _ => 4,
-        };
-    }
-
     /// <inheritdoc/>
     public int Compare(GuildPosition x, GuildPosition y)
     {
@@ -71,4 +54,21 @@ public int Compare(GuildListEntry? x, GuildListEntry? y)
 
         return StringComparer.OrdinalIgnoreCase.Compare(x.PlayerName, y.PlayerName);
     }
+
+    /// <summary>
+    /// Gets the numerical rank for ordering purposes. A lower value means a higher rank.
+    /// </summary>
+    /// <param name="position">The guild position.</param>
+    /// <returns>The rank of the position.</returns>
+    private static int GetRank(GuildPosition position)
+    {
+        return position switch
+        {
+            GuildPosition.GuildMaster => 0,
+            GuildPosition.AssistantMaster => 1,
+            GuildPosition.BattleMaster => 2,
+            GuildPosition.NormalMember => 3,
+            _ => 4,
+        };
+    }
 }
diff --git a/src/Interfaces/Properties/ModelResources.resx b/src/Interfaces/Properties/ModelResources.resx
index c2d2b3eb16..c0f8545de8 100644
--- a/src/Interfaces/Properties/ModelResources.resx
+++ b/src/Interfaces/Properties/ModelResources.resx
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <root>
   <resheader name="resmimetype">
     <value>text/microsoft-resx</value>
@@ -328,6 +328,12 @@
   <data name="GuildPosition_BattleMaster_Description" xml:space="preserve">
     <value></value>
   </data>
+  <data name="GuildPosition_AssistantMaster_Caption" xml:space="preserve">
+    <value>Assistant Master</value>
+  </data>
+  <data name="GuildPosition_AssistantMaster_Description" xml:space="preserve">
+    <value></value>
+  </data>
   <data name="LocalizableExceptionBase_TypeCaption" xml:space="preserve">
     <value>Localizable Exception Base</value>
   </data>
diff --git a/src/Persistence/EntityFramework/GuildServerContext.cs b/src/Persistence/EntityFramework/GuildServerContext.cs
index eb895bf44f..2e2aae3590 100644
--- a/src/Persistence/EntityFramework/GuildServerContext.cs
+++ b/src/Persistence/EntityFramework/GuildServerContext.cs
@@ -1,9 +1,10 @@
-// <copyright file="GuildServerContext.cs" company="MUnique">
+// <copyright file="GuildServerContext.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
 namespace MUnique.OpenMU.Persistence.EntityFramework;
 
+using System.Threading;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using MUnique.OpenMU.Persistence.EntityFramework.Model;
@@ -68,4 +69,51 @@ join character in this.Context.Set<CharacterName>() on member.Id equals characte
             .Include(g => g.RawMembers)
             .ToListAsync().ConfigureAwait(false);
     }
+
+    /// <inheritdoc/>
+    public async ValueTask<IReadOnlyList<DataModel.Entities.Guild>> GetGuildsOrderedByNameAsync(int skip, int count, CancellationToken cancellationToken = default)
+    {
+        return await this.Context.Set<Guild>()
+            .AsNoTracking()
+            .Include(g => g.RawMembers)
+            .Include(g => g.RawAllianceGuild)
+            .OrderBy(g => g.Name)
+            .Skip(skip)
+            .Take(count)
+            .ToListAsync(cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask<IReadOnlyList<DataModel.Entities.Guild>> SearchGuildsAsync(string searchTerm, int skip, int count, CancellationToken cancellationToken = default)
+    {
+        // Invariant: this runs in .NET, so it must not depend on the server's locale (see the
+        // equivalent remark in PlayerContext.SearchAccountsAsync). The ToLower() calls below are
+        // translated to the database's own lower(), which is why they cannot take a culture.
+        var term = searchTerm.ToLowerInvariant();
+        return await this.Context.Set<Guild>()
+            .AsNoTracking()
+            .Include(g => g.RawMembers)
+            .Include(g => g.RawAllianceGuild)
+            .Where(g => g.Name != null && g.Name.ToLower().Contains(term))
+            .OrderBy(g => g.Name)
+            .Skip(skip)
+            .Take(count)
+            .ToListAsync(cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask<IReadOnlyCollection<Guid>> GetAllianceMasterIdsAsync(IReadOnlyCollection<Guid> guildIds)
+    {
+        if (guildIds.Count == 0)
+        {
+            return [];
+        }
+
+        return await this.Context.Set<Guild>()
+            .AsNoTracking()
+            .Where(g => g.AllianceGuildId != null && guildIds.Contains(g.AllianceGuildId!.Value))
+            .Select(g => g.AllianceGuildId!.Value)
+            .Distinct()
+            .ToListAsync().ConfigureAwait(false);
+    }
 }
diff --git a/src/Persistence/IGuildServerContext.cs b/src/Persistence/IGuildServerContext.cs
index 7e2fd3a758..f0b9f48c54 100644
--- a/src/Persistence/IGuildServerContext.cs
+++ b/src/Persistence/IGuildServerContext.cs
@@ -1,9 +1,10 @@
-// <copyright file="IGuildServerContext.cs" company="MUnique">
+// <copyright file="IGuildServerContext.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
 namespace MUnique.OpenMU.Persistence;
 
+using System.Threading;
 using MUnique.OpenMU.Interfaces;
 
 /// <summary>
@@ -46,4 +47,31 @@ public interface IGuildServerContext : IContext
     /// <param name="guildId">The guild identifier.</param>
     /// <returns>The ids of the alliances of a guild.</returns>
     ValueTask<IReadOnlyList<DataModel.Entities.Guild>> GetAlliancesAsync(Guid guildId);
+
+    /// <summary>
+    /// Gets a page of guilds, ordered by name, without loading the whole guild table into memory.
+    /// </summary>
+    /// <param name="skip">The number of guilds to skip.</param>
+    /// <param name="count">The maximum number of guilds to return.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The requested page of guilds, including alliance and member information.</returns>
+    ValueTask<IReadOnlyList<DataModel.Entities.Guild>> GetGuildsOrderedByNameAsync(int skip, int count, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Searches guilds by name and returns a page of the matching results, without loading the whole guild table into memory.
+    /// </summary>
+    /// <param name="searchTerm">The case-insensitive search term which is matched against the guild name.</param>
+    /// <param name="skip">The number of matching guilds to skip.</param>
+    /// <param name="count">The maximum number of guilds to return.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The requested page of matching guilds, including alliance and member information.</returns>
+    ValueTask<IReadOnlyList<DataModel.Entities.Guild>> SearchGuildsAsync(string searchTerm, int skip, int count, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Of the given guild identifiers, returns the ones which are the master of an alliance
+    /// (i.e. at least one other guild points to them as their <see cref="Interfaces.Guild.AllianceGuild"/>).
+    /// </summary>
+    /// <param name="guildIds">The guild identifiers to check. Kept small (e.g. one page) to avoid a full table scan.</param>
+    /// <returns>The subset of <paramref name="guildIds"/> which are alliance masters.</returns>
+    ValueTask<IReadOnlyCollection<Guid>> GetAllianceMasterIdsAsync(IReadOnlyCollection<Guid> guildIds);
 }
diff --git a/src/Persistence/InMemory/GuildServerInMemoryContext.cs b/src/Persistence/InMemory/GuildServerInMemoryContext.cs
index 581d0c5ff3..d3a17b5fec 100644
--- a/src/Persistence/InMemory/GuildServerInMemoryContext.cs
+++ b/src/Persistence/InMemory/GuildServerInMemoryContext.cs
@@ -1,9 +1,10 @@
-// <copyright file="GuildServerInMemoryContext.cs" company="MUnique">
+// <copyright file="GuildServerInMemoryContext.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
 namespace MUnique.OpenMU.Persistence.InMemory;
 
+using System.Threading;
 using MUnique.OpenMU.Persistence.BasicModel;
 
 /// <summary>
@@ -64,4 +65,40 @@ public async ValueTask<IReadOnlyDictionary<Guid, string>> GetMemberNamesAsync(Gu
             .Where(g => g.AllianceGuild?.GetId() == guildId)
             .ToList();
     }
+
+    /// <inheritdoc/>
+    public async ValueTask<IReadOnlyList<DataModel.Entities.Guild>> GetGuildsOrderedByNameAsync(int skip, int count, CancellationToken cancellationToken = default)
+    {
+        var allGuilds = await this.Provider.GetRepository<DataModel.Entities.Guild>().GetAllAsync(cancellationToken).ConfigureAwait(false);
+        return allGuilds.OrderBy(g => g.Name).Skip(skip).Take(count).ToList();
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask<IReadOnlyList<DataModel.Entities.Guild>> SearchGuildsAsync(string searchTerm, int skip, int count, CancellationToken cancellationToken = default)
+    {
+        var allGuilds = await this.Provider.GetRepository<DataModel.Entities.Guild>().GetAllAsync(cancellationToken).ConfigureAwait(false);
+        return allGuilds
+            .Where(g => g.Name?.Contains(searchTerm, StringComparison.InvariantCultureIgnoreCase) == true)
+            .OrderBy(g => g.Name)
+            .Skip(skip)
+            .Take(count)
+            .ToList();
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask<IReadOnlyCollection<Guid>> GetAllianceMasterIdsAsync(IReadOnlyCollection<Guid> guildIds)
+    {
+        if (guildIds.Count == 0)
+        {
+            return [];
+        }
+
+        var guildIdSet = guildIds.ToHashSet();
+        var allGuilds = await this.Provider.GetRepository<DataModel.Entities.Guild>().GetAllAsync().ConfigureAwait(false);
+        return allGuilds
+            .Where(g => g.AllianceGuild is { } master && guildIdSet.Contains(master.GetId()))
+            .Select(g => g.AllianceGuild!.GetId())
+            .Distinct()
+            .ToList();
+    }
 }
diff --git a/src/Web/AdminPanel/Components/Layout/NavMenu.razor b/src/Web/AdminPanel/Components/Layout/NavMenu.razor
index 6ad2372d5e..6173143d0a 100644
--- a/src/Web/AdminPanel/Components/Layout/NavMenu.razor
+++ b/src/Web/AdminPanel/Components/Layout/NavMenu.razor
@@ -49,6 +49,18 @@
                     <span class="oi oi-people" aria-hidden="true" /> @Resources.OnlineAccounts
                   </NavLink>
                 </li>
+                <li class="nav-item px-3">
+                  <NavLink class="nav-link" href="guilds" @onclick="() => NavigationHistory.Clear()">
+                    <span class="oi oi-flag" aria-hidden="true" /> @Resources.Guilds
+                  </NavLink>
+                </li>
+                <AuthorizeView Policy="@AdminPolicies.Administrator">
+                    <li class="nav-item px-3">
+                        <NavLink class="nav-link" href="castle-siege" @onclick="() => NavigationHistory.Clear()">
+                            <span class="oi oi-shield" aria-hidden="true"></span> @Resources.CastleSiege
+                        </NavLink>
+                    </li>
+                </AuthorizeView>
                 @if (this.GameConfigurationId is { } gameConfigurationId )
                 {
                     <ConfigNavMenu GameConfigurationId="@gameConfigurationId" />
@@ -70,11 +82,6 @@
                 </li>
             }
             <AuthorizeView Policy="@AdminPolicies.Administrator">
-                <li class="nav-item px-3">
-                    <NavLink class="nav-link" href="castle-siege" @onclick="() => NavigationHistory.Clear()">
-                        <span class="oi oi-shield" aria-hidden="true"></span> @Resources.CastleSiege
-                    </NavLink>
-                </li>
                 <li class="nav-item px-3">
                     <NavLink class="nav-link" href="users" @onclick="() => NavigationHistory.Clear()">
                         <span class="oi oi-key" aria-hidden="true"></span> @Resources.Users
diff --git a/src/Web/AdminPanel/Components/PartyBadge.razor b/src/Web/AdminPanel/Components/PartyBadge.razor
index 924e548d09..9c65ca1699 100644
--- a/src/Web/AdminPanel/Components/PartyBadge.razor
+++ b/src/Web/AdminPanel/Components/PartyBadge.razor
@@ -1,10 +1,12 @@
+@using MUnique.OpenMU.Web.AdminPanel.Properties
+
 @if (PartyMaster is null || PartySize <= 0)
 {
-  <span class="text-muted">—</span>
+  <span class="text-muted">@Resources.EmptyValue</span>
 }
 else
 {
-  <span class="badge" title="Party of @PartyMaster: @PartySize members" style="background-color: @GetPartyColor(); color: #fff;">@PartyMaster (@PartySize)</span>
+  <span class="badge" title="@string.Format(Resources.PartyBadgeTitle, PartyMaster, PartySize)" style="background-color: @GetPartyColor(); color: #fff;">@PartyMaster (@PartySize)</span>
 }
 
 @code {
@@ -20,12 +22,5 @@ else
     [Parameter]
     public int PartySize { get; set; }
 
-    private string GetPartyColor()
-    {
-        // Deterministic hue per party master, so all members of one party share the same badge color
-        // and different parties are visually distinct.
-        var hash = System.HashCode.Combine(this.PartyMaster!.ToUpperInvariant());
-        var hue = ((hash % 360) + 360) % 360;
-        return $"hsl({hue}, 45%, 45%)";
-    }
+    private string GetPartyColor() => PartyColorHelper.GetPartyColor(this.PartyMaster!);
 }
diff --git a/src/Web/AdminPanel/Components/PartyColorHelper.cs b/src/Web/AdminPanel/Components/PartyColorHelper.cs
new file mode 100644
index 0000000000..fa4847b72b
--- /dev/null
+++ b/src/Web/AdminPanel/Components/PartyColorHelper.cs
@@ -0,0 +1,42 @@
+// <copyright file="PartyColorHelper.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.AdminPanel.Components;
+
+/// <summary>
+/// Assigns a stable badge color per party master, so all members of one party share
+/// the same color and different parties are visually distinct.
+/// Uses FNV-1a instead of the process-randomized string hash function, so colors
+/// don't change on every restart of the admin panel.
+/// </summary>
+public static class PartyColorHelper
+{
+    /// <summary>
+    /// Gets the badge background color for the given party master.
+    /// </summary>
+    /// <param name="partyMaster">The character name of the party master.</param>
+    public static string GetPartyColor(string partyMaster)
+    {
+        return $"hsl({Fnv1aUpperInvariant(partyMaster) % 360}, 45%, 45%)";
+    }
+
+    /// <summary>
+    /// Computes the 32-bit FNV-1a hash of the value, folding casing without allocating.
+    /// </summary>
+    /// <param name="value">The value to hash.</param>
+    internal static uint Fnv1aUpperInvariant(string value)
+    {
+        const uint offsetBasis = 2166136261;
+        const uint prime = 16777619;
+
+        var hash = offsetBasis;
+        foreach (var c in value)
+        {
+            hash ^= char.ToUpperInvariant(c);
+            hash *= prime;
+        }
+
+        return hash;
+    }
+}
diff --git a/src/Web/AdminPanel/Pages/Alliance.razor b/src/Web/AdminPanel/Pages/Alliance.razor
new file mode 100644
index 0000000000..ef7fe808df
--- /dev/null
+++ b/src/Web/AdminPanel/Pages/Alliance.razor
@@ -0,0 +1,53 @@
+@page "/alliance/{GuildId:guid}"
+@using MUnique.OpenMU.Web.Shared.Models;
+@using Resources = MUnique.OpenMU.Web.AdminPanel.Properties.Resources
+
+@if (this._alliance is null && !this._isLoading)
+{
+    <PageTitle>OpenMU: @Resources.Alliance</PageTitle>
+    <Breadcrumb IsFirstFromRoot="false" Caption="@Resources.Alliance" />
+    <div class="alert alert-warning" role="alert">@Resources.GuildNotFound</div>
+    <NavLink href="guilds" class="btn btn-secondary">&lt; @Resources.Back</NavLink>
+}
+else if (this._alliance is { } alliance)
+{
+    <PageTitle>OpenMU: @alliance.Master.Name</PageTitle>
+    <Breadcrumb IsFirstFromRoot="false" Caption="@alliance.Master.Name" />
+    <div class="d-flex flex-row align-items-center gap-3">
+        <NavLink href="guilds" class="btn btn-secondary">&lt; @Resources.Back</NavLink>
+        <GuildLogo Logo="@alliance.Master.Logo" Size="32" class="border rounded-1" />
+        <h1 class="mb-0">@Resources.Alliance: @alliance.Master.Name</h1>
+    </div>
+    <hr />
+
+    <div class="table-responsive">
+        <table class="table table-striped table-hover">
+            <thead>
+                <tr>
+                    <th>@Resources.Guild</th>
+                    <th>@Resources.Members</th>
+                    <th>@Resources.Score</th>
+                </tr>
+            </thead>
+            <tbody>
+                @foreach (var guild in alliance.Guilds)
+                {
+                    <tr @key="guild.Id">
+                        <td>
+                            <span class="d-inline-flex align-items-center">
+                                <GuildLogo Logo="@guild.Logo" Size="20" class="me-2 border rounded-1" />
+                                <NavLink href="@($"guild/{guild.Id}")">@guild.Name</NavLink>
+                            </span>
+                        </td>
+                        <td>@guild.MemberCount</td>
+                        <td>@guild.Score</td>
+                    </tr>
+                }
+            </tbody>
+        </table>
+    </div>
+}
+else
+{
+    <PageTitle>OpenMU: @Resources.Alliance</PageTitle>
+}
diff --git a/src/Web/AdminPanel/Pages/Alliance.razor.cs b/src/Web/AdminPanel/Pages/Alliance.razor.cs
new file mode 100644
index 0000000000..cb0d0811c8
--- /dev/null
+++ b/src/Web/AdminPanel/Pages/Alliance.razor.cs
@@ -0,0 +1,52 @@
+// <copyright file="Alliance.razor.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.AdminPanel.Pages;
+
+using Microsoft.AspNetCore.Components;
+using MUnique.OpenMU.Web.Shared.Models;
+using MUnique.OpenMU.Web.Shared.Services;
+
+/// <summary>
+/// Page which shows the guilds of an alliance.
+/// </summary>
+public partial class Alliance : ComponentBase
+{
+    private AllianceDetails? _alliance;
+
+    private bool _isLoading = true;
+
+    /// <summary>
+    /// Gets or sets the persistent identifier of any guild in the alliance.
+    /// </summary>
+    [Parameter]
+    public Guid GuildId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the guild service.
+    /// </summary>
+    [Inject]
+    public IGuildService GuildService { get; set; } = null!;
+
+    /// <summary>
+    /// Gets or sets the loading overlay service.
+    /// </summary>
+    [Inject]
+    public LoadingOverlayService LoadingService { get; set; } = null!;
+
+    /// <inheritdoc />
+    protected override async Task OnParametersSetAsync()
+    {
+        await base.OnParametersSetAsync().ConfigureAwait(true);
+        using var loading = this.LoadingService.ShowLoadingIndicator();
+        this._isLoading = true;
+        this._alliance = null;
+        await this.InvokeAsync(this.StateHasChanged).ConfigureAwait(true);
+
+        this._alliance = await this.GuildService.GetAllianceAsync(this.GuildId).ConfigureAwait(true);
+
+        this._isLoading = false;
+        await this.InvokeAsync(this.StateHasChanged).ConfigureAwait(true);
+    }
+}
diff --git a/src/Web/AdminPanel/Pages/Guild.razor b/src/Web/AdminPanel/Pages/Guild.razor
new file mode 100644
index 0000000000..f95dc8b2be
--- /dev/null
+++ b/src/Web/AdminPanel/Pages/Guild.razor
@@ -0,0 +1,92 @@
+@page "/guild/{GuildId:guid}"
+@using MUnique.OpenMU.DataModel
+@using MUnique.OpenMU.Web.Shared.Models;
+@using Resources = MUnique.OpenMU.Web.AdminPanel.Properties.Resources
+
+@if (this._guild is null && !this._isLoading)
+{
+    <PageTitle>OpenMU: @Resources.Guild</PageTitle>
+    <Breadcrumb IsFirstFromRoot="false" Caption="@Resources.Guild" />
+    <div class="alert alert-warning" role="alert">@Resources.GuildNotFound</div>
+    <NavLink href="guilds" class="btn btn-secondary">&lt; @Resources.Back</NavLink>
+}
+else if (this._guild is { } guild)
+{
+    <PageTitle>OpenMU: @guild.Name</PageTitle>
+    <Breadcrumb IsFirstFromRoot="false" Caption="@guild.Name" />
+    <div class="d-flex flex-row align-items-center gap-3">
+        <NavLink href="guilds" class="btn btn-secondary">&lt; @Resources.Back</NavLink>
+        <GuildLogo Logo="@guild.Logo" Size="32" class="border rounded-1" />
+        <h1 class="mb-0">@guild.Name</h1>
+    </div>
+    <hr />
+
+    <dl class="row">
+        <dt class="col-sm-2">@Resources.Score</dt>
+        <dd class="col-sm-10">@guild.Score</dd>
+        <dt class="col-sm-2">@Resources.Members</dt>
+        <dd class="col-sm-10">@guild.MemberCount</dd>
+        @if (!string.IsNullOrEmpty(guild.Notice))
+        {
+            <dt class="col-sm-2">@Resources.Notice</dt>
+            <dd class="col-sm-10">@guild.Notice</dd>
+        }
+        <dt class="col-sm-2">@Resources.Alliance</dt>
+        <dd class="col-sm-10">
+            <AllianceLink AllianceId="@guild.AllianceGuildId" AllianceName="@guild.AllianceName" EmptyText="@Resources.EmptyValue" />
+        </dd>
+    </dl>
+
+    <h2>@Resources.Members</h2>
+    @if (this._isLoading)
+    {
+        <p><em>@Resources.Loading</em></p>
+    }
+    else if (this._members.Count == 0)
+    {
+        <p><em>@Resources.EmptyValue</em></p>
+    }
+    else
+    {
+        <div class="table-responsive">
+            <table class="table table-striped table-hover">
+                <thead>
+                    <tr>
+                        <th>@Resources.Character</th>
+                        <th>@Resources.Account</th>
+                        <th>@Resources.CharacterClass</th>
+                        <th>@Resources.Level</th>
+                        <th>@Resources.MasterLevel</th>
+                        <th>@Resources.Position</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    @foreach (var member in this._members)
+                    {
+                        <tr>
+                            <td>
+                                @if (member.AccountId is { } accountId)
+                                {
+                                    <NavLink href="@AdminRoutes.EditCharacter(accountId, member.CharacterId)">@member.CharacterName</NavLink>
+                                }
+                                else
+                                {
+                                    @member.CharacterName
+                                }
+                            </td>
+                            <td>@(member.AccountLoginName ?? Resources.EmptyValue)</td>
+                            <td>@(member.CharacterClass ?? Resources.EmptyValue)</td>
+                            <td>@member.Level</td>
+                            <td>@member.MasterLevel</td>
+                            <td>@member.Position.GetEnumCaption()</td>
+                        </tr>
+                    }
+                </tbody>
+            </table>
+        </div>
+    }
+}
+else
+{
+    <PageTitle>OpenMU: @Resources.Guild</PageTitle>
+}
diff --git a/src/Web/AdminPanel/Pages/Guild.razor.cs b/src/Web/AdminPanel/Pages/Guild.razor.cs
new file mode 100644
index 0000000000..24e7ca86e8
--- /dev/null
+++ b/src/Web/AdminPanel/Pages/Guild.razor.cs
@@ -0,0 +1,59 @@
+// <copyright file="Guild.razor.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.AdminPanel.Pages;
+
+using Microsoft.AspNetCore.Components;
+using MUnique.OpenMU.Web.Shared.Models;
+using MUnique.OpenMU.Web.Shared.Services;
+
+/// <summary>
+/// Page which shows the details of a single guild, including its members.
+/// </summary>
+public partial class Guild : ComponentBase
+{
+    private GuildListItem? _guild;
+
+    private IReadOnlyList<GuildMemberViewItem> _members = [];
+
+    private bool _isLoading = true;
+
+    /// <summary>
+    /// Gets or sets the persistent identifier of the guild.
+    /// </summary>
+    [Parameter]
+    public Guid GuildId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the guild service.
+    /// </summary>
+    [Inject]
+    public IGuildService GuildService { get; set; } = null!;
+
+    /// <summary>
+    /// Gets or sets the loading overlay service.
+    /// </summary>
+    [Inject]
+    public LoadingOverlayService LoadingService { get; set; } = null!;
+
+    /// <inheritdoc />
+    protected override async Task OnParametersSetAsync()
+    {
+        await base.OnParametersSetAsync().ConfigureAwait(true);
+        using var loading = this.LoadingService.ShowLoadingIndicator();
+        this._isLoading = true;
+        this._guild = null;
+        this._members = [];
+        await this.InvokeAsync(this.StateHasChanged).ConfigureAwait(true);
+
+        this._guild = await this.GuildService.GetGuildAsync(this.GuildId).ConfigureAwait(true);
+        if (this._guild is not null)
+        {
+            this._members = await this.GuildService.GetGuildMembersAsync(this.GuildId).ConfigureAwait(true);
+        }
+
+        this._isLoading = false;
+        await this.InvokeAsync(this.StateHasChanged).ConfigureAwait(true);
+    }
+}
diff --git a/src/Web/AdminPanel/Pages/Guilds.razor b/src/Web/AdminPanel/Pages/Guilds.razor
new file mode 100644
index 0000000000..12c0c6385c
--- /dev/null
+++ b/src/Web/AdminPanel/Pages/Guilds.razor
@@ -0,0 +1,41 @@
+@page "/guilds"
+@using MUnique.OpenMU.Web.Shared.Models;
+@using Resources = MUnique.OpenMU.Web.AdminPanel.Properties.Resources
+
+@inject IGuildService _guildService;
+
+<PageTitle>OpenMU: @Resources.Guilds</PageTitle>
+<Breadcrumb IsFirstFromRoot="true" Caption="@Resources.Guilds" />
+<h1>@Resources.Guilds</h1>
+
+<div>
+    <DataTable TItem=@GuildListItem>
+        <TableHeader>
+            <th class="col-3">@Resources.Guild</th>
+            <th class="col-1">@Resources.Members</th>
+            <th class="col-1">@Resources.Score</th>
+            <th class="col-3">@Resources.Alliance</th>
+        </TableHeader>
+        <FilterHeader>
+            <th colspan="4">
+                <div class="input-group">
+                    <span class="input-group-text"><span class="oi oi-magnifying-glass" aria-hidden="true"></span></span>
+                    <input class="form-control small" type="search" autofocus @bind="@this._guildService.SearchFilter" @bind:event="oninput" placeholder="@Resources.Search ..."/>
+                </div>
+            </th>
+        </FilterHeader>
+        <ItemTemplate Context="item">
+            <td>
+                <span class="d-inline-flex align-items-center">
+                    <GuildLogo Logo="@item.Logo" Size="20" class="me-2 border rounded-1" />
+                    <NavLink href="@($"guild/{item.Id}")">@item.Name</NavLink>
+                </span>
+            </td>
+            <td>@item.MemberCount</td>
+            <td>@item.Score</td>
+            <td>
+                <AllianceLink AllianceId="@item.AllianceGuildId" AllianceName="@item.AllianceName" EmptyText="@Resources.EmptyValue" />
+            </td>
+        </ItemTemplate>
+    </DataTable>
+</div>
diff --git a/src/Web/AdminPanel/Pages/LoggedIn.razor b/src/Web/AdminPanel/Pages/LoggedIn.razor
index 90ab5ec9b2..35b36d53d9 100644
--- a/src/Web/AdminPanel/Pages/LoggedIn.razor
+++ b/src/Web/AdminPanel/Pages/LoggedIn.razor
@@ -16,28 +16,28 @@
 
 <ul class="nav nav-tabs" role="tablist">
   <li class="nav-item" role="presentation">
-    <button type="button" role="tab" aria-selected="@(_activeTab == Tab.Players)"
-            class="nav-link @(_activeTab == Tab.Players ? "active" : null)"
-            @onclick="() => _activeTab = Tab.Players">
+    <button type="button" role="tab" id="tab-players" aria-controls="panel-players" aria-selected="@(this._activeTab == Tab.Players ? "true" : "false")"
+            class="nav-link @(this._activeTab == Tab.Players ? "active" : null)"
+            @onclick="() => this._activeTab = Tab.Players">
       @Resources.Players
     </button>
   </li>
-  @if (_showOfflevel)
+  @if (this._showOfflevel)
   {
     <li class="nav-item" role="presentation">
-      <button type="button" role="tab" aria-selected="@(_activeTab == Tab.Offlevel)"
-              class="nav-link @(_activeTab == Tab.Offlevel ? "active" : null)"
-              @onclick="() => _activeTab = Tab.Offlevel">
+      <button type="button" role="tab" id="tab-offlevel" aria-controls="panel-offlevel" aria-selected="@(this._activeTab == Tab.Offlevel ? "true" : "false")"
+              class="nav-link @(this._activeTab == Tab.Offlevel ? "active" : null)"
+              @onclick="() => this._activeTab = Tab.Offlevel">
         @Resources.OffLevelPlayers
       </button>
     </li>
   }
-  @if (_showBots)
+  @if (this._showBots)
   {
     <li class="nav-item" role="presentation">
-      <button type="button" role="tab" aria-selected="@(_activeTab == Tab.Bots)"
-              class="nav-link @(_activeTab == Tab.Bots ? "active" : null)"
-              @onclick="() => _activeTab = Tab.Bots">
+      <button type="button" role="tab" id="tab-bots" aria-controls="panel-bots" aria-selected="@(this._activeTab == Tab.Bots ? "true" : "false")"
+              class="nav-link @(this._activeTab == Tab.Bots ? "active" : null)"
+              @onclick="() => this._activeTab = Tab.Bots">
         @Resources.BotPlayers
       </button>
     </li>
@@ -45,21 +45,23 @@
 </ul>
 
 <div class="tab-content pt-3">
-  @if (_activeTab == Tab.Players)
+  @if (this._activeTab == Tab.Players)
   {
-    <div class="w-100" role="tabpanel">
+    <div class="w-100" role="tabpanel" id="panel-players" aria-labelledby="tab-players">
       <DataTable TItem=@LoggedInAccount>
         <TableHeader>
-          <th class="col-3">@typeof(Account).GetPropertyCaption(nameof(Account.LoginName))</th>
+          <th class="col-2">@typeof(Account).GetPropertyCaption(nameof(Account.LoginName))</th>
           <th class="col-2">@Resources.Character</th>
           <th class="col-1">@Resources.ServerID</th>
-          <th class="col-3">@Resources.Party</th>
+          <th class="col-2">@Resources.Guild</th>
+          <th class="col-2">@Resources.Party</th>
           <th class="col-3">@Resources.Action</th>
         </TableHeader>
         <ItemTemplate Context="item">
           <td>@item.LoginName</td>
-          <td>@(item.CharacterName ?? "—")</td>
+          <td>@(item.CharacterName ?? Resources.EmptyValue)</td>
           <td>@item.Server</td>
+          <td><GuildLink GuildId="@item.GuildId" GuildName="@item.GuildName" EmptyText="@Resources.EmptyValue" /></td>
           <td><PartyBadge PartyMaster="@item.PartyMaster" PartySize="@item.PartySize" /></td>
           <td>
             <button class="btn btn-warning btn-sm" type="button" @onclick="() => this.AccountService.SetAccountOfflineAsync(item)">
@@ -77,22 +79,24 @@
       </DataTable>
     </div>
   }
-  else if (_activeTab == Tab.Offlevel)
+  else if (this._activeTab == Tab.Offlevel)
   {
-    <div class="w-100" role="tabpanel">
+    <div class="w-100" role="tabpanel" id="panel-offlevel" aria-labelledby="tab-offlevel">
       <DataTable TItem=@OfflineAccount>
         <TableHeader>
           <th class="col-2">@typeof(Account).GetPropertyCaption(nameof(Account.LoginName))</th>
-          <th class="col-2">@Resources.Character</th>
+          <th class="col-1">@Resources.Character</th>
           <th class="col-1">@Resources.ServerID</th>
+          <th class="col-2">@Resources.Guild</th>
           <th class="col-2">@Resources.Party</th>
-          <th class="col-3">@Resources.StartedAt</th>
+          <th class="col-2">@Resources.StartedAt</th>
           <th class="col-2">@Resources.Action</th>
         </TableHeader>
         <ItemTemplate Context="item">
           <td>@item.LoginName</td>
-          <td>@(item.CharacterName ?? "—")</td>
+          <td>@(item.CharacterName ?? Resources.EmptyValue)</td>
           <td>@item.ServerId</td>
+          <td>@(item.GuildName ?? Resources.EmptyValue)</td>
           <td><PartyBadge PartyMaster="@item.PartyMaster" PartySize="@item.PartySize" /></td>
           <td>@item.StartedAt.ToString("yyyy-MM-dd HH:mm:ss") UTC</td>
           <td>
@@ -104,21 +108,23 @@
       </DataTable>
     </div>
   }
-  else
+  else if (this._activeTab == Tab.Bots)
   {
-    <div class="w-100" role="tabpanel">
+    <div class="w-100" role="tabpanel" id="panel-bots" aria-labelledby="tab-bots">
       <DataTable TItem=@BotAccount>
         <TableHeader>
-          <th class="col-3">@typeof(Account).GetPropertyCaption(nameof(Account.LoginName))</th>
+          <th class="col-2">@typeof(Account).GetPropertyCaption(nameof(Account.LoginName))</th>
           <th class="col-2">@Resources.Character</th>
           <th class="col-1">@Resources.ServerID</th>
-          <th class="col-3">@Resources.Party</th>
+          <th class="col-2">@Resources.Guild</th>
+          <th class="col-2">@Resources.Party</th>
           <th class="col-3">@Resources.StartedAt</th>
         </TableHeader>
         <ItemTemplate Context="item">
           <td>@item.LoginName</td>
-          <td>@(item.CharacterName ?? "—")</td>
+          <td>@(item.CharacterName ?? Resources.EmptyValue)</td>
           <td>@item.ServerId</td>
+          <td>@(item.GuildName ?? Resources.EmptyValue)</td>
           <td><PartyBadge PartyMaster="@item.PartyMaster" PartySize="@item.PartySize" /></td>
           <td>@item.StartedAt.ToString("yyyy-MM-dd HH:mm:ss") UTC</td>
         </ItemTemplate>
@@ -145,6 +151,8 @@
         base.OnInitialized();
         // Tabs are only shown when the corresponding feature plugin is active on an in-process game server.
         // In a distributed deployment the contexts aren't available, so the tabs stay hidden.
+        // An active plugin with no sessions renders as an empty list, so "disabled" (no tab)
+        // stays distinguishable from "enabled but idle" (empty tab).
         this._showOfflevel = this.OfflineService.IsOfflevelFeatureAvailable();
         this._showBots = this.BotService.IsBotFeatureAvailable();
     }
diff --git a/src/Web/AdminPanel/Properties/Resources.Designer.cs b/src/Web/AdminPanel/Properties/Resources.Designer.cs
index 0d876b6ea9..02492ae438 100644
--- a/src/Web/AdminPanel/Properties/Resources.Designer.cs
+++ b/src/Web/AdminPanel/Properties/Resources.Designer.cs
@@ -2314,29 +2314,110 @@ public static string OpenMUAdminPanel {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Off-level Players.
+        ///   Looks up a localized string similar to Guilds.
         /// </summary>
-        public static string OffLevelPlayers {
+        public static string Guilds {
             get {
-                return ResourceManager.GetString("OffLevelPlayers", resourceCulture);
+                return ResourceManager.GetString("Guilds", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Bot Players.
+        ///   Looks up a localized string similar to Guild.
         /// </summary>
-        public static string BotPlayers {
+        public static string Guild {
             get {
-                return ResourceManager.GetString("BotPlayers", resourceCulture);
+                return ResourceManager.GetString("Guild", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Party.
+        ///   Looks up a localized string similar to Alliance.
         /// </summary>
-        public static string Party {
+        public static string Alliance {
             get {
-                return ResourceManager.GetString("Party", resourceCulture);
+                return ResourceManager.GetString("Alliance", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Members.
+        /// </summary>
+        public static string Members {
+            get {
+                return ResourceManager.GetString("Members", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Score.
+        /// </summary>
+        public static string Score {
+            get {
+                return ResourceManager.GetString("Score", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Notice.
+        /// </summary>
+        public static string Notice {
+            get {
+                return ResourceManager.GetString("Notice", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Position.
+        /// </summary>
+        public static string Position {
+            get {
+                return ResourceManager.GetString("Position", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Character Class.
+        /// </summary>
+        public static string CharacterClass {
+            get {
+                return ResourceManager.GetString("CharacterClass", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Level.
+        /// </summary>
+        public static string Level {
+            get {
+                return ResourceManager.GetString("Level", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Master Level.
+        /// </summary>
+        public static string MasterLevel {
+            get {
+                return ResourceManager.GetString("MasterLevel", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Account.
+        /// </summary>
+        public static string Account {
+            get {
+                return ResourceManager.GetString("Account", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The guild was not found. It may have been deleted..
+        /// </summary>
+        public static string GuildNotFound {
+            get {
+                return ResourceManager.GetString("GuildNotFound", resourceCulture);
             }
         }
         
@@ -4202,5 +4283,50 @@ public static string CastleSiegeErrorUnexpected {
                 return ResourceManager.GetString("CastleSiegeErrorUnexpected", resourceCulture);
             }
         }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Off-level Players.
+        /// </summary>
+        public static string OffLevelPlayers {
+            get {
+                return ResourceManager.GetString("OffLevelPlayers", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Bot Players.
+        /// </summary>
+        public static string BotPlayers {
+            get {
+                return ResourceManager.GetString("BotPlayers", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Party.
+        /// </summary>
+        public static string Party {
+            get {
+                return ResourceManager.GetString("Party", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to —.
+        /// </summary>
+        public static string EmptyValue {
+            get {
+                return ResourceManager.GetString("EmptyValue", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Party of {0}: {1} members.
+        /// </summary>
+        public static string PartyBadgeTitle {
+            get {
+                return ResourceManager.GetString("PartyBadgeTitle", resourceCulture);
+            }
+        }
     }
 }
diff --git a/src/Web/AdminPanel/Properties/Resources.resx b/src/Web/AdminPanel/Properties/Resources.resx
index 68ad712df8..8fbf1bf101 100644
--- a/src/Web/AdminPanel/Properties/Resources.resx
+++ b/src/Web/AdminPanel/Properties/Resources.resx
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <root>
   <!-- 
     Microsoft ResX Schema 
@@ -1254,6 +1254,48 @@
   <data name="Party" xml:space="preserve">
     <value>Party</value>
   </data>
+  <data name="Guilds" xml:space="preserve">
+    <value>Guilds</value>
+  </data>
+  <data name="Guild" xml:space="preserve">
+    <value>Guild</value>
+  </data>
+  <data name="Alliance" xml:space="preserve">
+    <value>Alliance</value>
+  </data>
+  <data name="Members" xml:space="preserve">
+    <value>Members</value>
+  </data>
+  <data name="Score" xml:space="preserve">
+    <value>Score</value>
+  </data>
+  <data name="Notice" xml:space="preserve">
+    <value>Notice</value>
+  </data>
+  <data name="Position" xml:space="preserve">
+    <value>Position</value>
+  </data>
+  <data name="CharacterClass" xml:space="preserve">
+    <value>Character Class</value>
+  </data>
+  <data name="Level" xml:space="preserve">
+    <value>Level</value>
+  </data>
+  <data name="MasterLevel" xml:space="preserve">
+    <value>Master Level</value>
+  </data>
+  <data name="Account" xml:space="preserve">
+    <value>Account</value>
+  </data>
+  <data name="GuildNotFound" xml:space="preserve">
+    <value>The guild was not found. It may have been deleted.</value>
+  </data>
+  <data name="EmptyValue" xml:space="preserve">
+    <value>—</value>
+  </data>
+  <data name="PartyBadgeTitle" xml:space="preserve">
+    <value>Party of {0}: {1} members</value>
+  </data>
   <data name="AddChancePercent" xml:space="preserve">
     <value>Add chance (%)</value>
   </data>
diff --git a/src/Web/AdminPanel/Startup.cs b/src/Web/AdminPanel/Startup.cs
index a59f67ec97..9a1320349e 100644
--- a/src/Web/AdminPanel/Startup.cs
+++ b/src/Web/AdminPanel/Startup.cs
@@ -70,6 +70,10 @@ public void ConfigureServices(IServiceCollection services)
 
         services.AddScoped<AccountService>();
         services.AddScoped<IDataService<Account>>(serviceProvider => serviceProvider.GetService<AccountService>()!);
+        services.AddScoped<IGuildMemberEnricher, CharacterGuildMemberEnricher>();
+        services.AddScoped<GuildService>();
+        services.AddScoped<IGuildService>(serviceProvider => serviceProvider.GetRequiredService<GuildService>());
+        services.AddScoped<IDataService<GuildListItem>>(serviceProvider => serviceProvider.GetRequiredService<GuildService>());
 
         services.AddScoped<PlugInController>();
         services.AddScoped<IDataService<PlugInConfigurationViewItem>>(serviceProvider => serviceProvider.GetService<PlugInController>()!);
diff --git a/src/Web/AdminPanel/WebApplicationExtensions.cs b/src/Web/AdminPanel/WebApplicationExtensions.cs
index ba773cd8cb..d48a162050 100644
--- a/src/Web/AdminPanel/WebApplicationExtensions.cs
+++ b/src/Web/AdminPanel/WebApplicationExtensions.cs
@@ -70,6 +70,8 @@ public static WebApplicationBuilder AddAdminPanel(this WebApplicationBuilder bui
 
         services.AddToasts();
 
+        services.AddMemoryCache();
+
         services.AddScoped<ModalService>();
         services.AddScoped<IModalService>(sp => sp.GetRequiredService<ModalService>());
         services.AddScoped<ILookupController, PersistentObjectsLookupController>();
@@ -84,6 +86,10 @@ public static WebApplicationBuilder AddAdminPanel(this WebApplicationBuilder bui
         services.AddScoped<DataUpdateService>();
         services.AddScoped<AccountService>();
         services.AddScoped<IDataService<Account>>(serviceProvider => serviceProvider.GetService<AccountService>()!);
+        services.AddScoped<IGuildMemberEnricher, CharacterGuildMemberEnricher>();
+        services.AddScoped<GuildService>();
+        services.AddScoped<IGuildService>(serviceProvider => serviceProvider.GetRequiredService<GuildService>());
+        services.AddScoped<IDataService<GuildListItem>>(serviceProvider => serviceProvider.GetRequiredService<GuildService>());
         services.AddScoped<PlugInController>();
         services.AddScoped<IDataService<PlugInConfigurationViewItem>>(serviceProvider => serviceProvider.GetService<PlugInController>()!);
         services.AddScoped<ChatCommandController>();
diff --git a/src/Web/Shared/AdminRoutes.cs b/src/Web/Shared/AdminRoutes.cs
new file mode 100644
index 0000000000..ef47a64142
--- /dev/null
+++ b/src/Web/Shared/AdminRoutes.cs
@@ -0,0 +1,36 @@
+// <copyright file="AdminRoutes.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Shared;
+
+using MUnique.OpenMU.DataModel.Entities;
+
+/// <summary>
+/// Centralized route templates of the admin panel. Pages and link components
+/// should build their hrefs through these helpers instead of duplicating route strings.
+/// </summary>
+public static class AdminRoutes
+{
+    /// <summary>
+    /// Gets the route of the guild detail page.
+    /// </summary>
+    /// <param name="guildId">The persistent identifier of the guild.</param>
+    /// <returns>The route of the guild detail page.</returns>
+    public static string Guild(Guid guildId) => $"guild/{guildId}";
+
+    /// <summary>
+    /// Gets the route of the alliance page.
+    /// </summary>
+    /// <param name="guildId">The persistent identifier of the alliance master guild.</param>
+    /// <returns>The route of the alliance page.</returns>
+    public static string Alliance(Guid guildId) => $"alliance/{guildId}";
+
+    /// <summary>
+    /// Gets the route of the character edit page.
+    /// </summary>
+    /// <param name="accountId">The identifier of the account the character belongs to.</param>
+    /// <param name="characterId">The identifier of the character.</param>
+    /// <returns>The route of the character edit page.</returns>
+    public static string EditCharacter(Guid accountId, Guid characterId) => $"edit-account/{accountId}/{typeof(Character).FullName}/{characterId}";
+}
diff --git a/src/Web/Shared/Components/AllianceLink.razor b/src/Web/Shared/Components/AllianceLink.razor
new file mode 100644
index 0000000000..8bd3f32610
--- /dev/null
+++ b/src/Web/Shared/Components/AllianceLink.razor
@@ -0,0 +1,29 @@
+@if (this.AllianceId is { } allianceId)
+{
+    <NavLink href="@AdminRoutes.Alliance(allianceId)">@(this.AllianceName ?? this.EmptyText)</NavLink>
+}
+else
+{
+    @(this.AllianceName ?? this.EmptyText)
+}
+
+@code {
+    /// <summary>
+    /// Gets or sets the persistent identifier of the alliance master guild. If <c>null</c>, the name is rendered as plain text.
+    /// </summary>
+    [Parameter]
+    public Guid? AllianceId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the name of the alliance (its master guild).
+    /// </summary>
+    [Parameter]
+    public string? AllianceName { get; set; }
+
+    /// <summary>
+    /// Gets or sets the text which is rendered when no alliance name is available,
+    /// e.g. <c>Resources.EmptyValue</c> of the consuming page.
+    /// </summary>
+    [Parameter]
+    public string EmptyText { get; set; } = string.Empty;
+}
diff --git a/src/Web/Shared/Components/GuildLink.razor b/src/Web/Shared/Components/GuildLink.razor
new file mode 100644
index 0000000000..ca1a033fc1
--- /dev/null
+++ b/src/Web/Shared/Components/GuildLink.razor
@@ -0,0 +1,29 @@
+@if (this.GuildId is { } guildId)
+{
+    <NavLink href="@AdminRoutes.Guild(guildId)">@(this.GuildName ?? this.EmptyText)</NavLink>
+}
+else
+{
+    @(this.GuildName ?? this.EmptyText)
+}
+
+@code {
+    /// <summary>
+    /// Gets or sets the persistent identifier of the guild. If <c>null</c>, the name is rendered as plain text.
+    /// </summary>
+    [Parameter]
+    public Guid? GuildId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the name of the guild.
+    /// </summary>
+    [Parameter]
+    public string? GuildName { get; set; }
+
+    /// <summary>
+    /// Gets or sets the text which is rendered when no guild name is available,
+    /// e.g. <c>Resources.EmptyValue</c> of the consuming page.
+    /// </summary>
+    [Parameter]
+    public string EmptyText { get; set; } = string.Empty;
+}
diff --git a/src/Web/Shared/Components/GuildLogo.razor b/src/Web/Shared/Components/GuildLogo.razor
new file mode 100644
index 0000000000..13ff68eb07
--- /dev/null
+++ b/src/Web/Shared/Components/GuildLogo.razor
@@ -0,0 +1,66 @@
+@if (this.Logo is { Length: >= 32 })
+{
+    <svg viewBox="0 0 8 8" width="@this.Size" height="@this.Size" class="guild-logo @this.Class" style="shape-rendering: crispEdges; flex-shrink: 0;" aria-hidden="true">
+        @for (var y = 0; y < 8; y++)
+        {
+            @for (var x = 0; x < 8; x++)
+            {
+                var byteIndex = (y * 4) + (x / 2);
+                var colorIndex = (x % 2 == 0)
+                    ? (this.Logo[byteIndex] >> 4) & 0x0F
+                    : this.Logo[byteIndex] & 0x0F;
+
+                if (colorIndex > 0 && colorIndex < Palette.Length)
+                {
+                    <rect x="@x" y="@y" width="1" height="1" fill="@Palette[colorIndex]" />
+                }
+            }
+        }
+    </svg>
+}
+else
+{
+    <svg viewBox="0 0 8 8" width="@this.Size" height="@this.Size" class="guild-logo guild-logo-placeholder @this.Class" style="shape-rendering: crispEdges; flex-shrink: 0;" aria-hidden="true">
+        <rect x="0" y="0" width="8" height="8" fill="#dee2e6" />
+    </svg>
+}
+
+@code {
+    private static readonly string[] Palette =
+    [
+        "transparent", // 0: Transparent
+        "#000000",     // 1: Black
+        "#8c8a8d",     // 2: Gray
+        "#ffffff",     // 3: White
+        "#fe0000",     // 4: Red
+        "#ff8a00",     // 5: Orange
+        "#ffff00",     // 6: Yellow
+        "#8cff01",     // 7: Light Green
+        "#00ff00",     // 8: Green
+        "#01ff8d",     // 9: Teal
+        "#00ffff",     // 10: Cyan
+        "#008aff",     // 11: Light Blue
+        "#0000fe",     // 12: Dark Blue
+        "#8c00ff",     // 13: Purple
+        "#ff00fe",     // 14: Magenta
+        "#ff008c",     // 15: Pink
+    ];
+
+    /// <summary>
+    /// Gets or sets the raw 8x8 16-color logo bitmap data.
+    /// </summary>
+    [Parameter]
+    public byte[]? Logo { get; set; }
+
+    /// <summary>
+    /// Gets or sets the display size in pixels. Defaults to 20.
+    /// </summary>
+    [Parameter]
+    public int Size { get; set; } = 20;
+
+    /// <summary>
+    /// Gets or sets optional CSS classes.
+    /// </summary>
+    [Parameter]
+    public string? Class { get; set; }
+}
diff --git a/src/Web/Shared/MUnique.OpenMU.Web.Shared.csproj b/src/Web/Shared/MUnique.OpenMU.Web.Shared.csproj
index e5450a3718..be2d922b64 100644
--- a/src/Web/Shared/MUnique.OpenMU.Web.Shared.csproj
+++ b/src/Web/Shared/MUnique.OpenMU.Web.Shared.csproj
@@ -49,6 +49,7 @@
     <PackageReference Include="BCrypt.Net-Next" />
     <PackageReference Include="BlazorInputFile" />
     <PackageReference Include="Mapster" />
+    <PackageReference Include="Microsoft.Extensions.Caching.Memory" />
     <PackageReference Include="Microsoft.AspNetCore.Components.QuickGrid" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Core" />
diff --git a/src/Web/Shared/Models/AllianceDetails.cs b/src/Web/Shared/Models/AllianceDetails.cs
new file mode 100644
index 0000000000..457a6eddc6
--- /dev/null
+++ b/src/Web/Shared/Models/AllianceDetails.cs
@@ -0,0 +1,21 @@
+// <copyright file="AllianceDetails.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Shared.Models;
+
+/// <summary>
+/// Data transfer object for the admin panel alliance page.
+/// </summary>
+public class AllianceDetails
+{
+    /// <summary>
+    /// Gets or sets the alliance master guild.
+    /// </summary>
+    public GuildListItem Master { get; set; } = new();
+
+    /// <summary>
+    /// Gets or sets the guilds which are part of the alliance, including the master guild.
+    /// </summary>
+    public IReadOnlyList<GuildListItem> Guilds { get; set; } = [];
+}
diff --git a/src/Web/Shared/Models/GuildListItem.cs b/src/Web/Shared/Models/GuildListItem.cs
new file mode 100644
index 0000000000..bfb01b5d38
--- /dev/null
+++ b/src/Web/Shared/Models/GuildListItem.cs
@@ -0,0 +1,54 @@
+// <copyright file="GuildListItem.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Shared.Models;
+
+/// <summary>
+/// Data transfer object for a guild in the admin panel guild list and detail pages.
+/// </summary>
+public class GuildListItem
+{
+    /// <summary>
+    /// Gets or sets the persistent identifier of the guild.
+    /// </summary>
+    public Guid Id { get; set; }
+
+    /// <summary>
+    /// Gets or sets the name of the guild.
+    /// </summary>
+    public string Name { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the score of the guild.
+    /// </summary>
+    public int Score { get; set; }
+
+    /// <summary>
+    /// Gets or sets the notice of the guild.
+    /// </summary>
+    public string? Notice { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of members of the guild.
+    /// </summary>
+    public int MemberCount { get; set; }
+
+    /// <summary>
+    /// Gets or sets the persistent identifier of the alliance master guild, if this guild is part of an alliance.
+    /// This is set to <see cref="Id"/> itself when this guild is the alliance master, so that both member
+    /// guilds and the master guild can link to the same alliance page.
+    /// </summary>
+    public Guid? AllianceGuildId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the name of the alliance master guild, if this guild is part of an alliance.
+    /// This is set to <see cref="Name"/> itself when this guild is the alliance master.
+    /// </summary>
+    public string? AllianceName { get; set; }
+
+    /// <summary>
+    /// Gets or sets the raw 8x8 16-color logo bitmap data of the guild.
+    /// </summary>
+    public byte[]? Logo { get; set; }
+}
diff --git a/src/Web/Shared/Models/GuildMemberViewItem.cs b/src/Web/Shared/Models/GuildMemberViewItem.cs
new file mode 100644
index 0000000000..f62c5c0494
--- /dev/null
+++ b/src/Web/Shared/Models/GuildMemberViewItem.cs
@@ -0,0 +1,54 @@
+// <copyright file="GuildMemberViewItem.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Shared.Models;
+
+using MUnique.OpenMU.Interfaces;
+
+/// <summary>
+/// Data transfer object for a guild member in the admin panel guild detail page.
+/// </summary>
+public class GuildMemberViewItem
+{
+    /// <summary>
+    /// Gets or sets the identifier of the character. It is the same as the guild member identifier.
+    /// </summary>
+    public Guid CharacterId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the name of the character.
+    /// </summary>
+    public string CharacterName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the login name of the account the character belongs to, if known.
+    /// </summary>
+    public string? AccountLoginName { get; set; }
+
+    /// <summary>
+    /// Gets or sets the identifier of the account the character belongs to, if known.
+    /// It is required to link to the character edit page.
+    /// </summary>
+    public Guid? AccountId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the name of the character class, if known.
+    /// </summary>
+    public string? CharacterClass { get; set; }
+
+    /// <summary>
+    /// Gets or sets the level of the character.
+    /// </summary>
+    public int Level { get; set; }
+
+    /// <summary>
+    /// Gets or sets the master level of the character.
+    /// </summary>
+    public int MasterLevel { get; set; }
+
+    /// <summary>
+    /// Gets or sets the position of the member in the guild.
+    /// </summary>
+    public GuildPosition Position { get; set; }
+}
diff --git a/src/Web/Shared/Services/BotAccount.cs b/src/Web/Shared/Services/BotAccount.cs
index 3d37f9d4c0..45cf551c7c 100644
--- a/src/Web/Shared/Services/BotAccount.cs
+++ b/src/Web/Shared/Services/BotAccount.cs
@@ -11,6 +11,7 @@ namespace MUnique.OpenMU.Web.Shared.Services;
 /// <param name="ServerId">The server identifier.</param>
 /// <param name="CharacterName">The character which the bot is driving.</param>
 /// <param name="StartedAt">The start timestamp of the bot session.</param>
+/// <param name="GuildName">The guild of the character, if any.</param>
 /// <param name="PartyMaster">The character name of the party master, if the bot is in a party.</param>
 /// <param name="PartySize">The number of party members, if the bot is in a party.</param>
-public record BotAccount(string LoginName, byte ServerId, string? CharacterName, DateTime StartedAt, string? PartyMaster = null, int PartySize = 0) : IPartyGroupedAccount;
+public record BotAccount(string LoginName, byte ServerId, string? CharacterName, DateTime StartedAt, string? GuildName = null, string? PartyMaster = null, int PartySize = 0) : IPartyGroupedAccount;
diff --git a/src/Web/Shared/Services/BotAccountService.cs b/src/Web/Shared/Services/BotAccountService.cs
index dd5d4d73c6..b64bdf8e4a 100644
--- a/src/Web/Shared/Services/BotAccountService.cs
+++ b/src/Web/Shared/Services/BotAccountService.cs
@@ -4,6 +4,7 @@
 
 namespace MUnique.OpenMU.Web.Shared.Services;
 
+using Microsoft.Extensions.Caching.Memory;
 using MUnique.OpenMU.GameLogic;
 using MUnique.OpenMU.GameLogic.Bots;
 using MUnique.OpenMU.Interfaces;
@@ -16,15 +17,22 @@ namespace MUnique.OpenMU.Web.Shared.Services;
 /// </summary>
 public class BotAccountService : IDataService<BotAccount>
 {
+    private static readonly TimeSpan ListCacheLifetime = TimeSpan.FromSeconds(5);
+
+    private const string ListCacheKey = "BotAccountService.BotList";
+
     private readonly IServerProvider _serverProvider;
+    private readonly IMemoryCache _cache;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="BotAccountService"/> class.
     /// </summary>
     /// <param name="serverProvider">The server provider.</param>
-    public BotAccountService(IServerProvider serverProvider)
+    /// <param name="cache">The memory cache.</param>
+    public BotAccountService(IServerProvider serverProvider, IMemoryCache cache)
     {
         this._serverProvider = serverProvider;
+        this._cache = cache;
     }
 
     /// <summary>
@@ -38,26 +46,50 @@ public bool IsBotFeatureAvailable()
     }
 
     /// <inheritdoc />
+    /// <remarks>
+    /// The full list is cached for a few seconds: building it copies the whole player list of every
+    /// game server, while the table only renders one page. Paging applies on top of the cached,
+    /// globally ordered list, so party grouping stays correct across pages.
+    /// </remarks>
     public async Task<List<BotAccount>> GetAsync(int offset, int count)
     {
-        var result = new List<BotAccount>();
+        if (this._cache.TryGetValue<List<BotAccount>>(ListCacheKey, out var cached) && cached is not null)
+        {
+            return cached.Skip(offset).Take(count).ToList();
+        }
+
+        var rows = new List<(byte ServerId, BotPlayer Player)>();
         foreach (var server in this._serverProvider.Servers.OfType<IGameServerContextProvider>())
         {
             var serverId = (byte)((IManageableServer)server).Id;
             var players = await server.Context.GetPlayersAsync().ConfigureAwait(false);
-            result.AddRange(players
-                .OfType<BotPlayer>()
-                .Select(p => new BotAccount(
-                    p.Account?.LoginName ?? string.Empty,
-                    serverId,
-                    p.SelectedCharacter?.Name,
-                    p.StartTimestamp,
-                    p.Party?.PartyMaster?.Name,
-                    p.Party?.PartyList.Count ?? 0)));
+            rows.AddRange(players.OfType<BotPlayer>().Select(p => (serverId, p)));
         }
 
-        return result
+        var guilds = await GuildNames.ResolveAsync(
+                GuildNames.FindServer(this._serverProvider),
+                rows.Select(r => r.Player.GuildStatus?.GuildId).OfType<uint>())
+            .ConfigureAwait(false);
+
+        var ordered = rows
+            .Select(r =>
+            {
+                var (partyMaster, partySize) = PartyDisplay.From(r.Player.Party);
+                var guildId = r.Player.GuildStatus?.GuildId;
+                return new BotAccount(
+                    r.Player.Account?.LoginName ?? string.Empty,
+                    r.ServerId,
+                    r.Player.SelectedCharacter?.Name,
+                    r.Player.StartTimestamp,
+                    guildId is { } id ? guilds.GetValueOrDefault(id)?.Name : null,
+                    partyMaster,
+                    partySize);
+            })
             .OrderPartyGrouped()
+            .ToList();
+
+        this._cache.Set(ListCacheKey, ordered, ListCacheLifetime);
+        return ordered
             .Skip(offset)
             .Take(count)
             .ToList();
diff --git a/src/Web/Shared/Services/CharacterGuildMemberEnricher.cs b/src/Web/Shared/Services/CharacterGuildMemberEnricher.cs
new file mode 100644
index 0000000000..5e34c0b012
--- /dev/null
+++ b/src/Web/Shared/Services/CharacterGuildMemberEnricher.cs
@@ -0,0 +1,132 @@
+// <copyright file="CharacterGuildMemberEnricher.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Shared.Services;
+
+using Microsoft.Extensions.Logging;
+using MUnique.OpenMU.DataModel.Configuration;
+using MUnique.OpenMU.DataModel.Entities;
+using MUnique.OpenMU.GameLogic.Attributes;
+using MUnique.OpenMU.Persistence;
+using MUnique.OpenMU.Web.Shared.Models;
+
+/// <summary>
+/// Enriches guild members with character and account data by resolving them through a player context.
+/// </summary>
+public class CharacterGuildMemberEnricher : IGuildMemberEnricher
+{
+    private readonly IPersistenceContextProvider _contextProvider;
+    private readonly IDataSource<GameConfiguration> _gameConfigurationSource;
+    private readonly ILogger<CharacterGuildMemberEnricher> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CharacterGuildMemberEnricher"/> class.
+    /// </summary>
+    /// <param name="contextProvider">The persistence context provider.</param>
+    /// <param name="gameConfigurationSource">The game configuration source, required to create player contexts.</param>
+    /// <param name="logger">The logger.</param>
+    public CharacterGuildMemberEnricher(IPersistenceContextProvider contextProvider, IDataSource<GameConfiguration> gameConfigurationSource, ILogger<CharacterGuildMemberEnricher> logger)
+    {
+        this._contextProvider = contextProvider;
+        this._gameConfigurationSource = gameConfigurationSource;
+        this._logger = logger;
+    }
+
+    /// <inheritdoc />
+    public async Task EnrichAsync(IReadOnlyList<GuildMemberViewItem> members)
+    {
+        if (members.Count == 0)
+        {
+            return;
+        }
+
+        using var playerContext = await this.TryCreatePlayerContextAsync().ConfigureAwait(false);
+        if (playerContext is null)
+        {
+            return;
+        }
+
+        var accountCache = new Dictionary<string, Account?>(StringComparer.OrdinalIgnoreCase);
+        foreach (var member in members)
+        {
+            await this.EnrichWithCharacterDataAsync(playerContext, member, accountCache).ConfigureAwait(false);
+        }
+    }
+
+    private async Task<IPlayerContext?> TryCreatePlayerContextAsync()
+    {
+        try
+        {
+            var gameConfiguration = await this._gameConfigurationSource.GetOwnerAsync().ConfigureAwait(false);
+            return this._contextProvider.CreateNewPlayerContext(gameConfiguration);
+        }
+        catch (Exception ex)
+        {
+            this._logger.LogWarning(ex, "Failed to create a player context for guild member enrichment. Members are shown without character details.");
+            return null;
+        }
+    }
+
+    private async Task EnrichWithCharacterDataAsync(
+        IPlayerContext playerContext,
+        GuildMemberViewItem viewItem,
+        Dictionary<string, Account?> accountCache)
+    {
+        try
+        {
+            // NOTE: Do NOT use GetByIdAsync<Character> here. The generic EF repository path
+            // eagerly walks the full-model navigations, including config types
+            // (CharacterClass, AttributeDefinition, ...) which are excluded from the
+            // account DbContext model, so the load throws. Resolving through the account
+            // instead uses AccountRepository/AccountJsonObjectLoader - the same load path
+            // as login and account editing - which returns the full object graph.
+            Account? account;
+            if (accountCache.TryGetValue(viewItem.CharacterName, out var cachedAccount))
+            {
+                account = cachedAccount;
+            }
+            else
+            {
+                account = await playerContext.GetAccountByCharacterNameAsync(viewItem.CharacterName).ConfigureAwait(false);
+                accountCache[viewItem.CharacterName] = account;
+                if (account?.Characters is not null)
+                {
+                    foreach (var characterInAccount in account.Characters)
+                    {
+                        if (!string.IsNullOrEmpty(characterInAccount.Name))
+                        {
+                            accountCache[characterInAccount.Name] = account;
+                        }
+                    }
+                }
+            }
+
+            if (account is null)
+            {
+                return;
+            }
+
+            var character = account.Characters.FirstOrDefault(c => c.GetId() == viewItem.CharacterId)
+                ?? account.Characters.FirstOrDefault(c => c.Name == viewItem.CharacterName);
+            if (character is null)
+            {
+                return;
+            }
+
+            viewItem.CharacterName = character.Name;
+            viewItem.CharacterClass = character.CharacterClass?.Name.ToString();
+            viewItem.Level = (int)(character.Attributes?.FirstOrDefault(attribute => attribute.Definition == Stats.Level)?.Value ?? 0);
+            viewItem.MasterLevel = (int)(character.Attributes?.FirstOrDefault(attribute => attribute.Definition == Stats.MasterLevel)?.Value ?? 0);
+
+            viewItem.AccountLoginName = account.LoginName;
+            var accountId = account.GetId();
+            viewItem.AccountId = accountId != Guid.Empty ? accountId : null;
+        }
+        catch (Exception ex)
+        {
+            // Character details are best-effort; the guild member is still shown with its name and position.
+            this._logger.LogDebug(ex, "Failed to enrich guild member {CharacterId} with character data.", viewItem.CharacterId);
+        }
+    }
+}
diff --git a/src/Web/Shared/Services/GuildNames.cs b/src/Web/Shared/Services/GuildNames.cs
new file mode 100644
index 0000000000..72284b7a29
--- /dev/null
+++ b/src/Web/Shared/Services/GuildNames.cs
@@ -0,0 +1,80 @@
+// <copyright file="GuildNames.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Shared.Services;
+
+using MUnique.OpenMU.GameLogic;
+using MUnique.OpenMU.Interfaces;
+
+/// <summary>
+/// Bulk resolution of guild names for the online-accounts tables: one lookup per distinct
+/// guild instead of one per row. A display column must never fail the whole table because
+/// a single guild lookup failed, so per-guild failures resolve to "no guild".
+/// </summary>
+public static class GuildNames
+{
+    /// <summary>
+    /// Finds the guild server of the first in-process game server, if any.
+    /// </summary>
+    /// <param name="serverProvider">The server provider.</param>
+    public static IGuildServer? FindServer(IServerProvider serverProvider)
+        => serverProvider.Servers
+            .OfType<IGameServerContextProvider>()
+            .Select(s => s.Context.GuildServer)
+            .FirstOrDefault(g => g is not null);
+
+    /// <summary>
+    /// Resolves the display data of the given guilds: one lookup per distinct
+    /// guild instead of one per row.
+    /// </summary>
+    /// <param name="guildServer">The guild server, if available (all-in-one deployment only).</param>
+    /// <param name="guildIds">The guild identifiers to resolve.</param>
+    /// <returns>The display data by guild identifier; unknown or failed lookups are absent.</returns>
+    public static async Task<Dictionary<uint, GuildInfo>> ResolveAsync(IGuildServer? guildServer, IEnumerable<uint> guildIds)
+    {
+        var result = new Dictionary<uint, GuildInfo>();
+        if (guildServer is null)
+        {
+            return result;
+        }
+
+        foreach (var guildId in guildIds.Distinct())
+        {
+            string? name = null;
+            Guid? persistentId = null;
+            try
+            {
+                name = (await guildServer.GetGuildAsync(guildId).ConfigureAwait(false))?.Name;
+            }
+            catch (Exception)
+            {
+                // A single failed lookup resolves to "no guild" (see above).
+            }
+
+            try
+            {
+                var resolvedId = await guildServer.GetPersistentGuildIdAsync(guildId).ConfigureAwait(false);
+                persistentId = resolvedId is { } guid && guid != Guid.Empty ? guid : null;
+            }
+            catch (Exception)
+            {
+                // A single failed lookup resolves to "no guild" (see above).
+            }
+
+            if (name is not null || persistentId is not null)
+            {
+                result[guildId] = new GuildInfo(name, persistentId);
+            }
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Display data of a guild for the online-accounts tables.
+    /// </summary>
+    /// <param name="Name">The name of the guild, if it could be resolved.</param>
+    /// <param name="PersistentId">The persistent identifier of the guild, for linking to the guild page. Null when unknown.</param>
+    public sealed record GuildInfo(string? Name, Guid? PersistentId);
+}
diff --git a/src/Web/Shared/Services/GuildService.cs b/src/Web/Shared/Services/GuildService.cs
new file mode 100644
index 0000000000..abbae62f8b
--- /dev/null
+++ b/src/Web/Shared/Services/GuildService.cs
@@ -0,0 +1,281 @@
+// <copyright file="GuildService.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Shared.Services;
+
+using Microsoft.Extensions.Logging;
+using MUnique.OpenMU.DataModel.Entities;
+using MUnique.OpenMU.Persistence;
+using MUnique.OpenMU.Web.Shared.Components;
+using MUnique.OpenMU.Web.Shared.Models;
+
+using GuildPositionComparer = MUnique.OpenMU.Interfaces.GuildPositionComparer;
+
+/// <summary>
+/// Service for guild information in the admin panel.
+/// It reads guild data from the guild context; enrichment of members with character/account
+/// data is delegated to an <see cref="IGuildMemberEnricher"/>, which lives in a separate context.
+/// </summary>
+public class GuildService : IGuildService, ISupportDataChangedNotification, IDisposable
+{
+    private readonly IPersistenceContextProvider _contextProvider;
+    private readonly IGuildMemberEnricher _memberEnricher;
+    private readonly ILogger<GuildService> _logger;
+    private readonly Debouncer _debouncer = new(300);
+
+    private string _searchFilter = string.Empty;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="GuildService"/> class.
+    /// </summary>
+    /// <param name="contextProvider">The persistence context provider.</param>
+    /// <param name="memberEnricher">The enricher which adds character/account data to guild members.</param>
+    /// <param name="logger">The logger.</param>
+    public GuildService(IPersistenceContextProvider contextProvider, IGuildMemberEnricher memberEnricher, ILogger<GuildService> logger)
+    {
+        this._contextProvider = contextProvider;
+        this._memberEnricher = memberEnricher;
+        this._logger = logger;
+    }
+
+    /// <inheritdoc />
+    public event EventHandler? DataChanged;
+
+    /// <summary>
+    /// Gets or sets the search filter query which is applied to the guild name.
+    /// </summary>
+    public string SearchFilter
+    {
+        get => this._searchFilter;
+        set
+        {
+            var newValue = value ?? string.Empty;
+            if (this._searchFilter != newValue)
+            {
+                this._searchFilter = newValue;
+                if (string.IsNullOrEmpty(newValue))
+                {
+                    this._debouncer.Cancel();
+                    this.DataChanged?.Invoke(this, EventArgs.Empty);
+                }
+                else
+                {
+                    _ = this._debouncer.DebounceAsync(this.RaiseDataChangedAsync);
+                }
+            }
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<List<GuildListItem>> GetAsync(int offset, int count)
+    {
+        return await this.SafeAsync(
+            async () =>
+            {
+                using var context = this._contextProvider.CreateNewGuildContext();
+                var filter = this.SearchFilter.Trim();
+
+                IReadOnlyList<Guild> guilds;
+                if (string.IsNullOrWhiteSpace(filter))
+                {
+                    guilds = await context.GetGuildsOrderedByNameAsync(offset, count).ConfigureAwait(false);
+                }
+                else
+                {
+                    guilds = await context.SearchGuildsAsync(filter, offset, count).ConfigureAwait(false);
+                    if (guilds.Count == 0 && offset > 0)
+                    {
+                        // The filter narrowed the result set down to less entries than the current page offset - show the first page instead.
+                        guilds = await context.SearchGuildsAsync(filter, 0, count).ConfigureAwait(false);
+                    }
+                }
+
+                return await ToListItemsWithAllianceInfoAsync(guilds, context).ConfigureAwait(false);
+            },
+            [],
+            "Failed to retrieve guilds (offset: {Offset}, count: {Count}).",
+            offset,
+            count).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc />
+    public async Task<GuildListItem?> GetGuildAsync(Guid guildId)
+    {
+        return await this.SafeAsync<GuildListItem?>(
+            async () =>
+            {
+                using var context = this._contextProvider.CreateNewGuildContext();
+                var guild = await context.GetByIdAsync<Guild>(guildId).ConfigureAwait(false);
+                if (guild is null)
+                {
+                    return null;
+                }
+
+                var items = await ToListItemsWithAllianceInfoAsync([guild], context).ConfigureAwait(false);
+                return items[0];
+            },
+            null,
+            "Failed to retrieve guild with ID {GuildId}.",
+            guildId).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<GuildMemberViewItem>> GetGuildMembersAsync(Guid guildId)
+    {
+        return await this.SafeAsync<IReadOnlyList<GuildMemberViewItem>>(
+            async () =>
+            {
+                using var guildContext = this._contextProvider.CreateNewGuildContext();
+                var guild = await guildContext.GetByIdAsync<Guild>(guildId).ConfigureAwait(false);
+                if (guild?.Members is not { } members || members.Count == 0)
+                {
+                    return [];
+                }
+
+                var names = await guildContext.GetMemberNamesAsync(guildId).ConfigureAwait(false);
+                var result = members
+                    .Select(member => new GuildMemberViewItem
+                    {
+                        CharacterId = member.Id,
+                        CharacterName = names.TryGetValue(member.Id, out var name) ? name : member.Id.ToString(),
+                        Position = member.Status,
+                    })
+                    .ToList();
+
+                await this._memberEnricher.EnrichAsync(result).ConfigureAwait(false);
+
+                result.Sort(static (x, y) =>
+                {
+                    var rankComparison = GuildPositionComparer.Instance.Compare(x.Position, y.Position);
+                    return rankComparison != 0
+                        ? rankComparison
+                        : StringComparer.OrdinalIgnoreCase.Compare(x.CharacterName, y.CharacterName);
+                });
+                return result;
+            },
+            [],
+            "Failed to retrieve members for guild with ID {GuildId}.",
+            guildId).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc />
+    public async Task<AllianceDetails?> GetAllianceAsync(Guid guildId)
+    {
+        return await this.SafeAsync<AllianceDetails?>(
+            async () =>
+            {
+                using var context = this._contextProvider.CreateNewGuildContext();
+                var guild = await context.GetByIdAsync<Guild>(guildId).ConfigureAwait(false);
+                if (guild is null)
+                {
+                    return null;
+                }
+
+                var master = guild.AllianceGuild as Guild ?? guild;
+                var allianceGuilds = await context.GetAlliancesAsync(master.Id).ConfigureAwait(false);
+                var guilds = allianceGuilds
+                    .Select(ToListItem)
+                    .OrderBy(item => item.Name, StringComparer.OrdinalIgnoreCase)
+                    .ToList();
+
+                if (guilds.All(item => item.Id != master.Id))
+                {
+                    guilds.Insert(0, ToListItem(master));
+                }
+
+                var masterItem = ToListItem(master);
+
+                // The master's own AllianceGuild navigation is null (it doesn't point to itself), so
+                // annotate it explicitly as its own alliance here, consistent with the list/detail pages.
+                masterItem.AllianceGuildId ??= master.Id;
+                masterItem.AllianceName ??= master.Name;
+
+                return new AllianceDetails
+                {
+                    Master = masterItem,
+                    Guilds = guilds,
+                };
+            },
+            null,
+            "Failed to retrieve alliance for guild with ID {GuildId}.",
+            guildId).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        this._debouncer.Dispose();
+    }
+
+    private static GuildListItem ToListItem(Guild guild)
+    {
+        var alliance = guild.AllianceGuild as Guild;
+        return new GuildListItem
+        {
+            Id = guild.Id,
+            Name = guild.Name ?? string.Empty,
+            Score = guild.Score,
+            Notice = guild.Notice,
+            MemberCount = guild.Members?.Count ?? 0,
+            AllianceGuildId = alliance?.Id,
+            AllianceName = alliance?.Name,
+            Logo = guild.Logo,
+        };
+    }
+
+    /// <summary>
+    /// Maps guilds to list items and additionally marks guilds which are themselves the master of
+    /// an alliance (i.e. other guilds point to them via <see cref="Interfaces.Guild.AllianceGuild"/>,
+    /// but they don't point to anyone). Without this, only member guilds would get a working
+    /// "Alliance" link - the master's own row/page would show nothing, even though it heads an alliance.
+    /// </summary>
+    private static async Task<List<GuildListItem>> ToListItemsWithAllianceInfoAsync(IReadOnlyList<Guild> guilds, IGuildServerContext context)
+    {
+        var items = guilds.Select(ToListItem).ToList();
+
+        // Only guilds without an AllianceGuild of their own are candidates for being a master.
+        // this keeps the lookup bounded to the current page instead of scanning the whole guild table.
+        var candidateMasterIds = items
+            .Where(item => item.AllianceGuildId is null)
+            .Select(item => item.Id)
+            .ToList();
+
+        if (candidateMasterIds.Count > 0)
+        {
+            var masterIds = await context.GetAllianceMasterIdsAsync(candidateMasterIds).ConfigureAwait(false);
+            if (masterIds.Count > 0)
+            {
+                foreach (var item in items)
+                {
+                    if (masterIds.Contains(item.Id))
+                    {
+                        item.AllianceGuildId = item.Id;
+                        item.AllianceName = item.Name;
+                    }
+                }
+            }
+        }
+
+        return items;
+    }
+
+    private async Task<T> SafeAsync<T>(Func<Task<T>> action, T fallback, string errorMessage, params object?[] args)
+    {
+        try
+        {
+            return await action().ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            this._logger.LogError(ex, errorMessage, args);
+            return fallback;
+        }
+    }
+
+    private Task RaiseDataChangedAsync()
+    {
+        this.DataChanged?.Invoke(this, EventArgs.Empty);
+        return Task.CompletedTask;
+    }
+}
diff --git a/src/Web/Shared/Services/IGuildMemberEnricher.cs b/src/Web/Shared/Services/IGuildMemberEnricher.cs
new file mode 100644
index 0000000000..510e1c64c3
--- /dev/null
+++ b/src/Web/Shared/Services/IGuildMemberEnricher.cs
@@ -0,0 +1,22 @@
+// <copyright file="IGuildMemberEnricher.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Shared.Services;
+
+using MUnique.OpenMU.Web.Shared.Models;
+
+/// <summary>
+/// Enriches guild members with character and account data, which lives in a separate
+/// persistence context (the player context) from the guild data itself.
+/// </summary>
+public interface IGuildMemberEnricher
+{
+    /// <summary>
+    /// Enriches the given guild members with character and account data, where available.
+    /// Enrichment is best-effort: members whose character data cannot be resolved are left
+    /// with just their name and position, so callers can always show the base guild member list.
+    /// </summary>
+    /// <param name="members">The guild members to enrich, in place.</param>
+    Task EnrichAsync(IReadOnlyList<GuildMemberViewItem> members);
+}
diff --git a/src/Web/Shared/Services/IGuildService.cs b/src/Web/Shared/Services/IGuildService.cs
new file mode 100644
index 0000000000..f96d777b31
--- /dev/null
+++ b/src/Web/Shared/Services/IGuildService.cs
@@ -0,0 +1,39 @@
+// <copyright file="IGuildService.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Shared.Services;
+
+using MUnique.OpenMU.Web.Shared.Models;
+
+/// <summary>
+/// Service for guild information in the admin panel, beyond the paged listing covered by <see cref="IDataService{T}"/>.
+/// </summary>
+public interface IGuildService : IDataService<GuildListItem>
+{
+    /// <summary>
+    /// Gets or sets the search filter query which is applied to the guild name.
+    /// </summary>
+    string SearchFilter { get; set; }
+
+    /// <summary>
+    /// Gets the guild with the specified persistent identifier.
+    /// </summary>
+    /// <param name="guildId">The persistent identifier of the guild.</param>
+    /// <returns>The guild, or <c>null</c> if it was not found.</returns>
+    Task<GuildListItem?> GetGuildAsync(Guid guildId);
+
+    /// <summary>
+    /// Gets the members of the guild with the specified persistent identifier.
+    /// </summary>
+    /// <param name="guildId">The persistent identifier of the guild.</param>
+    /// <returns>The members, ordered with the guild master first.</returns>
+    Task<IReadOnlyList<GuildMemberViewItem>> GetGuildMembersAsync(Guid guildId);
+
+    /// <summary>
+    /// Gets the alliance of the guild with the specified persistent identifier.
+    /// </summary>
+    /// <param name="guildId">The persistent identifier of any guild in the alliance.</param>
+    /// <returns>The alliance details, or <c>null</c> if the guild was not found.</returns>
+    Task<AllianceDetails?> GetAllianceAsync(Guid guildId);
+}
diff --git a/src/Web/Shared/Services/IPartyGroupedAccount.cs b/src/Web/Shared/Services/IPartyGroupedAccount.cs
index e77ba9bae0..1b68be50e5 100644
--- a/src/Web/Shared/Services/IPartyGroupedAccount.cs
+++ b/src/Web/Shared/Services/IPartyGroupedAccount.cs
@@ -23,4 +23,9 @@ public interface IPartyGroupedAccount
     /// Gets the character name of the party master, if the player is in a party.
     /// </summary>
     string? PartyMaster { get; }
+
+    /// <summary>
+    /// Gets the number of party members, if the player is in a party.
+    /// </summary>
+    int PartySize { get; }
 }
diff --git a/src/Web/Shared/Services/LoggedInAccount.cs b/src/Web/Shared/Services/LoggedInAccount.cs
index 29e4b5f254..586ab8f94e 100644
--- a/src/Web/Shared/Services/LoggedInAccount.cs
+++ b/src/Web/Shared/Services/LoggedInAccount.cs
@@ -10,6 +10,8 @@ namespace MUnique.OpenMU.Web.Shared.Services;
 /// <param name="LoginName">The account login name.</param>
 /// <param name="Server">The server identifier.</param>
 /// <param name="CharacterName">The selected character, if it could be resolved (only available in the all-in-one deployment).</param>
+/// <param name="GuildName">The guild of the selected character, if any.</param>
+/// <param name="GuildId">The persistent identifier of the guild, for linking to the guild page. Null when unknown.</param>
 /// <param name="PartyMaster">The character name of the party master, if the player is in a party.</param>
 /// <param name="PartySize">The number of party members, if the player is in a party.</param>
-public record LoggedInAccount(string LoginName, byte Server, string? CharacterName = null, string? PartyMaster = null, int PartySize = 0) : IPartyGroupedAccount;
\ No newline at end of file
+public record LoggedInAccount(string LoginName, byte Server, string? CharacterName = null, string? GuildName = null, string? PartyMaster = null, int PartySize = 0, Guid? GuildId = null) : IPartyGroupedAccount;
\ No newline at end of file
diff --git a/src/Web/Shared/Services/LoggedInAccountService.cs b/src/Web/Shared/Services/LoggedInAccountService.cs
index 4e02036cc7..a7686b98b6 100644
--- a/src/Web/Shared/Services/LoggedInAccountService.cs
+++ b/src/Web/Shared/Services/LoggedInAccountService.cs
@@ -4,6 +4,7 @@
 
 namespace MUnique.OpenMU.Web.Shared.Services;
 
+using Microsoft.Extensions.Caching.Memory;
 using MUnique.OpenMU.GameLogic;
 using MUnique.OpenMU.GameLogic.Offline;
 using MUnique.OpenMU.Interfaces;
@@ -13,18 +14,25 @@ namespace MUnique.OpenMU.Web.Shared.Services;
 /// </summary>
 public class LoggedInAccountService : IDataService<LoggedInAccount>, ISupportDataChangedNotification
 {
+    private static readonly TimeSpan LookupCacheLifetime = TimeSpan.FromSeconds(5);
+
+    private const string LookupCacheKey = "LoggedInAccountService.PlayerLookup";
+
     private readonly ILoginServer _loginServer;
     private readonly IServerProvider _serverProvider;
+    private readonly IMemoryCache _cache;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="LoggedInAccountService"/> class.
     /// </summary>
     /// <param name="loginServer">The login server.</param>
     /// <param name="serverProvider">The server provider.</param>
-    public LoggedInAccountService(ILoginServer loginServer, IServerProvider serverProvider)
+    /// <param name="cache">The memory cache.</param>
+    public LoggedInAccountService(ILoginServer loginServer, IServerProvider serverProvider, IMemoryCache cache)
     {
         this._loginServer = loginServer;
         this._serverProvider = serverProvider;
+        this._cache = cache;
     }
 
     /// <summary>
@@ -45,6 +53,7 @@ public async Task SetAccountOfflineAsync(LoggedInAccount account)
             await gameServer.DisconnectAccountAsync(account.LoginName).ConfigureAwait(false);
         }
 
+        this._cache.Remove(LookupCacheKey);
         this.DataChanged?.Invoke(this, EventArgs.Empty);
     }
 
@@ -58,7 +67,7 @@ public async Task<List<LoggedInAccount>> GetAsync(int offset, int count)
             {
                 if (playerLookup.TryGetValue(entry.Key, out var playerInfo))
                 {
-                    return new LoggedInAccount(entry.Key, entry.Value, playerInfo.CharacterName, playerInfo.PartyMaster, playerInfo.PartySize);
+                    return new LoggedInAccount(entry.Key, entry.Value, playerInfo.CharacterName, playerInfo.Guild?.Name, playerInfo.PartyMaster, playerInfo.PartySize, playerInfo.Guild?.PersistentId);
                 }
 
                 return new LoggedInAccount(entry.Key, entry.Value);
@@ -70,11 +79,19 @@ public async Task<List<LoggedInAccount>> GetAsync(int offset, int count)
     }
 
     /// <summary>
-    /// Builds a lookup of account login name to character and party info from the in-process game servers.
+    /// Builds a lookup of account login name to character, guild and party info from the in-process game servers.
     /// Empty when the servers run in another process (distributed deployment).
+    /// The lookup is cached for a few seconds: building it copies the whole player list of every
+    /// game server, while the table only renders one page. External changes (logins, party changes)
+    /// become visible with a short delay; the service's own mutations invalidate the cache.
     /// </summary>
     private async Task<Dictionary<string, PlayerInfo>> GetPlayerLookupAsync()
     {
+        if (this._cache.TryGetValue<Dictionary<string, PlayerInfo>>(LookupCacheKey, out var cached) && cached is not null)
+        {
+            return cached;
+        }
+
         var result = new Dictionary<string, PlayerInfo>(StringComparer.OrdinalIgnoreCase);
         foreach (var context in this._serverProvider.Servers.OfType<IGameServerContextProvider>().Select(s => s.Context))
         {
@@ -83,21 +100,36 @@ private async Task<Dictionary<string, PlayerInfo>> GetPlayerLookupAsync()
             {
                 if (player is OfflinePlayer)
                 {
-                    continue; // offline sessions and bots are shown on their own tabs.
+                    // Defensive only: offline sessions are logged off from the login server when they start,
+                    // so their accounts are normally absent from the snapshot. Bots never log in at all.
+                    continue;
                 }
 
                 var loginName = player.Account?.LoginName;
-                if (string.IsNullOrEmpty(loginName) || result.ContainsKey(loginName))
+                if (string.IsNullOrEmpty(loginName))
                 {
                     continue;
                 }
 
-                result[loginName] = new PlayerInfo(player.SelectedCharacter?.Name, player.Party?.PartyMaster?.Name, player.Party?.PartyList.Count ?? 0);
+                var (partyMaster, partySize) = PartyDisplay.From(player.Party);
+                result.TryAdd(loginName, new PlayerInfo(player.SelectedCharacter?.Name, partyMaster, partySize, player.GuildStatus?.GuildId));
+            }
+        }
+
+        var guildIds = result.Values.Select(v => v.GuildId).OfType<uint>().ToList();
+        var guilds = await GuildNames.ResolveAsync(GuildNames.FindServer(this._serverProvider), guildIds).ConfigureAwait(false);
+        foreach (var key in result.Keys.ToList())
+        {
+            var info = result[key];
+            if (info.GuildId is { } guildId)
+            {
+                result[key] = info with { Guild = guilds.GetValueOrDefault(guildId) };
             }
         }
 
+        this._cache.Set(LookupCacheKey, result, LookupCacheLifetime);
         return result;
     }
 
-    private sealed record PlayerInfo(string? CharacterName, string? PartyMaster, int PartySize);
+    private sealed record PlayerInfo(string? CharacterName, string? PartyMaster, int PartySize, uint? GuildId, GuildNames.GuildInfo? Guild = null);
 }
\ No newline at end of file
diff --git a/src/Web/Shared/Services/OfflineAccount.cs b/src/Web/Shared/Services/OfflineAccount.cs
index 0fb28c7be7..92dbe8c4d1 100644
--- a/src/Web/Shared/Services/OfflineAccount.cs
+++ b/src/Web/Shared/Services/OfflineAccount.cs
@@ -11,6 +11,7 @@ namespace MUnique.OpenMU.Web.Shared.Services;
 /// <param name="ServerId">The server identifier.</param>
 /// <param name="StartedAt">The start timestamp of the offline session.</param>
 /// <param name="CharacterName">The character which keeps leveling.</param>
+/// <param name="GuildName">The guild of the character, if any.</param>
 /// <param name="PartyMaster">The character name of the party master, if the player is in a party.</param>
 /// <param name="PartySize">The number of party members, if the player is in a party.</param>
-public record OfflineAccount(string LoginName, byte ServerId, DateTime StartedAt, string? CharacterName = null, string? PartyMaster = null, int PartySize = 0) : IPartyGroupedAccount;
+public record OfflineAccount(string LoginName, byte ServerId, DateTime StartedAt, string? CharacterName = null, string? GuildName = null, string? PartyMaster = null, int PartySize = 0) : IPartyGroupedAccount;
diff --git a/src/Web/Shared/Services/OfflineAccountService.cs b/src/Web/Shared/Services/OfflineAccountService.cs
index 898fcf15fd..192fbc4763 100644
--- a/src/Web/Shared/Services/OfflineAccountService.cs
+++ b/src/Web/Shared/Services/OfflineAccountService.cs
@@ -55,25 +55,39 @@ public bool IsOfflevelFeatureAvailable()
     }
 
     /// <inheritdoc />
-    public Task<List<OfflineAccount>> GetAsync(int offset, int count)
+    public async Task<List<OfflineAccount>> GetAsync(int offset, int count)
     {
         // Note: bots never show up here - they are managed by the BotManager, not the OfflinePlayerManager.
-        var result = this._serverProvider.Servers
+        // Materialized once: guild names resolve in bulk afterwards, and a second snapshot could disagree.
+        var rows = this._serverProvider.Servers
             .OfType<IGameServerContextProvider>()
             .SelectMany(s => s.Context.OfflinePlayerManager
                 .OfflinePlayers
-                .Select(p => new OfflineAccount(
-                    p.AccountLoginName ?? string.Empty,
-                    (byte)((IManageableServer)s).Id,
-                    p.StartTimestamp,
-                    p.SelectedCharacter?.Name,
-                    p.Party?.PartyMaster?.Name,
-                    p.Party?.PartyList.Count ?? 0)))
+                .Select(p => (ServerId: (byte)((IManageableServer)s).Id, Player: p)))
+            .ToList();
+
+        var guilds = await GuildNames.ResolveAsync(
+                GuildNames.FindServer(this._serverProvider),
+                rows.Select(r => r.Player.GuildStatus?.GuildId).OfType<uint>())
+            .ConfigureAwait(false);
+
+        return rows
+            .Select(r =>
+            {
+                var (partyMaster, partySize) = PartyDisplay.From(r.Player.Party);
+                var guildId = r.Player.GuildStatus?.GuildId;
+                return new OfflineAccount(
+                    r.Player.AccountLoginName ?? string.Empty,
+                    r.ServerId,
+                    r.Player.StartTimestamp,
+                    r.Player.SelectedCharacter?.Name,
+                    guildId is { } id ? guilds.GetValueOrDefault(id)?.Name : null,
+                    partyMaster,
+                    partySize);
+            })
             .OrderPartyGrouped()
             .Skip(offset)
             .Take(count)
             .ToList();
-
-        return Task.FromResult(result);
     }
 }
\ No newline at end of file
diff --git a/src/Web/Shared/Services/PartyDisplay.cs b/src/Web/Shared/Services/PartyDisplay.cs
new file mode 100644
index 0000000000..0eee2c90b9
--- /dev/null
+++ b/src/Web/Shared/Services/PartyDisplay.cs
@@ -0,0 +1,25 @@
+// <copyright file="PartyDisplay.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Shared.Services;
+
+using MUnique.OpenMU.GameLogic;
+
+/// <summary>
+/// Normalizes party display data: a row only counts as partied when a party master is known.
+/// A <see cref="Party"/> whose master is momentarily <c>null</c> sorts and renders as solo.
+/// </summary>
+public static class PartyDisplay
+{
+    /// <summary>
+    /// Extracts the display data of the given party.
+    /// </summary>
+    /// <param name="party">The party, if the player is in one.</param>
+    /// <returns>The party master name and member count; both empty when not partied.</returns>
+    public static (string? Master, int Size) From(Party? party)
+    {
+        var master = party?.PartyMaster?.Name;
+        return master is null ? (null, 0) : (master, party!.PartyList.Count);
+    }
+}
diff --git a/tests/MUnique.OpenMU.Tests/ModelResourcesTest.cs b/tests/MUnique.OpenMU.Tests/ModelResourcesTest.cs
index 0046ad77de..206a679922 100644
--- a/tests/MUnique.OpenMU.Tests/ModelResourcesTest.cs
+++ b/tests/MUnique.OpenMU.Tests/ModelResourcesTest.cs
@@ -9,6 +9,7 @@ namespace MUnique.OpenMU.Tests;
 using MUnique.OpenMU.DataModel;
 using MUnique.OpenMU.DataModel.Configuration;
 using MUnique.OpenMU.DataModel.Entities;
+using MUnique.OpenMU.Interfaces;
 
 /// <summary>
 /// Unit tests for verifying that <see cref="ModelResourceProvider"/> returns expected captions and descriptions
@@ -134,4 +135,19 @@ public void EnumCaption()
         var caption = ModelResourceProvider.GetEnumCaption(typeof(AccountState), AccountState.GameMaster, CultureInfo.GetCultureInfo("en"));
         Assert.That(caption, Is.EqualTo("Game Master"));
     }
+
+    /// <summary>
+    /// Verifies that the captions for <see cref="GuildPosition"/> are properly returned from model resources.
+    /// </summary>
+    /// <param name="position">The guild position.</param>
+    /// <param name="expectedCaption">The expected caption.</param>
+    [TestCase(GuildPosition.NormalMember, "Normal Member")]
+    [TestCase(GuildPosition.GuildMaster, "Guild Master")]
+    [TestCase(GuildPosition.BattleMaster, "Battle Master")]
+    [TestCase(GuildPosition.AssistantMaster, "Assistant Master")]
+    public void GuildPositionCaption(GuildPosition position, string expectedCaption)
+    {
+        var caption = position.GetEnumCaption(CultureInfo.GetCultureInfo("en"));
+        Assert.That(caption, Is.EqualTo(expectedCaption));
+    }
 }
\ No newline at end of file
diff --git a/tests/MUnique.OpenMU.Web.Tests/Components/GuildLinkTests.cs b/tests/MUnique.OpenMU.Web.Tests/Components/GuildLinkTests.cs
new file mode 100644
index 0000000000..b9e8ea5f42
--- /dev/null
+++ b/tests/MUnique.OpenMU.Web.Tests/Components/GuildLinkTests.cs
@@ -0,0 +1,109 @@
+// <copyright file="GuildLinkTests.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Tests.Components;
+
+using Bunit;
+using MUnique.OpenMU.Web.Shared.Components;
+
+/// <summary>
+/// Tests for the <see cref="GuildLink"/> and <see cref="AllianceLink"/> components.
+/// </summary>
+[TestFixture]
+public class GuildLinkTests
+{
+    private BunitContext _context = null!;
+
+    /// <summary>
+    /// Setups the test objects.
+    /// </summary>
+    [SetUp]
+    public void Setup()
+    {
+        this._context = new BunitContext();
+    }
+
+    /// <summary>
+    /// Tears down the test objects.
+    /// </summary>
+    [TearDown]
+    public void Teardown()
+    {
+        this._context.Dispose();
+    }
+
+    /// <summary>
+    /// A known guild renders a link to its detail page.
+    /// </summary>
+    [Test]
+    public void KnownGuild_RendersLink()
+    {
+        var guildId = Guid.NewGuid();
+
+        var cut = this._context.Render<GuildLink>(parameters => parameters
+            .Add(p => p.GuildId, guildId)
+            .Add(p => p.GuildName, "Knights"));
+
+        var link = cut.Find("a");
+        Assert.That(link.GetAttribute("href"), Is.EqualTo($"guild/{guildId}"));
+        Assert.That(link.TextContent, Is.EqualTo("Knights"));
+    }
+
+    /// <summary>
+    /// Without an identifier the name renders as plain text without a link.
+    /// </summary>
+    [Test]
+    public void UnknownGuild_RendersPlainText()
+    {
+        var cut = this._context.Render<GuildLink>(parameters => parameters
+            .Add(p => p.GuildName, "Knights")
+            .Add(p => p.EmptyText, "—"));
+
+        Assert.That(cut.FindAll("a"), Is.Empty);
+        Assert.That(cut.Markup, Does.Contain("Knights"));
+    }
+
+    /// <summary>
+    /// Without a name the fallback text renders.
+    /// </summary>
+    [Test]
+    public void MissingName_RendersEmptyText()
+    {
+        var cut = this._context.Render<AllianceLink>(parameters => parameters
+            .Add(p => p.EmptyText, "none"));
+
+        Assert.That(cut.FindAll("a"), Is.Empty);
+        Assert.That(cut.Markup, Does.Contain("none"));
+    }
+
+    /// <summary>
+    /// A known alliance renders a link to its alliance page.
+    /// </summary>
+    [Test]
+    public void KnownAlliance_RendersLink()
+    {
+        var allianceId = Guid.NewGuid();
+
+        var cut = this._context.Render<AllianceLink>(parameters => parameters
+            .Add(p => p.AllianceId, allianceId)
+            .Add(p => p.AllianceName, "Masters"));
+
+        var link = cut.Find("a");
+        Assert.That(link.GetAttribute("href"), Is.EqualTo($"alliance/{allianceId}"));
+        Assert.That(link.TextContent, Is.EqualTo("Masters"));
+    }
+
+    /// <summary>
+    /// Without an identifier the alliance name renders as plain text without a link.
+    /// </summary>
+    [Test]
+    public void UnknownAlliance_RendersPlainText()
+    {
+        var cut = this._context.Render<AllianceLink>(parameters => parameters
+            .Add(p => p.EmptyText, "—"));
+
+        Assert.That(cut.FindAll("a"), Is.Empty);
+        Assert.That(cut.Markup, Does.Contain("—"));
+    }
+}
diff --git a/tests/MUnique.OpenMU.Web.Tests/Guilds/GuildServiceTests.cs b/tests/MUnique.OpenMU.Web.Tests/Guilds/GuildServiceTests.cs
new file mode 100644
index 0000000000..fe71bf02ca
--- /dev/null
+++ b/tests/MUnique.OpenMU.Web.Tests/Guilds/GuildServiceTests.cs
@@ -0,0 +1,420 @@
+// <copyright file="GuildServiceTests.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Tests.Guilds;
+
+using Moq;
+using System.Threading;
+using Microsoft.Extensions.Logging;
+using MUnique.OpenMU.DataModel.Configuration;
+using MUnique.OpenMU.DataModel.Entities;
+using MUnique.OpenMU.GameLogic.Attributes;
+using MUnique.OpenMU.Persistence;
+using MUnique.OpenMU.Persistence.InMemory;
+using MUnique.OpenMU.Web.Shared.Services;
+
+using BasicModel = MUnique.OpenMU.Persistence.BasicModel;
+
+/// <summary>
+/// Tests for the <see cref="GuildService"/> which backs the admin panel guild pages.
+/// </summary>
+[TestFixture]
+public class GuildServiceTests
+{
+    private InMemoryPersistenceContextProvider _persistenceContextProvider = null!;
+
+    private Mock<IDataSource<GameConfiguration>> _gameConfigurationSource = null!;
+
+    private GuildService _service = null!;
+
+    /// <summary>
+    /// Setups the test objects.
+    /// </summary>
+    [SetUp]
+    public void Setup()
+    {
+        this._persistenceContextProvider = new InMemoryPersistenceContextProvider();
+        this._gameConfigurationSource = new Mock<IDataSource<GameConfiguration>>();
+        this._gameConfigurationSource
+            .Setup(s => s.GetOwnerAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new GameConfiguration());
+        var enricher = new CharacterGuildMemberEnricher(this._persistenceContextProvider, this._gameConfigurationSource.Object, Mock.Of<ILogger<CharacterGuildMemberEnricher>>());
+        this._service = new GuildService(this._persistenceContextProvider, enricher, Mock.Of<ILogger<GuildService>>());
+    }
+
+    /// <summary>
+    /// Tears down the test objects.
+    /// </summary>
+    [TearDown]
+    public void Teardown()
+    {
+        this._service.Dispose();
+    }
+
+    /// <summary>
+    /// Guilds are listed ordered by name.
+    /// </summary>
+    [Test]
+    public async Task GetAsync_ReturnsGuildsOrderedByName()
+    {
+        await this.CreateGuildAsync("Zealots").ConfigureAwait(false);
+        await this.CreateGuildAsync("Alphas").ConfigureAwait(false);
+
+        var result = await this._service.GetAsync(0, 20).ConfigureAwait(false);
+
+        Assert.That(result.Select(g => g.Name), Is.EqualTo(new[] { "Alphas", "Zealots" }));
+    }
+
+    /// <summary>
+    /// Pagination applies after ordering.
+    /// </summary>
+    [Test]
+    public async Task GetAsync_PaginationAppliesAfterOrdering()
+    {
+        await this.CreateGuildAsync("Charlie").ConfigureAwait(false);
+        await this.CreateGuildAsync("Alpha").ConfigureAwait(false);
+        await this.CreateGuildAsync("Bravo").ConfigureAwait(false);
+
+        var result = await this._service.GetAsync(1, 1).ConfigureAwait(false);
+
+        Assert.That(result.Select(g => g.Name), Is.EqualTo(new[] { "Bravo" }));
+    }
+
+    /// <summary>
+    /// The search filter narrows the list down by guild name, case-insensitively.
+    /// </summary>
+    [Test]
+    public async Task GetAsync_SearchFilter_NarrowsByName()
+    {
+        await this.CreateGuildAsync("DarkNights").ConfigureAwait(false);
+        await this.CreateGuildAsync("LightBringers").ConfigureAwait(false);
+
+        this._service.SearchFilter = "dark";
+
+        var result = await this._service.GetAsync(0, 20).ConfigureAwait(false);
+
+        Assert.That(result.Select(g => g.Name), Is.EqualTo(new[] { "DarkNights" }));
+    }
+
+    /// <summary>
+    /// When the search filter narrows the list such that the current page offset is out of range,
+    /// it falls back to the first page (offset 0).
+    /// </summary>
+    [Test]
+    public async Task GetAsync_SearchFilterBeyondRange_FallsBackToFirstPage()
+    {
+        await this.CreateGuildAsync("DarkNights").ConfigureAwait(false);
+        await this.CreateGuildAsync("LightBringers").ConfigureAwait(false);
+
+        this._service.SearchFilter = "dark";
+
+        // Offset 10 is beyond the 1 matching entry, so it falls back to page 0.
+        var result = await this._service.GetAsync(10, 20).ConfigureAwait(false);
+
+        Assert.That(result.Select(g => g.Name), Is.EqualTo(new[] { "DarkNights" }));
+    }
+
+    /// <summary>
+    /// The alliance of a guild is shown on its list item.
+    /// </summary>
+    [Test]
+    public async Task GetAsync_ShowsAllianceOfGuild()
+    {
+        var master = await this.CreateGuildAsync("Masters").ConfigureAwait(false);
+        var member = await this.CreateGuildAsync("Minions").ConfigureAwait(false);
+        await this.SetAllianceAsync(member.Id, master.Id).ConfigureAwait(false);
+
+        var result = await this._service.GetAsync(0, 20).ConfigureAwait(false);
+
+        var minions = result.Single(g => g.Name == "Minions");
+        Assert.That(minions.AllianceGuildId, Is.EqualTo(master.Id));
+        Assert.That(minions.AllianceName, Is.EqualTo("Masters"));
+    }
+
+    /// <summary>
+    /// Guild logo is mapped to the list item.
+    /// </summary>
+    [Test]
+    public async Task GetAsync_IncludesGuildLogo()
+    {
+        var logo = new byte[] { 0x18, 0x88, 0x88, 0x81 };
+        await this.CreateGuildAsync("LogoGuild", logo).ConfigureAwait(false);
+
+        var result = await this._service.GetAsync(0, 20).ConfigureAwait(false);
+
+        var item = result.Single(g => g.Name == "LogoGuild");
+        Assert.That(item.Logo, Is.EqualTo(logo));
+    }
+
+    /// <summary>
+    /// Members are returned with the guild master first, including character details.
+    /// </summary>
+    [Test]
+    public async Task GetGuildMembersAsync_ReturnsMasterFirstWithCharacterDetails()
+    {
+        var guild = await this.CreateGuildAsync("Knights").ConfigureAwait(false);
+        await this.AddMemberAsync(guild.Id, "Squire", Interfaces.GuildPosition.NormalMember, 50, 0, "squireAccount").ConfigureAwait(false);
+        var (lordCharacterId, lordAccountId) = await this.AddMemberAsync(guild.Id, "Lord", Interfaces.GuildPosition.GuildMaster, 400, 200, "lordAccount").ConfigureAwait(false);
+
+        var members = await this._service.GetGuildMembersAsync(guild.Id).ConfigureAwait(false);
+
+        Assert.That(members.Select(m => m.CharacterName), Is.EqualTo(new[] { "Lord", "Squire" }));
+        var master = members.First();
+        Assert.Multiple(() =>
+        {
+            Assert.That(master.Position, Is.EqualTo(Interfaces.GuildPosition.GuildMaster));
+            Assert.That(master.Level, Is.EqualTo(400));
+            Assert.That(master.MasterLevel, Is.EqualTo(200));
+            Assert.That(master.AccountLoginName, Is.EqualTo("lordAccount"));
+            Assert.That(master.CharacterId, Is.EqualTo(lordCharacterId));
+            Assert.That(master.AccountId, Is.EqualTo(lordAccountId));
+        });
+    }
+
+    /// <summary>
+    /// Without a player context, members are still listed with their names and positions.
+    /// </summary>
+    [Test]
+    public async Task GetGuildMembersAsync_WithoutPlayerContext_StillListsNamesAndPositions()
+    {
+        var guild = await this.CreateGuildAsync("Rogues").ConfigureAwait(false);
+        await this.AddMemberAsync(guild.Id, "Shadow", Interfaces.GuildPosition.BattleMaster, 100, 0, null).ConfigureAwait(false);
+        this._gameConfigurationSource
+            .Setup(s => s.GetOwnerAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new InvalidOperationException("no database"));
+
+        var members = await this._service.GetGuildMembersAsync(guild.Id).ConfigureAwait(false);
+
+        Assert.That(members, Has.Count.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            Assert.That(members[0].CharacterName, Is.EqualTo("Shadow"));
+            Assert.That(members[0].Position, Is.EqualTo(Interfaces.GuildPosition.BattleMaster));
+        });
+    }
+
+    /// <summary>
+    /// Members are ordered by rank: GuildMaster -> AssistantMaster -> BattleMaster -> NormalMember,
+    /// and then alphabetically by character name within the same rank.
+    /// </summary>
+    [Test]
+    public async Task GetGuildMembersAsync_OrdersMembersByPositionRankThenByName()
+    {
+        var guild = await this.CreateGuildAsync("OrderGuild").ConfigureAwait(false);
+        await this.AddGuildMemberAsync(guild.Id, "ZackNormal", Interfaces.GuildPosition.NormalMember).ConfigureAwait(false);
+        await this.AddGuildMemberAsync(guild.Id, "AliceNormal", Interfaces.GuildPosition.NormalMember).ConfigureAwait(false);
+        await this.AddGuildMemberAsync(guild.Id, "BobBattle", Interfaces.GuildPosition.BattleMaster).ConfigureAwait(false);
+        await this.AddGuildMemberAsync(guild.Id, "CharlieAssistant", Interfaces.GuildPosition.AssistantMaster).ConfigureAwait(false);
+        await this.AddGuildMemberAsync(guild.Id, "DaveMaster", Interfaces.GuildPosition.GuildMaster).ConfigureAwait(false);
+
+        var members = await this._service.GetGuildMembersAsync(guild.Id).ConfigureAwait(false);
+
+        Assert.That(members.Select(m => m.CharacterName), Is.EqualTo(new[]
+        {
+            "DaveMaster",
+            "CharlieAssistant",
+            "BobBattle",
+            "AliceNormal",
+            "ZackNormal",
+        }));
+    }
+
+    /// <summary>
+    /// An empty guild (or unknown guild) returns an empty list without error.
+    /// </summary>
+    [Test]
+    public async Task GetGuildMembersAsync_EmptyGuild_ReturnsEmpty()
+    {
+        var guild = await this.CreateGuildAsync("EmptyGuild").ConfigureAwait(false);
+
+        var members = await this._service.GetGuildMembersAsync(guild.Id).ConfigureAwait(false);
+
+        Assert.That(members, Is.Empty);
+    }
+
+    /// <summary>
+    /// The alliance page lists all guilds of the alliance, including the master.
+    /// </summary>
+    [Test]
+    public async Task GetAllianceAsync_ListsAllGuildsOfAlliance()
+    {
+        var master = await this.CreateGuildAsync("AllianceMaster").ConfigureAwait(false);
+        var member = await this.CreateGuildAsync("AllianceMember").ConfigureAwait(false);
+        await this.SetAllianceAsync(member.Id, master.Id).ConfigureAwait(false);
+        await this.SetAllianceAsync(master.Id, master.Id).ConfigureAwait(false);
+
+        var alliance = await this._service.GetAllianceAsync(member.Id).ConfigureAwait(false);
+
+        Assert.That(alliance, Is.Not.Null);
+        Assert.That(alliance!.Master.Id, Is.EqualTo(master.Id));
+        Assert.That(alliance.Guilds.Select(g => g.Name), Is.EquivalentTo(new[] { "AllianceMaster", "AllianceMember" }));
+    }
+
+    /// <summary>
+    /// An unknown guild identifier returns <c>null</c>.
+    /// </summary>
+    [Test]
+    public async Task GetAllianceAsync_UnknownGuild_ReturnsNull()
+    {
+        Assert.That(await this._service.GetAllianceAsync(Guid.NewGuid()).ConfigureAwait(false), Is.Null);
+    }
+
+    /// <summary>
+    /// An unknown guild identifier returns <c>null</c> from <see cref="GuildService.GetGuildAsync"/>.
+    /// </summary>
+    [Test]
+    public async Task GetGuildAsync_UnknownGuild_ReturnsNull()
+    {
+        Assert.That(await this._service.GetGuildAsync(Guid.NewGuid()).ConfigureAwait(false), Is.Null);
+    }
+
+    /// <summary>
+    /// A guild which is itself the master of an alliance (other guilds point to it via
+    /// <see cref="Interfaces.Guild.AllianceGuild"/>, but it doesn't point to anyone) still gets an
+    /// "Alliance" link pointing to itself - both in the paged list and on its own detail page.
+    /// Without this, only member guilds would be able to reach the alliance page.
+    /// </summary>
+    [Test]
+    public async Task GetAsync_And_GetGuildAsync_MasterGuild_HasSelfAllianceLink()
+    {
+        var master = await this.CreateGuildAsync("AllianceMaster").ConfigureAwait(false);
+        var member = await this.CreateGuildAsync("AllianceMember").ConfigureAwait(false);
+        await this.SetAllianceAsync(member.Id, master.Id).ConfigureAwait(false);
+
+        var listResult = await this._service.GetAsync(0, 20).ConfigureAwait(false);
+        var masterInList = listResult.Single(g => g.Id == master.Id);
+        Assert.Multiple(() =>
+        {
+            Assert.That(masterInList.AllianceGuildId, Is.EqualTo(master.Id));
+            Assert.That(masterInList.AllianceName, Is.EqualTo("AllianceMaster"));
+        });
+
+        var masterDetail = await this._service.GetGuildAsync(master.Id).ConfigureAwait(false);
+        Assert.That(masterDetail, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(masterDetail!.AllianceGuildId, Is.EqualTo(master.Id));
+            Assert.That(masterDetail.AllianceName, Is.EqualTo("AllianceMaster"));
+        });
+    }
+
+    /// <summary>
+    /// A guild which is not part of any alliance - neither a member nor a master - has no alliance link.
+    /// </summary>
+    [Test]
+    public async Task GetGuildAsync_GuildWithoutAlliance_HasNoAllianceLink()
+    {
+        var guild = await this.CreateGuildAsync("Loners").ConfigureAwait(false);
+
+        var detail = await this._service.GetGuildAsync(guild.Id).ConfigureAwait(false);
+
+        Assert.That(detail, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(detail!.AllianceGuildId, Is.Null);
+            Assert.That(detail.AllianceName, Is.Null);
+        });
+    }
+
+    /// <summary>
+    /// Enrichment must not use the generic character-by-id lookup: in production (EF)
+    /// that path eagerly walks config-type navigations which are excluded from the
+    /// account database model, so it throws and members lose all details.
+    /// A strict player context mock throws on any unexpected call, simulating that.
+    /// </summary>
+    [Test]
+    public async Task GetGuildMembersAsync_WorksWithoutCharacterByIdLookup()
+    {
+        var guild = await this.CreateGuildAsync("Knights").ConfigureAwait(false);
+        var characterId = await this.AddGuildMemberAsync(guild.Id, "Lord", Interfaces.GuildPosition.GuildMaster).ConfigureAwait(false);
+
+        var accountId = Guid.NewGuid();
+        var account = new BasicModel.Account { Id = accountId, LoginName = "lordAccount" };
+        var character = new BasicModel.Character { Id = characterId, Name = "Lord" };
+        character.Attributes.Add(new BasicModel.StatAttribute(Stats.Level, 400));
+        character.Attributes.Add(new BasicModel.StatAttribute(Stats.MasterLevel, 200));
+        account.Characters.Add(character);
+
+        var playerContextMock = new Mock<IPlayerContext>(MockBehavior.Strict);
+        playerContextMock.Setup(c => c.Dispose());
+        playerContextMock
+            .Setup(c => c.GetAccountByCharacterNameAsync("Lord", It.IsAny<CancellationToken>()))
+            .ReturnsAsync(account);
+
+        var providerMock = new Mock<IPersistenceContextProvider>();
+        providerMock.Setup(p => p.CreateNewGuildContext()).Returns(() => this._persistenceContextProvider.CreateNewGuildContext());
+        providerMock.Setup(p => p.CreateNewPlayerContext(It.IsAny<GameConfiguration>())).Returns(playerContextMock.Object);
+
+        var enricher = new CharacterGuildMemberEnricher(providerMock.Object, this._gameConfigurationSource.Object, Mock.Of<ILogger<CharacterGuildMemberEnricher>>());
+        using var service = new GuildService(providerMock.Object, enricher, Mock.Of<ILogger<GuildService>>());
+
+        var members = await service.GetGuildMembersAsync(guild.Id).ConfigureAwait(false);
+
+        Assert.That(members, Has.Count.EqualTo(1));
+        Assert.Multiple(() =>
+        {
+            Assert.That(members[0].CharacterName, Is.EqualTo("Lord"));
+            Assert.That(members[0].Position, Is.EqualTo(Interfaces.GuildPosition.GuildMaster));
+            Assert.That(members[0].Level, Is.EqualTo(400));
+            Assert.That(members[0].MasterLevel, Is.EqualTo(200));
+            Assert.That(members[0].AccountLoginName, Is.EqualTo("lordAccount"));
+            Assert.That(members[0].AccountId, Is.EqualTo(accountId));
+        });
+        playerContextMock.VerifyAll();
+    }
+
+    private async Task<Guild> CreateGuildAsync(string name, byte[]? logo = null)
+    {
+        using var context = this._persistenceContextProvider.CreateNewGuildContext();
+        var guild = context.CreateNew<Guild>();
+        guild.Name = name;
+        guild.Logo = logo;
+        await context.SaveChangesAsync().ConfigureAwait(false);
+        return guild;
+    }
+
+    private async Task SetAllianceAsync(Guid guildId, Guid allianceMasterId)
+    {
+        using var context = this._persistenceContextProvider.CreateNewGuildContext();
+        var guild = await context.GetByIdAsync<Guild>(guildId).ConfigureAwait(false);
+        var master = await context.GetByIdAsync<Guild>(allianceMasterId).ConfigureAwait(false);
+        guild!.AllianceGuild = master;
+        await context.SaveChangesAsync().ConfigureAwait(false);
+    }
+
+    private async Task<Guid> AddGuildMemberAsync(Guid guildId, string characterName, Interfaces.GuildPosition position)
+    {
+        var (characterId, _) = await this.AddMemberAsync(guildId, characterName, position, 0, 0, null).ConfigureAwait(false);
+        return characterId;
+    }
+
+    private async Task<(Guid CharacterId, Guid? AccountId)> AddMemberAsync(Guid guildId, string characterName, Interfaces.GuildPosition position, int level, int masterLevel, string? accountLoginName)
+    {
+        var gameConfiguration = await this._gameConfigurationSource.Object.GetOwnerAsync().ConfigureAwait(false);
+        using var playerContext = this._persistenceContextProvider.CreateNewPlayerContext(gameConfiguration);
+        var character = playerContext.CreateNew<Character>();
+        character.Name = characterName;
+        character.Attributes.Add(new BasicModel.StatAttribute(Stats.Level, level));
+        character.Attributes.Add(new BasicModel.StatAttribute(Stats.MasterLevel, masterLevel));
+        Guid? accountId = null;
+        if (accountLoginName is not null)
+        {
+            var account = playerContext.CreateNew<Account>();
+            account.LoginName = accountLoginName;
+            account.Characters.Add(character);
+            accountId = account.GetId();
+        }
+
+        await playerContext.SaveChangesAsync().ConfigureAwait(false);
+
+        using var guildContext = this._persistenceContextProvider.CreateNewGuildContext();
+        var member = guildContext.CreateNew<GuildMember>(character.Id);
+        member.Status = position;
+        member.GuildId = guildId;
+        var guild = await guildContext.GetByIdAsync<Guild>(guildId).ConfigureAwait(false);
+        guild!.Members.Add(member);
+        await guildContext.SaveChangesAsync().ConfigureAwait(false);
+        return (character.Id, accountId);
+    }
+}
diff --git a/tests/MUnique.OpenMU.Web.Tests/NetworkAnalyzer/NetworkAnalyzerLinkTests.cs b/tests/MUnique.OpenMU.Web.Tests/NetworkAnalyzer/NetworkAnalyzerLinkTests.cs
index 879450afc2..731c6588ba 100644
--- a/tests/MUnique.OpenMU.Web.Tests/NetworkAnalyzer/NetworkAnalyzerLinkTests.cs
+++ b/tests/MUnique.OpenMU.Web.Tests/NetworkAnalyzer/NetworkAnalyzerLinkTests.cs
@@ -5,6 +5,7 @@
 namespace MUnique.OpenMU.Web.Tests.NetworkAnalyzer;
 
 using Bunit;
+using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.DependencyInjection;
 using Moq;
 using MUnique.OpenMU.Interfaces;
@@ -55,9 +56,9 @@ private static BunitContext CreateContext(IPacketCaptureService? captureService
         serverProvider.Setup(provider => provider.Servers).Returns(new List<IManageableServer>());
 
         context.Services.AddSingleton<NavigationHistory>();
-        context.Services.AddSingleton(new LoggedInAccountService(Mock.Of<ILoginServer>(), serverProvider.Object));
+        context.Services.AddSingleton(new LoggedInAccountService(Mock.Of<ILoginServer>(), serverProvider.Object, new MemoryCache(new MemoryCacheOptions())));
         context.Services.AddSingleton(new OfflineAccountService(serverProvider.Object));
-        context.Services.AddSingleton(new BotAccountService(serverProvider.Object));
+        context.Services.AddSingleton(new BotAccountService(serverProvider.Object, new MemoryCache(new MemoryCacheOptions())));
         context.Services.AddSingleton<IDataService<LoggedInAccount>>(
             new TestDataService<LoggedInAccount>([new LoggedInAccount("Test Account", 3)]));
         context.Services.AddSingleton<IDataService<OfflineAccount>>(new TestDataService<OfflineAccount>([]));
diff --git a/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/GuildNamesTests.cs b/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/GuildNamesTests.cs
new file mode 100644
index 0000000000..4709029bcc
--- /dev/null
+++ b/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/GuildNamesTests.cs
@@ -0,0 +1,122 @@
+// <copyright file="GuildNamesTests.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Tests.OnlineAccounts;
+
+using Moq;
+using MUnique.OpenMU.Interfaces;
+using MUnique.OpenMU.Web.Shared.Services;
+
+/// <summary>
+/// Tests for the bulk guild name resolution.
+/// </summary>
+[TestFixture]
+public class GuildNamesTests
+{
+    /// <summary>
+    /// Without a guild server (distributed deployment) there is nothing to resolve.
+    /// </summary>
+    [Test]
+    public async Task WithoutGuildServer_ReturnsEmpty()
+    {
+        var result = await GuildNames.ResolveAsync(null, new uint[] { 1, 2 });
+
+        Assert.That(result, Is.Empty);
+    }
+
+    /// <summary>
+    /// Each distinct guild is looked up exactly once, no matter how many members it has.
+    /// </summary>
+    [Test]
+    public async Task DistinctGuilds_LookedUpOnce()
+    {
+        var firstId = Guid.NewGuid();
+        var secondId = Guid.NewGuid();
+        var guildServer = new Mock<IGuildServer>();
+        guildServer.Setup(g => g.GetGuildAsync(1)).Returns(new ValueTask<Guild?>(new Guild { Name = "Knights" }));
+        guildServer.Setup(g => g.GetGuildAsync(2)).Returns(new ValueTask<Guild?>(new Guild { Name = "Mages" }));
+        guildServer.Setup(g => g.GetPersistentGuildIdAsync(1)).Returns(new ValueTask<Guid?>(firstId));
+        guildServer.Setup(g => g.GetPersistentGuildIdAsync(2)).Returns(new ValueTask<Guid?>(secondId));
+
+        var result = await GuildNames.ResolveAsync(guildServer.Object, new uint[] { 1, 2, 1 });
+
+        Assert.That(result, Is.EqualTo(new Dictionary<uint, GuildNames.GuildInfo>
+        {
+            [1] = new GuildNames.GuildInfo("Knights", firstId),
+            [2] = new GuildNames.GuildInfo("Mages", secondId),
+        }));
+        guildServer.Verify(g => g.GetGuildAsync(It.IsAny<uint>()), Times.Exactly(2));
+        guildServer.Verify(g => g.GetPersistentGuildIdAsync(It.IsAny<uint>()), Times.Exactly(2));
+    }
+
+    /// <summary>
+    /// Unknown guilds are absent, so the row renders as guild-less.
+    /// </summary>
+    [Test]
+    public async Task UnknownGuild_IsAbsent()
+    {
+        var guildServer = new Mock<IGuildServer>();
+        guildServer.Setup(g => g.GetGuildAsync(It.IsAny<uint>())).Returns(new ValueTask<Guild?>(result: null));
+        guildServer.Setup(g => g.GetPersistentGuildIdAsync(It.IsAny<uint>())).Returns(new ValueTask<Guid?>(result: null));
+
+        var result = await GuildNames.ResolveAsync(guildServer.Object, new uint[] { 7 });
+
+        Assert.That(result, Is.Empty);
+    }
+
+    /// <summary>
+    /// A single failed lookup doesn't fail the whole table.
+    /// </summary>
+    [Test]
+    public async Task FailedLookup_DoesNotFailOthers()
+    {
+        var secondId = Guid.NewGuid();
+        var guildServer = new Mock<IGuildServer>();
+        guildServer.Setup(g => g.GetGuildAsync(1)).Throws(new InvalidOperationException("guild server down"));
+        guildServer.Setup(g => g.GetPersistentGuildIdAsync(1)).Throws(new InvalidOperationException("guild server down"));
+        guildServer.Setup(g => g.GetGuildAsync(2)).Returns(new ValueTask<Guild?>(new Guild { Name = "Mages" }));
+        guildServer.Setup(g => g.GetPersistentGuildIdAsync(2)).Returns(new ValueTask<Guid?>(secondId));
+
+        var result = await GuildNames.ResolveAsync(guildServer.Object, new uint[] { 1, 2 });
+
+        Assert.That(result, Is.EqualTo(new Dictionary<uint, GuildNames.GuildInfo>
+        {
+            [2] = new GuildNames.GuildInfo("Mages", secondId),
+        }));
+    }
+
+    /// <summary>
+    /// A partially failed guild still resolves the working half, so the row keeps its name or link.
+    /// </summary>
+    [Test]
+    public async Task PartiallyFailedGuild_ResolvesWorkingHalf()
+    {
+        var guildServer = new Mock<IGuildServer>();
+        guildServer.Setup(g => g.GetGuildAsync(1)).Throws(new InvalidOperationException("guild server down"));
+        var persistentId = Guid.NewGuid();
+        guildServer.Setup(g => g.GetPersistentGuildIdAsync(1)).Returns(new ValueTask<Guid?>(persistentId));
+
+        var result = await GuildNames.ResolveAsync(guildServer.Object, new uint[] { 1 });
+
+        Assert.That(result, Is.EqualTo(new Dictionary<uint, GuildNames.GuildInfo>
+        {
+            [1] = new GuildNames.GuildInfo(null, persistentId),
+        }));
+    }
+
+    /// <summary>
+    /// Empty persistent identifiers are treated as unknown, so no dead link is rendered.
+    /// </summary>
+    [Test]
+    public async Task EmptyPersistentId_IsAbsent()
+    {
+        var guildServer = new Mock<IGuildServer>();
+        guildServer.Setup(g => g.GetGuildAsync(1)).Returns(new ValueTask<Guild?>(result: null));
+        guildServer.Setup(g => g.GetPersistentGuildIdAsync(1)).Returns(new ValueTask<Guid?>(Guid.Empty));
+
+        var result = await GuildNames.ResolveAsync(guildServer.Object, new uint[] { 1 });
+
+        Assert.That(result, Is.Empty);
+    }
+}
diff --git a/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/OnlineAccountOrderingTests.cs b/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/OnlineAccountOrderingTests.cs
index 23a41b5650..f0cb827b63 100644
--- a/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/OnlineAccountOrderingTests.cs
+++ b/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/OnlineAccountOrderingTests.cs
@@ -23,8 +23,8 @@ public void PartiedAccountsComeFirst_MembersStayContiguous()
         var accounts = new List<LoggedInAccount>
         {
             new("zSolo", 1),
-            new("bMember", 1, "CharB", "Master", 2),
-            new("aMember", 1, "CharA", "Master", 2),
+            new("bMember", 1, "CharB", PartyMaster: "Master", PartySize: 2),
+            new("aMember", 1, "CharA", PartyMaster: "Master", PartySize: 2),
             new("aSolo", 1),
         };
 
@@ -42,9 +42,9 @@ public void MultipleParties_GroupedByMaster()
         var accounts = new List<OfflineAccount>
         {
             new("solo", 1, TestTimestamp),
-            new("m2b", 1, TestTimestamp, "C2", "ZMaster", 2),
-            new("m1a", 1, TestTimestamp, "C1", "AMaster", 2),
-            new("m2a", 1, TestTimestamp, "C3", "ZMaster", 2),
+            new("m2b", 1, TestTimestamp, "C2", PartyMaster: "ZMaster", PartySize: 2),
+            new("m1a", 1, TestTimestamp, "C1", PartyMaster: "AMaster", PartySize: 2),
+            new("m2a", 1, TestTimestamp, "C3", PartyMaster: "ZMaster", PartySize: 2),
         };
 
         var result = accounts.OrderPartyGrouped().Select(a => a.LoginName).ToList();
diff --git a/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/OnlineAccountServiceTests.cs b/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/OnlineAccountServiceTests.cs
index 7ea663f20d..2fc4eef032 100644
--- a/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/OnlineAccountServiceTests.cs
+++ b/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/OnlineAccountServiceTests.cs
@@ -5,6 +5,7 @@
 namespace MUnique.OpenMU.Web.Tests.OnlineAccounts;
 
 using Moq;
+using Microsoft.Extensions.Caching.Memory;
 using MUnique.OpenMU.Interfaces;
 using MUnique.OpenMU.Web.Shared.Services;
 
@@ -25,12 +26,13 @@ public async Task LoggedInAccounts_WithoutInProcessServers_HaveNoCharacter()
         var loginServer = new Mock<ILoginServer>();
         loginServer.Setup(s => s.GetSnapshotAsync()).Returns(
             new ValueTask<Dictionary<string, byte>>(new Dictionary<string, byte> { ["bUser"] = 1, ["aUser"] = 2 }));
-        var service = new LoggedInAccountService(loginServer.Object, EmptyServerProvider());
+        var service = new LoggedInAccountService(loginServer.Object, EmptyServerProvider(), new MemoryCache(new MemoryCacheOptions()));
 
         var result = await service.GetAsync(0, 20);
 
         Assert.That(result.Select(a => a.LoginName), Is.EqualTo(new[] { "aUser", "bUser" }));
         Assert.That(result.All(a => a.CharacterName is null), Is.True);
+        Assert.That(result.All(a => a.GuildName is null), Is.True);
     }
 
     /// <summary>
@@ -42,7 +44,7 @@ public async Task LoggedInAccounts_PaginationAppliesAfterOrdering()
         var loginServer = new Mock<ILoginServer>();
         loginServer.Setup(s => s.GetSnapshotAsync()).Returns(
             new ValueTask<Dictionary<string, byte>>(new Dictionary<string, byte> { ["cUser"] = 1, ["bUser"] = 1, ["aUser"] = 1 }));
-        var service = new LoggedInAccountService(loginServer.Object, EmptyServerProvider());
+        var service = new LoggedInAccountService(loginServer.Object, EmptyServerProvider(), new MemoryCache(new MemoryCacheOptions()));
 
         var result = await service.GetAsync(1, 1);
 
@@ -50,8 +52,8 @@ public async Task LoggedInAccounts_PaginationAppliesAfterOrdering()
     }
 
     /// <summary>
-    /// Without in-process game servers there are no offline sessions to list
-    /// and the off-level tab stays hidden.
+    /// Without in-process game servers there are no offline sessions to list,
+    /// and the plugin counts as unavailable so the tab stays hidden.
     /// </summary>
     [Test]
     public async Task OfflineAccounts_WithoutInProcessServers_AreEmpty()
@@ -69,7 +71,7 @@ public async Task OfflineAccounts_WithoutInProcessServers_AreEmpty()
     [Test]
     public async Task BotAccounts_WithoutInProcessServers_AreEmpty()
     {
-        var service = new BotAccountService(EmptyServerProvider());
+        var service = new BotAccountService(EmptyServerProvider(), new MemoryCache(new MemoryCacheOptions()));
 
         Assert.That(await service.GetAsync(0, 20), Is.Empty);
         Assert.That(service.IsBotFeatureAvailable(), Is.False);
diff --git a/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/PartyColorHelperTests.cs b/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/PartyColorHelperTests.cs
new file mode 100644
index 0000000000..588fd3b46d
--- /dev/null
+++ b/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/PartyColorHelperTests.cs
@@ -0,0 +1,36 @@
+// <copyright file="PartyColorHelperTests.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Tests.OnlineAccounts;
+
+using MUnique.OpenMU.Web.AdminPanel.Components;
+
+/// <summary>
+/// Tests for the stable party badge colors.
+/// </summary>
+[TestFixture]
+public class PartyColorHelperTests
+{
+    /// <summary>
+    /// The color is a fixed function of the master name (FNV-1a hue), so it survives admin panel restarts.
+    /// </summary>
+    /// <param name="partyMaster">The party master name.</param>
+    /// <param name="expected">The expected badge color.</param>
+    [TestCase("Master", "hsl(19, 45%, 45%)")]
+    [TestCase("Alpha", "hsl(147, 45%, 45%)")]
+    [TestCase("Beta", "hsl(223, 45%, 45%)")]
+    public void GetPartyColor_ReturnsStableColor(string partyMaster, string expected)
+    {
+        Assert.That(PartyColorHelper.GetPartyColor(partyMaster), Is.EqualTo(expected));
+    }
+
+    /// <summary>
+    /// Casing doesn't change the color: all members share the badge regardless of name casing.
+    /// </summary>
+    [Test]
+    public void GetPartyColor_IsCaseInsensitive()
+    {
+        Assert.That(PartyColorHelper.GetPartyColor("master"), Is.EqualTo(PartyColorHelper.GetPartyColor("MASTER")));
+    }
+}
diff --git a/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/PartyDisplayTests.cs b/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/PartyDisplayTests.cs
new file mode 100644
index 0000000000..f6d38c9508
--- /dev/null
+++ b/tests/MUnique.OpenMU.Web.Tests/OnlineAccounts/PartyDisplayTests.cs
@@ -0,0 +1,43 @@
+// <copyright file="PartyDisplayTests.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Tests.OnlineAccounts;
+
+using Microsoft.Extensions.Logging.Abstractions;
+using MUnique.OpenMU.GameLogic;
+using MUnique.OpenMU.Web.Shared.Services;
+
+/// <summary>
+/// Tests for the party display normalization.
+/// </summary>
+[TestFixture]
+public class PartyDisplayTests
+{
+    /// <summary>
+    /// Without a party there is nothing to display.
+    /// </summary>
+    [Test]
+    public void From_NullParty_ReturnsEmpty()
+    {
+        var (master, size) = PartyDisplay.From(null);
+
+        Assert.That(master, Is.Null);
+        Assert.That(size, Is.EqualTo(0));
+    }
+
+    /// <summary>
+    /// A party without a master (e.g. momentarily during transitions) renders as solo.
+    /// </summary>
+    [Test]
+    public void From_PartyWithoutMaster_ReturnsEmpty()
+    {
+        var partyManager = new PartyManager(5, new NullLogger<Party>());
+        var party = new Party(partyManager, 5, new NullLogger<Party>());
+
+        var (master, size) = PartyDisplay.From(party);
+
+        Assert.That(master, Is.Null);
+        Assert.That(size, Is.EqualTo(0));
+    }
+}