diff --git a/src/main/java/com/azuredoom/levelingcore/systems/level/MobLevelSystem.java b/src/main/java/com/azuredoom/levelingcore/systems/level/MobLevelSystem.java
index e375acb..eb1d1ca 100644
--- a/src/main/java/com/azuredoom/levelingcore/systems/level/MobLevelSystem.java
+++ b/src/main/java/com/azuredoom/levelingcore/systems/level/MobLevelSystem.java
@@ -17,7 +17,6 @@
 
 import java.util.Locale;
 import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 
 import com.azuredoom.levelingcore.LevelingCore;
@@ -37,12 +36,12 @@ public class MobLevelSystem extends EntityTickingSystem<EntityStore> {
 
     private final ConcurrentLinkedQueue<PendingUpdate> pending = new ConcurrentLinkedQueue<>();
 
-    private final AtomicBoolean drainScheduled = new AtomicBoolean(false);
-
     private static final int MAX_UPDATES_PER_DRAIN = 1000;
 
     private final Config<GUIConfig> config;
 
+    private boolean drainScheduled = false;
+
     public MobLevelSystem(Config<GUIConfig> config) {
         this.config = config;
     }
@@ -95,65 +94,64 @@ public void tick(
 
         data.lastRecalcMs = nowMs;
 
-        pending.add(new PendingUpdate(npc, transform, store, data));
+        pending.add(new PendingUpdate(npc, transform, data));
 
-        if (drainScheduled.compareAndSet(false, true)) {
-            store.getExternalData().getWorld().execute(() -> drainPending(store));
+        if (!drainScheduled) {
+            drainScheduled = true;
+            drainPending(store);
         }
     }
 
     private void drainPending(@NonNullDecl Store<EntityStore> store) {
-        store.getExternalData().getWorld().execute(() -> {
-            try {
-                var mobMaxLevel = computeMobMaxLevel();
+        try {
+            var mobMaxLevel = computeMobMaxLevel();
 
-                var processed = 0;
-                PendingUpdate u;
+            var processed = 0;
+            PendingUpdate u;
 
-                while (processed < MAX_UPDATES_PER_DRAIN && (u = pending.poll()) != null) {
-                    var npc = u.npc();
-                    var transform = u.transform();
-                    var store1 = u.store();
-                    var data = u.data();
+            while (processed < MAX_UPDATES_PER_DRAIN && (u = pending.poll()) != null) {
+                var npc = u.npc();
+                var transform = u.transform();
+                var data = u.data();
 
-                    if (data.locked)
-                        continue;
+                if (data.locked)
+                    continue;
 
-                    var newLevel = Math.max(
-                        1,
-                        Math.min(mobMaxLevel, MobLevelingUtil.computeDynamicLevel(config, npc, transform, store1))
-                    );
+                var newLevel = Math.max(
+                    1,
+                    Math.min(mobMaxLevel, MobLevelingUtil.computeDynamicLevel(config, npc, transform, store))
+                );
 
-                    if (newLevel != data.level) {
-                        data.level = newLevel;
-                    }
+                if (newLevel != data.level) {
+                    data.level = newLevel;
+                }
 
-                    if (!data.locked) {
-                        data.level = Math.max(
-                            1,
-                            Math.min(
-                                mobMaxLevel,
-                                MobLevelingUtil.computeDynamicLevel(config, npc, transform, store1)
-                            )
-                        );
-                    }
+                if (!data.locked) {
+                    data.level = Math.max(
+                        1,
+                        Math.min(
+                            mobMaxLevel,
+                            MobLevelingUtil.computeDynamicLevel(config, npc, transform, store)
+                        )
+                    );
+                }
 
-                    if (data.level != data.lastAppliedLevel) {
-                        if (MobLevelingUtil.applyMobScaling(config, npc, data.level, store1)) {
-                            data.lastAppliedLevel = data.level;
-                        }
+                if (data.level != data.lastAppliedLevel) {
+                    if (MobLevelingUtil.applyMobScaling(config, npc, data.level, store)) {
+                        data.lastAppliedLevel = data.level;
                     }
-
-                    processed++;
                 }
-            } finally {
-                drainScheduled.set(false);
 
-                if (!pending.isEmpty() && drainScheduled.compareAndSet(false, true)) {
-                    store.getExternalData().getWorld().execute(() -> drainPending(store));
-                }
+                processed++;
+            }
+        } finally {
+            if (!pending.isEmpty()) {
+                drainScheduled = true;
+                drainPending(store);
+            } else {
+                drainScheduled = false;
             }
-        });
+        }
     }
 
     private int computeMobMaxLevel() {
diff --git a/src/main/java/com/azuredoom/levelingcore/utils/PendingUpdate.java b/src/main/java/com/azuredoom/levelingcore/utils/PendingUpdate.java
index 98134eb..42f4344 100644
--- a/src/main/java/com/azuredoom/levelingcore/utils/PendingUpdate.java
+++ b/src/main/java/com/azuredoom/levelingcore/utils/PendingUpdate.java
@@ -1,8 +1,6 @@
 package com.azuredoom.levelingcore.utils;
 
-import com.hypixel.hytale.component.Store;
 import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
-import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
 import com.hypixel.hytale.server.npc.entities.NPCEntity;
 
 import com.azuredoom.levelingcore.level.mobs.MobLevelData;
@@ -10,6 +8,5 @@
 public record PendingUpdate(
     NPCEntity npc,
     TransformComponent transform,
-    Store<EntityStore> store,
     MobLevelData data
 ) {}