diff --git a/Content.Server/Access/AccessWireAction.cs b/Content.Server/Access/AccessWireAction.cs
index 05ec8ace77..739e908ee5 100644
--- a/Content.Server/Access/AccessWireAction.cs
+++ b/Content.Server/Access/AccessWireAction.cs
@@ -16,27 +16,33 @@ public sealed class AccessWireAction : ComponentWireAction<AccessReaderComponent
 
     public override StatusLightState? GetLightState(Wire wire, AccessReaderComponent comp)
     {
-        return EntityManager.HasComponent<EmaggedComponent>(comp.Owner) ? StatusLightState.On : StatusLightState.Off;
+        return comp.Enabled ? StatusLightState.On : StatusLightState.Off;
     }
 
-    public override object StatusKey { get; } = AccessWireActionKey.Status;
+    public override object StatusKey => AccessWireActionKey.Status;
 
     public override bool Cut(EntityUid user, Wire wire, AccessReaderComponent comp)
     {
         WiresSystem.TryCancelWireAction(wire.Owner, PulseTimeoutKey.Key);
-        EntityManager.EnsureComponent<EmaggedComponent>(comp.Owner);
+        comp.Enabled = false;
+        EntityManager.Dirty(comp);
         return true;
     }
 
     public override bool Mend(EntityUid user, Wire wire, AccessReaderComponent comp)
     {
-        EntityManager.RemoveComponent<EmaggedComponent>(comp.Owner);
+        if (!EntityManager.HasComponent<EmaggedComponent>(wire.Owner))
+        {
+            comp.Enabled = true;
+            EntityManager.Dirty(comp);
+        }
         return true;
     }
 
     public override void Pulse(EntityUid user, Wire wire, AccessReaderComponent comp)
     {
-        EntityManager.EnsureComponent<EmaggedComponent>(comp.Owner);
+        comp.Enabled = false;
+        EntityManager.Dirty(comp);
         WiresSystem.StartWireAction(wire.Owner, _pulseTimeout, PulseTimeoutKey.Key, new TimedWireEvent(AwaitPulseCancel, wire));
     }
 
@@ -52,10 +58,10 @@ public sealed class AccessWireAction : ComponentWireAction<AccessReaderComponent
     {
         if (!wire.IsCut)
         {
-            // check is still here incase you somehow TOCTOU it into unemagging something it shouldn't
-            if (EntityManager.TryGetComponent<AccessReaderComponent>(wire.Owner, out var access))
+            if (EntityManager.TryGetComponent<AccessReaderComponent>(wire.Owner, out var access) && !EntityManager.HasComponent<EmaggedComponent>(wire.Owner))
             {
-                EntityManager.RemoveComponent<EmaggedComponent>(wire.Owner);
+                access.Enabled = true;
+                EntityManager.Dirty(access);
             }
         }
     }
diff --git a/Content.Shared/Access/Components/AccessReaderComponent.cs b/Content.Shared/Access/Components/AccessReaderComponent.cs
index a365ecae84..53e59ec94b 100644
--- a/Content.Shared/Access/Components/AccessReaderComponent.cs
+++ b/Content.Shared/Access/Components/AccessReaderComponent.cs
@@ -13,6 +13,13 @@ namespace Content.Shared.Access.Components;
 [RegisterComponent, NetworkedComponent]
 public sealed class AccessReaderComponent : Component
 {
+    /// <summary>
+    /// Whether or not the accessreader is enabled.
+    /// If not, it will always let people through.
+    /// </summary>
+    [DataField("enabled")]
+    public bool Enabled = true;
+
     /// <summary>
     ///     The set of tags that will automatically deny an allowed check, if any of them are present.
     /// </summary>
@@ -36,14 +43,17 @@ public sealed class AccessReaderComponent : Component
 [Serializable, NetSerializable]
 public sealed class AccessReaderComponentState : ComponentState
 {
+    public bool Enabled;
+
     public HashSet<string> DenyTags;
 
     public List<HashSet<string>> AccessLists;
 
     public HashSet<StationRecordKey> AccessKeys;
 
-    public AccessReaderComponentState(HashSet<string> denyTags, List<HashSet<string>> accessLists, HashSet<StationRecordKey> accessKeys)
+    public AccessReaderComponentState(bool enabled, HashSet<string> denyTags, List<HashSet<string>> accessLists, HashSet<StationRecordKey> accessKeys)
     {
+        Enabled = enabled;
         DenyTags = denyTags;
         AccessLists = accessLists;
         AccessKeys = accessKeys;
diff --git a/Content.Shared/Access/Systems/AccessReaderSystem.cs b/Content.Shared/Access/Systems/AccessReaderSystem.cs
index f8b0b47f1a..5f1dfe2ea8 100644
--- a/Content.Shared/Access/Systems/AccessReaderSystem.cs
+++ b/Content.Shared/Access/Systems/AccessReaderSystem.cs
@@ -32,7 +32,7 @@ namespace Content.Shared.Access.Systems
 
         private void OnGetState(EntityUid uid, AccessReaderComponent component, ref ComponentGetState args)
         {
-            args.State = new AccessReaderComponentState(component.DenyTags, component.AccessLists,
+            args.State = new AccessReaderComponentState(component.Enabled, component.DenyTags, component.AccessLists,
                 component.AccessKeys);
         }
 
@@ -40,6 +40,7 @@ namespace Content.Shared.Access.Systems
         {
             if (args.Current is not AccessReaderComponentState state)
                 return;
+            component.Enabled = state.Enabled;
             component.AccessKeys = new (state.AccessKeys);
             component.AccessLists = new (state.AccessLists);
             component.DenyTags = new (state.DenyTags);
@@ -67,8 +68,9 @@ namespace Content.Shared.Access.Systems
 
         private void OnEmagged(EntityUid uid, AccessReaderComponent reader, ref GotEmaggedEvent args)
         {
-            // no fancy conditions
             args.Handled = true;
+            reader.Enabled = false;
+            Dirty(reader);
         }
 
         /// <summary>
@@ -95,6 +97,10 @@ namespace Content.Shared.Access.Systems
         {
             var allEnts = FindPotentialAccessItems(entity);
 
+            // Access reader is totally disabled, so access is always allowed.
+            if (!reader.Enabled)
+                return true;
+
             if (AreAccessTagsAllowed(FindAccessTags(entity, allEnts), reader))
                 return true;
 
@@ -111,12 +117,6 @@ namespace Content.Shared.Access.Systems
         /// <param name="reader">An access reader to check against</param>
         public bool AreAccessTagsAllowed(ICollection<string> accessTags, AccessReaderComponent reader)
         {
-            if (HasComp<EmaggedComponent>(reader.Owner))
-            {
-                // Access reader is totally disabled, so access is always allowed.
-                return true;
-            }
-
             if (reader.DenyTags.Overlaps(accessTags))
             {
                 // Sec owned by cargo.