@@ -17,6 +17,10 @@
 from .distributed_enforcer import DistributedEnforcer
 from .fast_enforcer import FastEnforcer
 from .async_enforcer import AsyncEnforcer
+from .cached_enforcer import CachedEnforcer
+from .synced_cached_enforcer import SyncedCachedEnforcer
+from .async_cached_enforcer import AsyncCachedEnforcer
+from .cache import Cache, DefaultCache
 from . import util
 from .persist import *
 from .effect import *
 
@@ -0,0 +1,101 @@
+# Copyright 2026 The casbin Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from casbin.async_enforcer import AsyncEnforcer
+from casbin.cached_enforcer import CacheSupport
+
+
+class AsyncCachedEnforcer(CacheSupport, AsyncEnforcer):
+    """AsyncEnforcer that caches enforce() decisions.
+
+    Only policy management is asynchronous upstream; enforce()/enforce_ex() stay
+    synchronous, and so does the caching around them. The methods overridden here are
+    exactly the mutating ones AsyncEnforcer defines as coroutines -- the synchronous ones
+    are handled by CacheSupport, and redeclaring them as coroutines here would turn calls
+    like ``e.clear_policy()`` into un-awaited no-ops.
+
+    See CachedEnforcer for what the cache does and does not notice.
+    """
+
+    async def load_policy(self):
+        try:
+            return await super().load_policy()
+        finally:
+            self.invalidate_cache()
+
+    async def load_filtered_policy(self, filter):
+        try:
+            return await super().load_filtered_policy(filter)
+        finally:
+            self.invalidate_cache()
+
+    async def load_increment_filtered_policy(self, filter):
+        try:
+            return await super().load_increment_filtered_policy(filter)
+        finally:
+            self.invalidate_cache()
+
+    async def _add_policy(self, sec, ptype, rule):
+        try:
+            return await super()._add_policy(sec, ptype, rule)
+        finally:
+            self.invalidate_cache()
+
+    async def _add_policies(self, sec, ptype, rules):
+        try:
+            return await super()._add_policies(sec, ptype, rules)
+        finally:
+            self.invalidate_cache()
+
+    async def _update_policy(self, sec, ptype, old_rule, new_rule):
+        try:
+            return await super()._update_policy(sec, ptype, old_rule, new_rule)
+        finally:
+            self.invalidate_cache()
+
+    async def _update_policies(self, sec, ptype, old_rules, new_rules):
+        try:
+            return await super()._update_policies(sec, ptype, old_rules, new_rules)
+        finally:
+            self.invalidate_cache()
+
+    async def _update_filtered_policies(self, sec, ptype, new_rules, field_index, *field_values):
+        try:
+            return await super()._update_filtered_policies(sec, ptype, new_rules, field_index, *field_values)
+        finally:
+            self.invalidate_cache()
+
+    async def _remove_policy(self, sec, ptype, rule):
+        try:
+            return await super()._remove_policy(sec, ptype, rule)
+        finally:
+            self.invalidate_cache()
+
+    async def _remove_policies(self, sec, ptype, rules):
+        try:
+            return await super()._remove_policies(sec, ptype, rules)
+        finally:
+            self.invalidate_cache()
+
+    async def _remove_filtered_policy(self, sec, ptype, field_index, *field_values):
+        try:
+            return await super()._remove_filtered_policy(sec, ptype, field_index, *field_values)
+        finally:
+            self.invalidate_cache()
+
+    async def _remove_filtered_policy_returns_effects(self, sec, ptype, field_index, *field_values):
+        try:
+            return await super()._remove_filtered_policy_returns_effects(sec, ptype, field_index, *field_values)
+        finally:
+            self.invalidate_cache()
@@ -0,0 +1,18 @@
+# Copyright 2026 The casbin Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .cache import Cache
+from .default_cache import DefaultCache, DEFAULT_MAX_SIZE
+
+__all__ = ["Cache", "DefaultCache", "DEFAULT_MAX_SIZE"]
@@ -0,0 +1,47 @@
+# Copyright 2026 The casbin Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import ABC, abstractmethod
+
+
+class Cache(ABC):
+    """the interface a cache backend has to implement to be usable by CachedEnforcer.
+
+    A miss is reported by returning the ``default`` object handed to ``get``, never by
+    raising. The enforcer passes a private sentinel as ``default``, so an implementation
+    that returns it verbatim on a miss can cache ``False`` and ``None`` values safely.
+
+    Implementations are expected to be safe to call from several threads at once, since
+    a single enforcer may be shared between them.
+    """
+
+    @abstractmethod
+    def get(self, key, default=None):
+        """returns the value stored under key, or default if key is absent or expired."""
+
+    @abstractmethod
+    def set(self, key, value, ttl=None):
+        """stores value under key.
+
+        ttl is the number of seconds the entry stays valid; None means it never expires
+        on its own.
+        """
+
+    @abstractmethod
+    def delete(self, key):
+        """drops a single key, if present."""
+
+    @abstractmethod
+    def clear(self):
+        """drops every entry."""
@@ -0,0 +1,77 @@
+# Copyright 2026 The casbin Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import threading
+import time
+from collections import OrderedDict
+
+from .cache import Cache
+
+DEFAULT_MAX_SIZE = 10000
+
+
+class DefaultCache(Cache):
+    """an in-memory cache with LRU eviction and optional per-entry expiry.
+
+    The size bound matters here: cache keys are built from request values such as user
+    names, so an unbounded cache in front of enforce() grows with the number of distinct
+    users an application has ever seen. Once max_size entries are stored, the least
+    recently used one is evicted.
+
+    All operations hold a lock, so the cache can back an enforcer shared between threads.
+    """
+
+    def __init__(self, max_size=DEFAULT_MAX_SIZE):
+        if max_size is not None and max_size <= 0:
+            raise ValueError("max_size must be a positive integer or None for no bound")
+        self.max_size = max_size
+        self._lock = threading.Lock()
+        self._store = OrderedDict()
+
+    def get(self, key, default=None):
+        with self._lock:
+            entry = self._store.get(key)
+            if entry is None:
+                return default
+
+            value, expires_at = entry
+            if expires_at is not None and time.monotonic() >= expires_at:
+                # only this thread can reach the delete: the lookup and the delete happen
+                # under the same lock acquisition.
+                del self._store[key]
+                return default
+
+            self._store.move_to_end(key)
+            return value
+
+    def set(self, key, value, ttl=None):
+        expires_at = time.monotonic() + ttl if ttl is not None and ttl > 0 else None
+        with self._lock:
+            self._store[key] = (value, expires_at)
+            self._store.move_to_end(key)
+            if self.max_size is not None:
+                while len(self._store) > self.max_size:
+                    self._store.popitem(last=False)
+
+    def delete(self, key):
+        with self._lock:
+            self._store.pop(key, None)
+
+    def clear(self):
+        with self._lock:
+            self._store.clear()
+
+    def __len__(self):
+        with self._lock:
+            return len(self._store)