diff --git a/Automate/Framework/Commands/Summary/GroupContainerStats.cs b/Automate/Framework/Commands/Summary/GroupContainerStats.cs
index b41fc5b2f..fbe787766 100644
--- a/Automate/Framework/Commands/Summary/GroupContainerStats.cs
+++ b/Automate/Framework/Commands/Summary/GroupContainerStats.cs
@@ -28,7 +28,7 @@ internal class GroupContainerStats
     public int TotalSlots { get; }
 
     /// <summary>Whether the container is a Junimo chest.</summary>
-    public bool IsJunimoChest { get; }
+    public HashSet<string> GlobalInventoryChests { get; } = new(StringComparer.OrdinalIgnoreCase);
 
 
     /*********
@@ -47,12 +47,11 @@ public GroupContainerStats(string name, AutomateContainerPreference storagePrefe
 
         foreach (IContainer container in containers)
         {
-            // only track Junimo chests once
-            if (container.IsJunimoChest)
+            // only track same global inventory chest once
+            if (container.IsGlobalChest)
             {
-                if (this.IsJunimoChest)
+                if (this.GlobalInventoryChests.Add(container.GlobalInventoryId))
                     continue;
-                this.IsJunimoChest = true;
             }
 
             // track stats
diff --git a/Automate/Framework/Commands/Summary/GroupStats.cs b/Automate/Framework/Commands/Summary/GroupStats.cs
index 3f11e391c..c648aceee 100644
--- a/Automate/Framework/Commands/Summary/GroupStats.cs
+++ b/Automate/Framework/Commands/Summary/GroupStats.cs
@@ -35,7 +35,7 @@ public GroupStats(IMachineGroup machineGroup)
     {
         this.MachineGroup = machineGroup;
 
-        if (machineGroup.IsJunimoGroup)
+        if (machineGroup.IsGlobalGroup)
             this.Name = "Distributed group";
         else
         {
@@ -43,7 +43,7 @@ public GroupStats(IMachineGroup machineGroup)
             this.Name = $"Group at ({tile.X}, {tile.Y})";
         }
 
-        this.IsJunimoGroup = machineGroup.IsJunimoGroup;
+        this.IsJunimoGroup = machineGroup.IsGlobalGroup;
 
         this.Machines = machineGroup.Machines
             .GroupBy(p => p.MachineTypeID)
diff --git a/Automate/Framework/Commands/SummaryCommand.cs b/Automate/Framework/Commands/SummaryCommand.cs
index 8e1e7cd4e..941d41d95 100644
--- a/Automate/Framework/Commands/SummaryCommand.cs
+++ b/Automate/Framework/Commands/SummaryCommand.cs
@@ -189,7 +189,7 @@ public override void Handle(string[] args)
                                             .ThenBy(p => p.TileArea.Y)
                                             .ToArray();
 
-                                        IContainer[] junimoChests = chests.Where(p => p.IsJunimoChest).ToArray();
+                                        IContainer[] junimoChests = chests.Where(p => p.IsGlobalChest).ToArray();
                                         return junimoChests.Any()
                                             ? junimoChests
                                             : chests; // special case: no Junimo chests in this location, but we're still connected somehow. This is most likely a custom connected chest from another mod, so just list all of them.
diff --git a/Automate/Framework/JunimoMachineGroup.cs b/Automate/Framework/GlobalMachineGroup.cs
similarity index 93%
rename from Automate/Framework/JunimoMachineGroup.cs
rename to Automate/Framework/GlobalMachineGroup.cs
index 7bc9b5909..dd3426264 100644
--- a/Automate/Framework/JunimoMachineGroup.cs
+++ b/Automate/Framework/GlobalMachineGroup.cs
@@ -9,7 +9,7 @@
 namespace Pathoschild.Stardew.Automate.Framework;
 
 /// <summary>An aggregate collection of machine groups linked by Junimo chests.</summary>
-internal class JunimoMachineGroup : MachineGroup
+internal class GlobalMachineGroup : MachineGroup
 {
     /*********
     ** Fields
@@ -38,7 +38,7 @@ internal class JunimoMachineGroup : MachineGroup
     /// <param name="sortMachines">Sort machines by priority.</param>
     /// <param name="buildStorage">Build a storage manager for the given containers.</param>
     /// <param name="monitor">Encapsulates monitoring and logging.</param>
-    public JunimoMachineGroup(Func<IEnumerable<IMachine>, IEnumerable<IMachine>> sortMachines, Func<IContainer[], StorageManager> buildStorage, IMonitor monitor)
+    public GlobalMachineGroup(Func<IEnumerable<IMachine>, IEnumerable<IMachine>> sortMachines, Func<IContainer[], StorageManager> buildStorage, IMonitor monitor)
         : base(
             locationKey: null,
             machines: [],
@@ -48,7 +48,7 @@ public JunimoMachineGroup(Func<IEnumerable<IMachine>, IEnumerable<IMachine>> sor
             monitor: monitor
         )
     {
-        this.IsJunimoGroup = true;
+        this.IsGlobalGroup = true;
         this.SortMachines = sortMachines;
     }
 
@@ -64,12 +64,14 @@ public IEnumerable<IMachineGroup> GetAll()
     public void Add(IList<IMachineGroup> groups)
     {
         this.MachineGroups.AddRange(groups);
+        this.GlobalContainerKeys.UnionWith(groups.SelectMany(p => p.GlobalContainerKeys));
     }
 
     /// <summary>Remove all machine groups in the collection.</summary>
     public void Clear()
     {
         this.MachineGroups.Clear();
+        this.GlobalContainerKeys.Clear();
 
         this.StorageManager.SetContainers([]);
 
@@ -94,6 +96,8 @@ public void Rebuild()
         this.Machines = this.SortMachines(this.MachineGroups.SelectMany(p => p.Machines)).ToArray();
         this.Tiles = null;
 
+        this.GlobalContainerKeys.Clear();
+        this.GlobalContainerKeys.UnionWith(this.MachineGroups.SelectMany(p => p.GlobalContainerKeys));
         this.StorageManager.SetContainers(this.Containers);
     }
 
diff --git a/Automate/Framework/IMachineGroup.cs b/Automate/Framework/IMachineGroup.cs
index 187e5492a..05db6ac39 100644
--- a/Automate/Framework/IMachineGroup.cs
+++ b/Automate/Framework/IMachineGroup.cs
@@ -8,20 +8,23 @@ namespace Pathoschild.Stardew.Automate.Framework;
 internal interface IMachineGroup
 {
     /*********
-    ** Accessors
-    *********/
+     ** Accessors
+     *********/
     /// <summary>The main location containing the group (as formatted by <see cref="MachineGroupFactory.GetLocationKey"/>), unless this is an aggregate machine group.</summary>
     string? LocationKey { get; }
 
-    /// <summary>The machines in the group.</summary>
+    /// <summary>The keys for all containers which are linked to global inventories.</summary>
+    HashSet<string> GlobalContainerKeys { get; }
+
+/// <summary>The machines in the group.</summary>
     IMachine[] Machines { get; }
 
     /// <summary>The containers in the group.</summary>
     IContainer[] Containers { get; }
 
-    /// <summary>Whether the machine group is linked to a Junimo chest.</summary>
+    /// <summary>Whether the machine group is linked to a global inventory.</summary>
     [MemberNotNullWhen(false, nameof(IMachineGroup.LocationKey))]
-    bool IsJunimoGroup { get; }
+    bool IsGlobalGroup { get; }
 
     /// <summary>Whether the group has the minimum requirements to enable internal automation (i.e., at least one chest and one machine).</summary>
     bool HasInternalAutomation { get; }
diff --git a/Automate/Framework/MachineDataForLocation.cs b/Automate/Framework/MachineDataForLocation.cs
index 47d5eb806..618d9a054 100644
--- a/Automate/Framework/MachineDataForLocation.cs
+++ b/Automate/Framework/MachineDataForLocation.cs
@@ -43,7 +43,7 @@ internal record MachineDataForLocation(string LocationKey, IReadOnlyCollection<I
     *********/
     /// <summary>Get whether the tile area intersects a machine group which meets the minimum requirements for automation (regardless of whether the machines are currently running).</summary>
     /// <param name="tileArea">The tile area to check.</param>
-    /// <remarks>This is the normal-chest equivalent of <see cref="JunimoMachineGroup.IntersectsAutomatedGroup"/>.</remarks>
+    /// <remarks>This is the normal-chest equivalent of <see cref="GlobalMachineGroup.IntersectsAutomatedGroup"/>.</remarks>
     public bool IntersectsAutomatedGroup(Rectangle tileArea)
     {
         var activeTiles = this.ActiveTiles;
@@ -59,7 +59,7 @@ public bool IntersectsAutomatedGroup(Rectangle tileArea)
 
     /// <summary>Get whether a tile area contains or is adjacent to a tracked automateable.</summary>
     /// <param name="tileArea">The tile area to check.</param>
-    /// <remarks>This is the normal-chest equivalent of <see cref="JunimoMachineGroup.ContainsOrAdjacent"/>.</remarks>
+    /// <remarks>This is the normal-chest equivalent of <see cref="GlobalMachineGroup.ContainsOrAdjacent"/>.</remarks>
     public bool ContainsOrAdjacent(Rectangle tileArea)
     {
         var activeTiles = this.ActiveTiles;
diff --git a/Automate/Framework/MachineGroup.cs b/Automate/Framework/MachineGroup.cs
index 7e26f416e..33c45eba4 100644
--- a/Automate/Framework/MachineGroup.cs
+++ b/Automate/Framework/MachineGroup.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
 using System.Linq;
 using Microsoft.Xna.Framework;
 using Pathoschild.Stardew.Common;
@@ -59,6 +60,9 @@ internal class MachineGroup : IMachineGroup
     /// <inheritdoc />
     public string? LocationKey { get; }
 
+    /// <inheritdoc />
+    public HashSet<string> GlobalContainerKeys { get; } = new(StringComparer.OrdinalIgnoreCase);
+
     /// <inheritdoc />
     public IMachine[] Machines { get; protected set; }
 
@@ -67,10 +71,10 @@ internal class MachineGroup : IMachineGroup
 
     /// <inheritdoc />
     [MemberNotNullWhen(false, nameof(IMachineGroup.LocationKey))]
-    public bool IsJunimoGroup { get; protected set; }
+    public bool IsGlobalGroup { get; protected set; }
 
     /// <inheritdoc />
-    public virtual bool HasInternalAutomation => this.IsJunimoGroup || (this.Machines.Length > 0 && this.Containers.Any(p => !p.IsJunimoChest));
+    public virtual bool HasInternalAutomation => this.IsGlobalGroup || (this.Machines.Length > 0 && this.Containers.Any(p => !p.IsGlobalChest));
 
 
     /*********
@@ -91,7 +95,15 @@ public MachineGroup(string? locationKey, IEnumerable<IMachine> machines, IEnumer
         this.Tiles = [.. tiles];
         this.Monitor = monitor;
 
-        this.IsJunimoGroup = this.Containers.Any(p => p.IsJunimoChest);
+        foreach (IContainer container in this.Containers)
+        {
+            if (container.IsGlobalChest)
+            {
+                this.GlobalContainerKeys.Add(container.GlobalInventoryId);
+            }
+        }
+
+        this.IsGlobalGroup = this.GlobalContainerKeys.Count > 0;
         this.StorageManager = buildStorage(this.GetUniqueContainers(this.Containers));
     }
 
diff --git a/Automate/Framework/MachineManager.cs b/Automate/Framework/MachineManager.cs
index 461742e0f..b942714ca 100644
--- a/Automate/Framework/MachineManager.cs
+++ b/Automate/Framework/MachineManager.cs
@@ -47,7 +47,7 @@ internal class MachineManager
     public MachineGroupFactory Factory { get; }
 
     /// <summary>An aggregate collection of machine groups linked by Junimo chests.</summary>
-    public JunimoMachineGroup JunimoMachineGroup { get; }
+    public List<GlobalMachineGroup> GlobalMachineGroups { get; } = new();
 
 
     /*********
@@ -67,7 +67,7 @@ public MachineManager(Func<ModConfig> config, DataModel data, IAutomationFactory
         this.Factory = new(this.GetMachineOverride, this.BuildStorage, monitor);
         this.Factory.Add(defaultFactory);
 
-        this.JunimoMachineGroup = new(this.Factory.SortMachines, this.BuildStorage, this.Monitor);
+        //this.GlobalMachineGroups = new(this.Factory.SortMachines, this.BuildStorage, this.Monitor);
     }
 
     /****
@@ -76,8 +76,9 @@ public MachineManager(Func<ModConfig> config, DataModel data, IAutomationFactory
     /// <summary>Get the machine groups in every location.</summary>
     public IEnumerable<IMachineGroup> GetActiveMachineGroups()
     {
-        if (this.JunimoMachineGroup.HasInternalAutomation)
-            yield return this.JunimoMachineGroup;
+        foreach (IMachineGroup group in this.GlobalMachineGroups)
+            if (group.HasInternalAutomation)
+                yield return group;
 
         foreach (IMachineGroup group in this.ActiveMachineGroups)
             yield return group;
@@ -92,7 +93,7 @@ public IEnumerable<IMachineGroup> GetForApi(GameLocation location)
         return this
             .ActiveMachineGroups
             .Concat(this.DisabledMachineGroups)
-            .Concat(this.JunimoMachineGroup.GetAll())
+            .Concat(this.GlobalMachineGroups.SelectMany(group => group.GetAll()))
             .Where(p => p.LocationKey == locationKey);
     }
 
@@ -141,7 +142,7 @@ public void Clear()
         this.MachineData.Clear();
         this.ActiveMachineGroups = [];
         this.DisabledMachineGroups = [];
-        this.JunimoMachineGroup.Clear();
+        this.GlobalMachineGroups.Clear();
     }
 
     /// <summary>Clear all registered machines and add all locations to the reload queue.</summary>
@@ -149,7 +150,8 @@ public void Reset()
     {
         this.Clear();
 
-        this.JunimoMachineGroup.Rebuild();
+        foreach (GlobalMachineGroup group in this.GlobalMachineGroups)
+            group.Rebuild();
 
         this.ReloadQueue.AddRange(CommonHelper.GetLocations());
     }
@@ -213,7 +215,8 @@ private StorageManager BuildStorage(IContainer[] containers)
     /// <param name="removedLocations">The locations which have been removed, and whose machines should be reloaded if they still exist.</param>
     private void ReloadMachinesIn(ISet<GameLocation> locations, ISet<GameLocation> removedLocations)
     {
-        bool junimoGroupChanged = false;
+        List<IMachineGroup> globalAdded = [];
+        HashSet<IMachineGroup> globalChanged = [];
         bool anyChanged = false;
 
         // remove old groups
@@ -225,10 +228,13 @@ private void ReloadMachinesIn(ISet<GameLocation> locations, ISet<GameLocation> r
             foreach (string locationKey in locationKeys)
                 anyChanged |= this.MachineData.Remove(locationKey);
 
-            if (this.JunimoMachineGroup.RemoveLocations(locationKeys))
+            foreach (GlobalMachineGroup globalGroup in this.GlobalMachineGroups)
             {
-                anyChanged = true;
-                junimoGroupChanged = true;
+                if (globalGroup.RemoveLocations(locationKeys))
+                {
+                    anyChanged = true;
+                    globalChanged.Add(globalGroup);
+                }
             }
         }
 
@@ -240,31 +246,26 @@ private void ReloadMachinesIn(ISet<GameLocation> locations, ISet<GameLocation> r
             // collect new groups
             List<IMachineGroup> active = [];
             List<IMachineGroup> disabled = [];
-            List<IMachineGroup> junimo = [];
             foreach (IMachineGroup group in this.Factory.GetMachineGroups(location, this.Monitor))
             {
                 if (!group.HasInternalAutomation)
                     disabled.Add(group);
 
-                else if (group.IsJunimoGroup)
-                    junimo.Add(group);
+                else if (!group.IsGlobalGroup)
+                    active.Add(group);
 
                 else
-                    active.Add(group);
+                {
+                    globalAdded.Add(group);
+                    globalChanged.Add(group);
+                }
             }
 
             // add groups
             this.MachineData[locationKey] = new MachineDataForLocation(locationKey, active, disabled);
 
             // track change
-            if (junimo.Any())
-            {
-                this.JunimoMachineGroup.Add(junimo);
-                junimoGroupChanged = true;
-                anyChanged = true;
-            }
-            else if (active.Any())
-                anyChanged = true;
+            anyChanged |= active.Any();
         }
 
         // rebuild caches
@@ -283,7 +284,60 @@ private void ReloadMachinesIn(ISet<GameLocation> locations, ISet<GameLocation> r
             this.DisabledMachineGroups = disabled.ToArray();
         }
 
-        if (junimoGroupChanged)
-            this.JunimoMachineGroup.Rebuild();
+        if (!globalChanged.Any())
+            return;
+
+        // determine distinct groups
+        List<HashSet<string>> distinctGlobalGroups = [];
+        foreach (HashSet<string> groupKeys in globalChanged.Select(p => p.GlobalContainerKeys))
+        {
+            HashSet<string>? existing = distinctGlobalGroups.FirstOrDefault(p => p.Overlaps(groupKeys));
+            if (existing != null)
+                existing.UnionWith(groupKeys);
+            else
+                distinctGlobalGroups.Add(groupKeys);
+        }
+
+        foreach (HashSet<string> groupKeys in distinctGlobalGroups)
+        {
+            GlobalMachineGroup? selectedGroup = null;
+            int total = this.GlobalMachineGroups.Count;
+
+            for (int i = 0; i < total; i++)
+            {
+                GlobalMachineGroup globalGroup = this.GlobalMachineGroups[i];
+                if (!globalGroup.GlobalContainerKeys.Overlaps(groupKeys))
+                    continue;
+
+                selectedGroup ??= globalGroup;
+                if (selectedGroup == globalGroup)
+                    globalChanged.Add(selectedGroup);
+
+                else
+                {
+                    selectedGroup.Add([.. globalGroup.GetAll()]);
+                    this.GlobalMachineGroups.Remove(globalGroup);
+                    total--;
+                }
+            }
+
+            // create new group
+            if (selectedGroup == null)
+            {
+                selectedGroup = new GlobalMachineGroup(this.Factory.SortMachines, this.BuildStorage, this.Monitor);
+                this.GlobalMachineGroups.Add(selectedGroup);
+            }
+
+            // add groups to selected
+            IList<IMachineGroup> groups = [.. globalAdded.Where(p => p.GlobalContainerKeys.Overlaps(groupKeys))];
+            if (groups.Any())
+                selectedGroup.Add(groups);
+        }
+
+        // rebuild groups
+        foreach (GlobalMachineGroup globalGroup in globalChanged.OfType<GlobalMachineGroup>())
+        {
+            globalGroup.Rebuild();
+        }
     }
 }
diff --git a/Automate/Framework/OverlayMenu.cs b/Automate/Framework/OverlayMenu.cs
index 7a4d8deca..03b87337f 100644
--- a/Automate/Framework/OverlayMenu.cs
+++ b/Automate/Framework/OverlayMenu.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 using Pathoschild.Stardew.Common;
@@ -25,8 +26,8 @@ internal class OverlayMenu : BaseOverlay
     /// <summary>The machine data for the current location.</summary>
     private readonly MachineDataForLocation? MachineData;
 
-    /// <summary>The machine group for machines connected to Junimo chests.</summary>
-    private readonly JunimoMachineGroup JunimoGroup;
+    /// <summary>The machine groups for machines connected to global inventories.</summary>
+    private readonly List<GlobalMachineGroup> GlobalGroups;
 
 
     /*********
@@ -38,13 +39,13 @@ internal class OverlayMenu : BaseOverlay
     /// <param name="reflection">Simplifies access to private code.</param>
     /// <param name="locationKey">The unique key for the current location.</param>
     /// <param name="machineData">The machine groups to display.</param>
-    /// <param name="junimoGroup">The machine group for machines connected to Junimo chests.</param>
-    public OverlayMenu(IModEvents events, IInputHelper inputHelper, IReflectionHelper reflection, string locationKey, MachineDataForLocation? machineData, JunimoMachineGroup junimoGroup)
+    /// <param name="globalGroups">The machine group for machines connected to global inventories.</param>
+    public OverlayMenu(IModEvents events, IInputHelper inputHelper, IReflectionHelper reflection, string locationKey, MachineDataForLocation? machineData, List<GlobalMachineGroup> globalGroups)
         : base(events, inputHelper, reflection)
     {
         this.LocationKey = locationKey;
         this.MachineData = machineData;
-        this.JunimoGroup = junimoGroup;
+        this.GlobalGroups = globalGroups;
     }
 
 
@@ -59,7 +60,7 @@ protected override void DrawWorld(SpriteBatch spriteBatch)
             return;
 
         // draw each tile
-        IReadOnlySet<Vector2> junimoChestTiles = this.JunimoGroup.GetTiles(this.LocationKey);
+        IReadOnlySet<Vector2> globalInventoryTiles = new HashSet<Vector2>(this.GlobalGroups.SelectMany(p => p.GetTiles(this.LocationKey)));
         foreach (Vector2 tile in TileHelper.GetVisibleTiles(expand: 1))
         {
             // get tile's screen coordinates
@@ -70,12 +71,12 @@ protected override void DrawWorld(SpriteBatch spriteBatch)
             // get machine group
             IMachineGroup? group = null;
             Color? color = null;
-            if (junimoChestTiles.Contains(tile))
+            if (globalInventoryTiles.Contains(tile))
             {
-                color = this.JunimoGroup.HasInternalAutomation
+                group = this.GlobalGroups.FirstOrDefault(p => p.GetTiles(this.LocationKey).Contains(tile));
+                color = group?.HasInternalAutomation == true
                     ? Color.Green * 0.2f
                     : Color.Red * 0.2f;
-                group = this.JunimoGroup;
             }
             else if (this.MachineData is not null)
             {
diff --git a/Automate/Framework/Storage/ChestContainer.cs b/Automate/Framework/Storage/ChestContainer.cs
index ab646cbe1..9280f30d3 100644
--- a/Automate/Framework/Storage/ChestContainer.cs
+++ b/Automate/Framework/Storage/ChestContainer.cs
@@ -33,11 +33,14 @@ internal class ChestContainer : IContainer
     /// <inheritdoc />
     public string Name => this.Chest.Name;
 
+    /// <inheritdoc />
+    public string? GlobalInventoryId => this.Chest.GlobalInventoryId ?? (this.Chest.SpecialChestType == Chest.SpecialChestTypes.JunimoChest ? "JunimoChests" : null);
+
     /// <inheritdoc />
     public ModDataDictionary ModData => this.Chest.modData;
 
     /// <inheritdoc />
-    public bool IsJunimoChest => this.Chest.SpecialChestType == Chest.SpecialChestTypes.JunimoChest;
+    public bool IsGlobalChest => this.Chest.SpecialChestType == Chest.SpecialChestTypes.JunimoChest || this.Chest.GlobalInventoryId != null;
 
     /// <inheritdoc />
     public bool IsLocked => this.Chest.GetMutex().IsLocked();
diff --git a/Automate/Framework/StorageManager.cs b/Automate/Framework/StorageManager.cs
index 8be655787..f91b8c690 100644
--- a/Automate/Framework/StorageManager.cs
+++ b/Automate/Framework/StorageManager.cs
@@ -38,13 +38,13 @@ public void SetContainers(IEnumerable<IContainer> containers)
 
         this.InputContainers = containerCollection
             .Where(p => p.StorageAllowed())
-            .OrderBy(p => p.IsJunimoChest) // push items into Junimo chests last
+            .OrderBy(p => p.IsGlobalChest) // push items into Junimo chests last
             .ThenByDescending(p => p.StoragePreferred())
             .ToArray();
 
         this.OutputContainers = containerCollection
             .Where(p => p.TakingItemsAllowed())
-            .OrderByDescending(p => p.IsJunimoChest) // take items from Junimo chests first
+            .OrderByDescending(p => p.IsGlobalChest) // take items from Junimo chests first
             .ThenByDescending(p => p.TakingItemsPreferred())
             .ToArray();
     }
diff --git a/Automate/IContainer.cs b/Automate/IContainer.cs
index 8ee581e08..c319d53fb 100644
--- a/Automate/IContainer.cs
+++ b/Automate/IContainer.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using StardewValley;
 using StardewValley.Inventories;
 using StardewValley.Mods;
@@ -15,11 +16,15 @@ public interface IContainer : IAutomatable, IEnumerable<ITrackedStack>
     /// <summary>The container name (if any).</summary>
     string Name { get; }
 
+    /// <summary>The global inventory id (if any).</summary>
+    string? GlobalInventoryId { get; }
+
     /// <summary>The raw mod data for the container.</summary>
     ModDataDictionary ModData { get; }
 
-    /// <summary>Whether this is a Junimo chest, which shares a global inventory with all other Junimo chests.</summary>
-    bool IsJunimoChest { get; }
+    /// <summary>Whether this is a global inventory chest, which shares an inventory with all other chests with the same Global Inventory Id.</summary>
+    [MemberNotNullWhen(true, nameof(IContainer.GlobalInventoryId))]
+    bool IsGlobalChest { get; }
 
     /// <summary>Whether this chest is locked (e.g. because a player has it open).</summary>
     bool IsLocked { get; }
diff --git a/Automate/ModEntry.cs b/Automate/ModEntry.cs
index 9bfb27ade..2f0477a8d 100644
--- a/Automate/ModEntry.cs
+++ b/Automate/ModEntry.cs
@@ -430,7 +430,7 @@ private void EnableOverlay()
             reflection: this.Helper.Reflection,
             locationKey: this.MachineManager.Factory.GetLocationKey(Game1.currentLocation),
             machineData: this.MachineManager.GetMachineDataFor(Game1.currentLocation),
-            junimoGroup: this.MachineManager.JunimoMachineGroup
+            globalGroups: this.MachineManager.GlobalMachineGroups
         );
     }
 
@@ -453,7 +453,7 @@ private bool ReloadIfNeeded<TEntity>(GameLocation location, IEnumerable<DiffEntr
     {
         string locationKey = this.MachineManager.Factory.GetLocationKey(location);
         MachineDataForLocation? data = this.MachineManager.GetMachineDataFor(location);
-        JunimoMachineGroup junimoData = this.MachineManager.JunimoMachineGroup;
+        List<GlobalMachineGroup> globalData = this.MachineManager.GlobalMachineGroups;
 
         bool shouldReload = false;
         foreach ((Rectangle tileArea, TEntity entity, bool isAdded) in entities)
@@ -479,7 +479,7 @@ private bool ReloadIfNeeded<TEntity>(GameLocation location, IEnumerable<DiffEntr
             if (isAdded)
             {
                 shouldReload =
-                    junimoData.ContainsOrAdjacent(locationKey, tileArea)
+                    globalData.Any(p => p.ContainsOrAdjacent(locationKey, tileArea))
                     || (automateable is IContainer ? data.ContainsOrAdjacent(tileArea) : data.IsConnectedToChest(tileArea));
 
                 if (shouldReload)
@@ -487,7 +487,7 @@ private bool ReloadIfNeeded<TEntity>(GameLocation location, IEnumerable<DiffEntr
             }
 
             // reload if removed from a valid machine group
-            if (data.IntersectsAutomatedGroup(tileArea) || junimoData.IntersectsAutomatedGroup(locationKey, tileArea))
+            if (data.IntersectsAutomatedGroup(tileArea) || globalData.Any(p => p.IntersectsAutomatedGroup(locationKey, tileArea)))
             {
                 shouldReload = true;
                 break;