diff --git a/BitFaster.Caching.UnitTests/Lru/ConcurrentLruBuilderTests.cs b/BitFaster.Caching.UnitTests/Lru/ConcurrentLruBuilderTests.cs
index 48d6eeb2..7d0a651c 100644
--- a/BitFaster.Caching.UnitTests/Lru/ConcurrentLruBuilderTests.cs
+++ b/BitFaster.Caching.UnitTests/Lru/ConcurrentLruBuilderTests.cs
@@ -4,6 +4,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using BitFaster.Caching.Lru;
+using BitFaster.Caching.Synchronized;
 using FluentAssertions;
 using Xunit;
 
@@ -14,7 +15,7 @@ public class ConcurrentLruBuilderTests
         [Fact]
         public void TestFastLru()
         {
-            var lru = new ConcurrentLruBuilder<int, int>()
+            ICache<int, int> lru = new ConcurrentLruBuilder<int, int>()
                 .Build();
 
             lru.Should().BeOfType<FastConcurrentLru<int, int>>();
@@ -23,7 +24,7 @@ public void TestFastLru()
         [Fact]
         public void TestMetricsLru()
         {
-            var lru = new ConcurrentLruBuilder<int, int>()
+            ICache<int, int> lru = new ConcurrentLruBuilder<int, int>()
                 .WithMetrics()
                 .Build();
 
@@ -33,7 +34,7 @@ public void TestMetricsLru()
         [Fact]
         public void TestFastTLru()
         {
-            var lru = new ConcurrentLruBuilder<int, int>()
+            ICache<int, int> lru = new ConcurrentLruBuilder<int, int>()
                 .WithExpireAfterWrite(TimeSpan.FromSeconds(1))
                 .Build();
 
@@ -43,7 +44,7 @@ public void TestFastTLru()
         [Fact]
         public void TestMetricsTLru()
         {
-            var lru = new ConcurrentLruBuilder<int, int>()
+            ICache<int, int> lru = new ConcurrentLruBuilder<int, int>()
                  .WithExpireAfterWrite(TimeSpan.FromSeconds(1))
                  .WithMetrics()
                  .Build();
@@ -53,22 +54,55 @@ public void TestMetricsTLru()
         }
 
         [Fact]
-        public void TestScoped()
+        public void AsAsyncTestFastLru()
         {
-            var lru = new ConcurrentLruBuilder<int, Disposable>()
-                .WithScopedValues()
-                .WithCapacity(3)
-                .WithExpireAfterWrite(TimeSpan.FromMinutes(1))
+            IAsyncCache<int, int> lru = new ConcurrentLruBuilder<int, int>()
+                .AsAsyncCache()
                 .Build();
 
-            lru.Should().BeOfType<ScopedCache<int, Disposable>>();
-            lru.Capacity.Should().Be(3);
+            lru.Should().BeOfType<FastConcurrentLru<int, int>>();
+        }
+
+        [Fact]
+        public void AsAsyncTestMetricsLru()
+        {
+            IAsyncCache<int, int> lru = new ConcurrentLruBuilder<int, int>()
+                .WithMetrics()
+                .AsAsyncCache()
+                .Build();
+
+            lru.Should().BeOfType<ConcurrentLru<int, int>>();
+        }
+
+        [Fact]
+        public void AsAsyncTestFastTLru()
+        {
+            IAsyncCache<int, int> lru = new ConcurrentLruBuilder<int, int>()
+                .WithExpireAfterWrite(TimeSpan.FromSeconds(1))
+                .AsAsyncCache()
+                .Build();
+
+            lru.Should().BeOfType<FastConcurrentTLru<int, int>>();
         }
 
+        [Fact]
+        public void AsAsyncTestMetricsTLru()
+        {
+            IAsyncCache<int, int> lru = new ConcurrentLruBuilder<int, int>()
+                 .WithExpireAfterWrite(TimeSpan.FromSeconds(1))
+                 .WithMetrics()
+                 .AsAsyncCache()
+                 .Build();
+
+            lru.Should().BeOfType<ConcurrentTLru<int, int>>();
+            lru.Capacity.Should().Be(128);
+        }
+
+
         [Fact]
         public void TestComparer()
         {
-            var fastLru = new ConcurrentLruBuilder<string, int>()
+            ICache<string, int> fastLru = new ConcurrentLruBuilder<string, int>()
                 .WithKeyComparer(StringComparer.OrdinalIgnoreCase)
                 .Build();
 
@@ -90,7 +124,7 @@ public void TestConcurrencyLevel()
         [Fact]
         public void TestIntCapacity()
         {
-            var lru = new ConcurrentLruBuilder<int, Disposable>()
+            ICache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
                 .WithCapacity(3)
                 .Build();
 
@@ -100,11 +134,277 @@ public void TestIntCapacity()
         [Fact]
         public void TestPartitionCapacity()
         {
-            var lru = new ConcurrentLruBuilder<int, Disposable>()
+            ICache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
                 .WithCapacity(new FavorFrequencyPartition(6))
                 .Build();
 
             lru.Capacity.Should().Be(6);
         }
+
+        //  There are 15 combinations to test:
+        //  -----------------------------
+        //1 WithAtomic
+        //2 WithScoped
+        //3 AsAsync
+        //
+        //  -----------------------------
+        //4 WithAtomic
+        //  WithScoped
+        //
+        //5 WithScoped
+        //  WithAtomic
+        //
+        //6 AsAsync
+        //  WithScoped
+        //
+        //7 WithScoped
+        //  AsAsync
+        //
+        //8 WithAtomic
+        //  AsAsync
+        //
+        //9 AsAsync
+        //  WithAtomic
+        //
+        //  -----------------------------
+        //10 WithAtomic
+        //   WithScoped
+        //   AsAsync
+        //
+        //11 WithAtomic
+        //   AsAsync
+        //   WithScoped
+        //
+        //12 WithScoped
+        //   WithAtomic
+        //   AsAsync
+        //
+        //13 WithScoped
+        //   AsAsync
+        //   WithAtomic
+        //
+        //14 AsAsync
+        //   WithScoped
+        //   WithAtomic
+        //
+        //15 AsAsync
+        //   WithAtomic
+        //   WithScoped
+
+        // 1
+        [Fact]
+        public void WithScopedValues()
+        {
+            IScopedCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
+                .WithScopedValues()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeOfType<ScopedCache<int, Disposable>>();
+            lru.Capacity.Should().Be(3);
+        }
+
+        // 2
+        [Fact]
+        public void WithAtomicFactory()
+        {
+            ICache<int, int> lru = new ConcurrentLruBuilder<int, int>()
+                .WithAtomicCreate()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeOfType<AtomicFactoryCache<int, int>>();
+        }
+
+        // 3
+        [Fact]
+        public void AsAsync()
+        {
+            IAsyncCache<int, int> lru = new ConcurrentLruBuilder<int, int>()
+                .AsAsyncCache()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeAssignableTo<IAsyncCache<int, int>>();
+        }
+
+        // 4
+        [Fact]
+        public void WithAtomicWithScope()
+        {
+            IScopedCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
+                .WithAtomicCreate()
+                .WithScopedValues()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeOfType<AtomicFactoryScopedCache<int, Disposable>>();
+            lru.Capacity.Should().Be(3);
+        }
+
+        // 5
+        [Fact]
+        public void WithScopedWithAtomic()
+        {
+            IScopedCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
+                .WithScopedValues()
+                .WithAtomicCreate()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeOfType<AtomicFactoryScopedCache<int, Disposable>>();
+            lru.Capacity.Should().Be(3);
+        }
+
+        // 6
+        [Fact]
+        public void AsAsyncWithScoped()
+        {
+            IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
+                .AsAsyncCache()
+                .WithScopedValues()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeAssignableTo<IScopedAsyncCache<int, Disposable>>();
+
+            lru.Capacity.Should().Be(3);
+        }
+
+        // 7
+        [Fact]
+        public void WithScopedAsAsync()
+        {
+            IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
+                .WithScopedValues()
+                .AsAsyncCache()           
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeAssignableTo<IScopedAsyncCache<int, Disposable>>();
+            lru.Capacity.Should().Be(3);
+        }
+
+        // 8
+        [Fact]
+        public void WithAtomicAsAsync()
+        {
+            IAsyncCache<int, int> lru = new ConcurrentLruBuilder<int, int>()
+                .WithAtomicCreate()
+                .AsAsyncCache()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeAssignableTo<IAsyncCache<int, int>>();
+        }
+
+        // 9
+        [Fact]
+        public void AsAsyncWithAtomic()
+        {
+            IAsyncCache<int, int> lru = new ConcurrentLruBuilder<int, int>()
+                .AsAsyncCache()
+                .WithAtomicCreate()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeAssignableTo<IAsyncCache<int, int>>();
+        }
+
+        // 10
+        [Fact]
+        public void WithAtomicWithScopedAsAsync()
+        {
+            // TODO: this will not resolve a TLru
+
+            IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
+                .WithAtomicCreate()
+                .WithScopedValues()
+                .AsAsyncCache()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeAssignableTo<IScopedAsyncCache<int, Disposable>>();
+        }
+
+        // 11
+        [Fact]
+        public void WithAtomicAsAsyncWithScoped()
+        {
+            // TODO: this will not resolve a TLru
+
+            IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
+                .WithAtomicCreate()
+                .AsAsyncCache()
+                .WithScopedValues()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeAssignableTo<IScopedAsyncCache<int, Disposable>>();
+        }
+
+        // 12
+        [Fact]
+        public void WithScopedWithAtomicAsAsync()
+        {
+            // TODO: this will not resolve a TLru
+
+            IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
+                .WithScopedValues()
+                .WithAtomicCreate()
+                .AsAsyncCache()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeAssignableTo<IScopedAsyncCache<int, Disposable>>();
+        }
+
+        // 13
+        [Fact]
+        public void WithScopedAsAsyncWithAtomic()
+        {
+            // TODO: this will not resolve a TLru
+
+            IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
+                .WithScopedValues()
+                .AsAsyncCache()
+                .WithAtomicCreate()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeAssignableTo<IScopedAsyncCache<int, Disposable>>();
+        }
+
+        // 14
+        [Fact]
+        public void AsAsyncWithScopedWithAtomic()
+        {
+            // TODO: this will not resolve a TLru
+
+            IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
+                .AsAsyncCache()
+                .WithScopedValues()
+                .WithAtomicCreate()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeAssignableTo<IScopedAsyncCache<int, Disposable>>();
+        }
+
+        // 15
+        [Fact]
+        public void AsAsyncWithAtomicWithScoped()
+        {
+            // TODO: this will not resolve a TLru
+
+            IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
+                .AsAsyncCache()
+                .WithAtomicCreate()
+                .WithScopedValues()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Should().BeAssignableTo<IScopedAsyncCache<int, Disposable>>();
+        }
     }
 }
diff --git a/BitFaster.Caching.UnitTests/ScopedAsyncCacheTestBase.cs b/BitFaster.Caching.UnitTests/ScopedAsyncCacheTestBase.cs
new file mode 100644
index 00000000..556701c1
--- /dev/null
+++ b/BitFaster.Caching.UnitTests/ScopedAsyncCacheTestBase.cs
@@ -0,0 +1,178 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BitFaster.Caching.Lru;
+using FluentAssertions;
+using Xunit;
+
+namespace BitFaster.Caching.UnitTests
+{
+    public abstract class ScopedAsyncCacheTestBase
+    {
+        protected const int capacity = 6;
+        protected readonly IScopedAsyncCache<int, Disposable> cache;
+
+        protected List<ItemRemovedEventArgs<int, Scoped<Disposable>>> removedItems = new();
+
+        protected ScopedAsyncCacheTestBase(IScopedAsyncCache<int, Disposable> cache)
+        {
+            this.cache = cache;
+        }
+
+        [Fact]
+        public void WhenCreatedCapacityPropertyWrapsInnerCache()
+        {
+            this.cache.Capacity.Should().Be(capacity);
+        }
+
+        [Fact]
+        public void WhenItemIsAddedCountIsCorrect()
+        {
+            this.cache.Count.Should().Be(0);
+
+            this.cache.AddOrUpdate(1, new Disposable());
+
+            this.cache.Count.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenItemIsAddedThenLookedUpMetricsAreCorrect()
+        {
+            this.cache.AddOrUpdate(1, new Disposable());
+            this.cache.ScopedTryGet(1, out var lifetime);
+
+            this.cache.Metrics.Misses.Should().Be(0);
+            this.cache.Metrics.Hits.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenEventHandlerIsRegisteredItIsFired()
+        {
+            this.cache.Events.ItemRemoved += OnItemRemoved;
+
+            this.cache.AddOrUpdate(1, new Disposable());
+            this.cache.TryRemove(1);
+
+            this.removedItems.First().Key.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistAddOrUpdateAddsNewItem()
+        {
+            var d = new Disposable();
+            this.cache.AddOrUpdate(1, d);
+
+            this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
+            lifetime.Value.Should().Be(d);
+        }
+
+        [Fact]
+        public void WhenKeyExistsAddOrUpdateUpdatesExistingItem()
+        {
+            var d1 = new Disposable();
+            var d2 = new Disposable();
+            this.cache.AddOrUpdate(1, d1);
+            this.cache.AddOrUpdate(1, d2);
+
+            this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
+            lifetime.Value.Should().Be(d2);
+        }
+
+        [Fact]
+        public void WhenItemUpdatedOldValueIsAliveUntilLifetimeCompletes()
+        {
+            var d1 = new Disposable();
+            var d2 = new Disposable();
+
+            // start a lifetime on 1
+            this.cache.AddOrUpdate(1, d1);
+            this.cache.ScopedTryGet(1, out var lifetime1).Should().BeTrue();
+
+            using (lifetime1)
+            {
+                // replace 1
+                this.cache.AddOrUpdate(1, d2);
+
+                // cache reflects replacement
+                this.cache.ScopedTryGet(1, out var lifetime2).Should().BeTrue();
+                lifetime2.Value.Should().Be(d2);
+
+                d1.IsDisposed.Should().BeFalse();
+            }
+
+            d1.IsDisposed.Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenClearedItemsAreDisposed()
+        {
+            var d = new Disposable();
+            this.cache.AddOrUpdate(1, d);
+
+            this.cache.Clear();
+
+            d.IsDisposed.Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenItemExistsTryGetReturnsLifetime()
+        {
+            this.cache.AddOrUpdate(1, new Disposable());
+            this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
+
+            lifetime.Should().NotBeNull();
+        }
+
+        [Fact]
+        public void WhenItemDoesNotExistTryGetReturnsFalse()
+        {
+            this.cache.ScopedTryGet(1, out var lifetime).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenCacheContainsValuesTrim1RemovesColdestValue()
+        {
+            this.cache.AddOrUpdate(0, new Disposable());
+            this.cache.AddOrUpdate(1, new Disposable());
+            this.cache.AddOrUpdate(2, new Disposable());
+
+            this.cache.Trim(1);
+
+            this.cache.ScopedTryGet(0, out var lifetime).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistTryRemoveReturnsFalse()
+        {
+            this.cache.TryRemove(1).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyExistsTryRemoveReturnsTrue()
+        {
+            this.cache.AddOrUpdate(1, new Disposable());
+            this.cache.TryRemove(1).Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistTryUpdateReturnsFalse()
+        {
+            this.cache.TryUpdate(1, new Disposable()).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyExistsTryUpdateReturnsTrue()
+        {
+            this.cache.AddOrUpdate(1, new Disposable());
+
+            this.cache.TryUpdate(1, new Disposable()).Should().BeTrue();
+        }
+
+        protected void OnItemRemoved(object sender, ItemRemovedEventArgs<int, Scoped<Disposable>> e)
+        {
+            this.removedItems.Add(e);
+        }
+    }
+}
diff --git a/BitFaster.Caching.UnitTests/ScopedAsyncCacheTests.cs b/BitFaster.Caching.UnitTests/ScopedAsyncCacheTests.cs
new file mode 100644
index 00000000..1908eedd
--- /dev/null
+++ b/BitFaster.Caching.UnitTests/ScopedAsyncCacheTests.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BitFaster.Caching.Lru;
+using FluentAssertions;
+using Xunit;
+
+namespace BitFaster.Caching.UnitTests
+{
+    public class ScopedAsyncCacheTests : ScopedAsyncCacheTestBase
+    {
+        public ScopedAsyncCacheTests() 
+            : base(new ScopedAsyncCache<int, Disposable>(new ConcurrentLru<int, Scoped<Disposable>>(capacity)))
+        {
+        }
+
+        [Fact]
+        public void WhenInnerCacheIsNullCtorThrows()
+        {
+            Action constructor = () => { var x = new ScopedAsyncCache<int, Disposable>(null); };
+
+            constructor.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public async Task WhenScopeIsDisposedTryGetReturnsFalse()
+        {
+            var scope = new Scoped<Disposable>(new Disposable());
+
+            await this.cache.ScopedGetOrAddAsync(1, k => Task.FromResult(scope));
+
+            scope.Dispose();
+
+            this.cache.ScopedTryGet(1, out var lifetime).Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task WhenKeyDoesNotExistGetOrAddAsyncAddsValue()
+        {
+            await this.cache.ScopedGetOrAddAsync(1, k => Task.FromResult(new Scoped<Disposable>(new Disposable())));
+
+            this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task GetOrAddAsyncDisposedScopeThrows()
+        {
+            var scope = new Scoped<Disposable>(new Disposable());
+            scope.Dispose();
+
+            Func<Task> getOrAdd = async () => { await this.cache.ScopedGetOrAddAsync(1, k => Task.FromResult(scope)); };
+
+            await getOrAdd.Should().ThrowAsync<InvalidOperationException>();
+        }
+    }
+}
diff --git a/BitFaster.Caching.UnitTests/ScopedCacheTests.cs b/BitFaster.Caching.UnitTests/ScopedCacheTests.cs
index 0adf2c6a..2345b48f 100644
--- a/BitFaster.Caching.UnitTests/ScopedCacheTests.cs
+++ b/BitFaster.Caching.UnitTests/ScopedCacheTests.cs
@@ -44,14 +44,6 @@ public void WhenKeyDoesNotExistGetOrAddAddsValue()
             this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
         }
 
-        [Fact]
-        public async Task WhenKeyDoesNotExistGetOrAddAsyncAddsValue()
-        {
-            await this.cache.ScopedGetOrAddAsync(1, k => Task.FromResult(new Scoped<Disposable>(new Disposable())));
-
-            this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
-        }
-
         [Fact]
         public void GetOrAddDisposedScopeThrows()
         {
@@ -62,16 +54,5 @@ public void GetOrAddDisposedScopeThrows()
 
             getOrAdd.Should().Throw<InvalidOperationException>();
         }
-
-        [Fact]
-        public async Task GetOrAddAsyncDisposedScopeThrows()
-        {
-            var scope = new Scoped<Disposable>(new Disposable());
-            scope.Dispose();
-
-            Func<Task> getOrAdd = async () => { await this.cache.ScopedGetOrAddAsync(1, k => Task.FromResult(scope)); };
-
-            await getOrAdd.Should().ThrowAsync<InvalidOperationException>();
-        }
     }
 }
diff --git a/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryAsyncCacheTests.cs b/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryAsyncCacheTests.cs
index e1f132a9..c4793d1b 100644
--- a/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryAsyncCacheTests.cs
+++ b/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryAsyncCacheTests.cs
@@ -97,14 +97,6 @@ public void WhenItemDoesNotExistTryGetReturnsFalse()
             this.cache.TryGet(1, out var value).Should().BeFalse();
         }
 
-        [Fact]
-        public void GetOrAddThrows()
-        {
-            Action getOrAdd = () => { this.cache.GetOrAdd(1, k => k); };
-
-            getOrAdd.Should().Throw<NotImplementedException>();
-        }
-
         [Fact]
         public async Task WhenKeyDoesNotExistGetOrAddAsyncAddsValue()
         {
diff --git a/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryScopedAsyncCacheTests.cs b/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryScopedAsyncCacheTests.cs
index 8818d11e..0f28af16 100644
--- a/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryScopedAsyncCacheTests.cs
+++ b/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryScopedAsyncCacheTests.cs
@@ -10,8 +10,10 @@
 
 namespace BitFaster.Caching.UnitTests.Synchronized
 {
-    public class AtomicFactoryScopedAsyncCacheTests : ScopedCacheTestBase
+    public class AtomicFactoryScopedAsyncCacheTests : ScopedAsyncCacheTestBase
     {
+
+
         public AtomicFactoryScopedAsyncCacheTests()
             : base(new AtomicFactoryScopedAsyncCache<int, Disposable>(new ConcurrentLru<int, ScopedAsyncAtomicFactory<int, Disposable>>(capacity)))
         {
@@ -37,14 +39,6 @@ public async Task WhenScopeIsDisposedTryGetReturnsFalse()
             this.cache.ScopedTryGet(1, out var lifetime).Should().BeFalse();
         }
 
-        [Fact]
-        public void WhenKeyDoesNotExistGetOrAddThrows()
-        {
-            Action getOrAdd = () => { this.cache.ScopedGetOrAdd(1, k => new Scoped<Disposable>(new Disposable())); };
-
-            getOrAdd.Should().Throw<NotImplementedException>();
-        }
-
         [Fact]
         public async Task WhenKeyDoesNotExistGetOrAddAsyncAddsValue()
         {
diff --git a/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryScopedCacheTests.cs b/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryScopedCacheTests.cs
index e0927bdc..f56d5896 100644
--- a/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryScopedCacheTests.cs
+++ b/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryScopedCacheTests.cs
@@ -45,14 +45,6 @@ public void WhenKeyDoesNotExistGetOrAddAddsValue()
             this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
         }
 
-        [Fact]
-        public async Task WhenKeyDoesNotExistGetOrAddAsyncThrows()
-        {
-            Func<Task> getOrAdd = async () => { await this.cache.ScopedGetOrAddAsync(1, k => Task.FromResult(new Scoped<Disposable>(new Disposable()))); };
-
-            await getOrAdd.Should().ThrowAsync<NotImplementedException>();
-        }
-
         [Fact]
         public void GetOrAddDisposedScopeThrows()
         {
@@ -63,16 +55,5 @@ public void GetOrAddDisposedScopeThrows()
 
             getOrAdd.Should().Throw<InvalidOperationException>();
         }
-
-        [Fact]
-        public void GetOrAddAsyncDisposedScopeThrows()
-        {
-            var scope = new Scoped<Disposable>(new Disposable());
-            scope.Dispose();
-
-            Func<Task> getOrAdd = async () => { await this.cache.ScopedGetOrAddAsync(1, k => Task.FromResult(scope)); };
-
-            getOrAdd.Should().ThrowAsync<InvalidOperationException>();
-        }
     }
 }
diff --git a/BitFaster.Caching/IAsyncCache.cs b/BitFaster.Caching/IAsyncCache.cs
new file mode 100644
index 00000000..7e547cb1
--- /dev/null
+++ b/BitFaster.Caching/IAsyncCache.cs
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching
+{
+    /// <summary>
+    /// Represents a generic cache of key/value pairs.
+    /// </summary>
+    /// <typeparam name="K">The type of keys in the cache.</typeparam>
+    /// <typeparam name="V">The type of values in the cache.</typeparam>
+    public interface IAsyncCache<K, V>
+    {
+        /// <summary>
+        /// Gets the total number of items that can be stored in the cache.
+        /// </summary>
+        int Capacity { get; }
+
+        /// <summary>
+        /// Gets the number of items currently held in the cache.
+        /// </summary>
+        int Count { get; }
+
+        /// <summary>
+        /// Gets the cache metrics.
+        /// </summary>
+        ICacheMetrics Metrics { get; }
+
+        /// <summary>
+        /// Gets the cache events.
+        /// </summary>
+        ICacheEvents<K, V> Events { get; }
+
+        /// <summary>
+        /// Attempts to get the value associated with the specified key from the cache.
+        /// </summary>
+        /// <param name="key">The key of the value to get.</param>
+        /// <param name="value">When this method returns, contains the object from the cache that has the specified key, or the default value of the type if the operation failed.</param>
+        /// <returns>true if the key was found in the cache; otherwise, false.</returns>
+        bool TryGet(K key, out V value);
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
+        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
+        Task<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory);
+
+        /// <summary>
+        /// Attempts to remove the value that has the specified key.
+        /// </summary>
+        /// <param name="key">The key of the element to remove.</param>
+        /// <returns>true if the object was removed successfully; otherwise, false.</returns>
+        bool TryRemove(K key);
+
+        /// <summary>
+        /// Attempts to update the value that has the specified key.
+        /// </summary>
+        /// <param name="key">The key of the element to update.</param>
+        /// <param name="value">The new value.</param>
+        /// <returns>true if the object was updated successfully; otherwise, false.</returns>
+        bool TryUpdate(K key, V value);
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist, or updates a key/value pair if the 
+        /// key already exists.
+        /// </summary>
+        /// <param name="key">The key of the element to update.</param>
+        /// <param name="value">The new value.</param>
+        void AddOrUpdate(K key, V value);
+
+        /// <summary>
+        /// Removes all keys and values from the cache.
+        /// </summary>
+        void Clear();
+
+        /// <summary>
+        /// Trim the specified number of items from the cache.
+        /// </summary>
+        /// <param name="itemCount">The number of items to remove.</param>
+        void Trim(int itemCount);
+    }
+}
diff --git a/BitFaster.Caching/ICache.cs b/BitFaster.Caching/ICache.cs
index 8200bafe..dbb9e892 100644
--- a/BitFaster.Caching/ICache.cs
+++ b/BitFaster.Caching/ICache.cs
@@ -51,15 +51,6 @@ public interface ICache<K, V>
         /// in the cache, or the new value if the key was not in the cache.</returns>
         V GetOrAdd(K key, Func<K, V> valueFactory);
 
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
-        /// existing value if the key already exists.
-        /// </summary>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
-        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
-        Task<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory);
-
         /// <summary>
         /// Attempts to remove the value that has the specified key.
         /// </summary>
diff --git a/BitFaster.Caching/IScopedAsyncCache.cs b/BitFaster.Caching/IScopedAsyncCache.cs
new file mode 100644
index 00000000..4906d441
--- /dev/null
+++ b/BitFaster.Caching/IScopedAsyncCache.cs
@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching
+{
+    /// <summary>
+    /// Represents a generic cache of key/scoped IDisposable value pairs.
+    /// </summary>
+    /// <typeparam name="K">The type of keys in the cache.</typeparam>
+    /// <typeparam name="V">The type of values in the cache.</typeparam>
+    public interface IScopedAsyncCache<K, V> where V : IDisposable
+    {
+        /// <summary>
+        /// Gets the total number of items that can be stored in the cache.
+        /// </summary>
+        int Capacity { get; }
+
+        /// <summary>
+        /// Gets the number of items currently held in the cache.
+        /// </summary>
+        int Count { get; }
+
+        /// <summary>
+        /// Gets the cache metrics.
+        /// </summary>
+        ICacheMetrics Metrics { get; }
+
+        /// <summary>
+        /// Gets the cache events.
+        /// </summary>
+        /// <remarks>
+        /// Events expose the Scoped instance wrapping each value. To keep the value alive (blocking Dispose), try to 
+        /// create a Lifetime from the scope.
+        /// </remarks>
+        ICacheEvents<K, Scoped<V>> Events { get; }
+
+        /// <summary>
+        /// Attempts to create a lifetime for the value associated with the specified key from the cache
+        /// </summary>
+        /// <param name="key">The key of the value to get.</param>
+        /// <param name="lifetime">When this method returns, contains a lifetime for the object from the cache that 
+        /// has the specified key, or the default value of the type if the operation failed.</param>
+        /// <returns>true if the key was found in the cache; otherwise, false.</returns>
+        bool ScopedTryGet(K key, out Lifetime<V> lifetime);
+
+        /// <summary>
+        /// Adds a key/scoped value pair to the cache if the key does not already exist. Returns a lifetime for either 
+        /// the new value, or the existing value if the key already exists.
+        /// </summary>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to asynchronously generate a scoped value for the key.</param>
+        /// <returns>A task that represents the asynchronous ScopedGetOrAdd operation.</returns>
+        Task<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory);
+
+        /// <summary>
+        /// Attempts to remove the value that has the specified key.
+        /// </summary>
+        /// <param name="key">The key of the element to remove.</param>
+        /// <returns>true if the object was removed successfully; otherwise, false.</returns>
+        bool TryRemove(K key);
+
+        /// <summary>
+        /// Attempts to update the value that has the specified key.
+        /// </summary>
+        /// <param name="key">The key of the element to update.</param>
+        /// <param name="value">The new value.</param>
+        /// <returns>true if the object was updated successfully; otherwise, false.</returns>
+        bool TryUpdate(K key, V value);
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist, or updates a key/value pair if the 
+        /// key already exists.
+        /// </summary>
+        /// <param name="key">The key of the element to update.</param>
+        /// <param name="value">The new value.</param>
+        void AddOrUpdate(K key, V value);
+
+        /// <summary>
+        /// Removes all keys and values from the cache.
+        /// </summary>
+        void Clear();
+
+        /// <summary>
+        /// Trim the specified number of items from the cache.
+        /// </summary>
+        /// <param name="itemCount">The number of items to remove.</param>
+        void Trim(int itemCount);
+    }
+}
diff --git a/BitFaster.Caching/IScopedCache.cs b/BitFaster.Caching/IScopedCache.cs
index 4eca0f1f..e06f11c1 100644
--- a/BitFaster.Caching/IScopedCache.cs
+++ b/BitFaster.Caching/IScopedCache.cs
@@ -57,15 +57,6 @@ public interface IScopedCache<K, V> where V : IDisposable
         /// the cache.</returns>
         Lifetime<V> ScopedGetOrAdd(K key, Func<K, Scoped<V>> valueFactory);
 
-        /// <summary>
-        /// Adds a key/scoped value pair to the cache if the key does not already exist. Returns a lifetime for either 
-        /// the new value, or the existing value if the key already exists.
-        /// </summary>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The factory function used to asynchronously generate a scoped value for the key.</param>
-        /// <returns>A task that represents the asynchronous ScopedGetOrAdd operation.</returns>
-        Task<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory);
-
         /// <summary>
         /// Attempts to remove the value that has the specified key.
         /// </summary>
diff --git a/BitFaster.Caching/Lru/Builder/AsyncAtomicLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AsyncAtomicLruBuilder.cs
new file mode 100644
index 00000000..f92c26c6
--- /dev/null
+++ b/BitFaster.Caching/Lru/Builder/AsyncAtomicLruBuilder.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BitFaster.Caching.Synchronized;
+
+namespace BitFaster.Caching.Lru.Builder
+{
+    public class AsyncAtomicLruBuilder<K, V> : LruBuilderBase<K, V, AsyncAtomicLruBuilder<K, V>, IAsyncCache<K, V>>
+    {
+        private readonly ConcurrentLruBuilder<K, AsyncAtomicFactory<K, V>> inner;
+
+        internal AsyncAtomicLruBuilder(ConcurrentLruBuilder<K, AsyncAtomicFactory<K, V>> inner)
+            : base(inner.info)
+        {
+            this.inner = inner;
+        }
+
+        public override IAsyncCache<K, V> Build()
+        {
+            var level1 = inner.Build();
+            return new AtomicFactoryAsyncCache<K, V>(level1);
+        }
+    }
+}
diff --git a/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs
new file mode 100644
index 00000000..c47223f9
--- /dev/null
+++ b/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching.Lru.Builder
+{
+    public sealed class AsyncConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, AsyncConcurrentLruBuilder<K, V>, IAsyncCache<K, V>>
+    {
+        internal AsyncConcurrentLruBuilder(LruInfo<K> info)
+            : base(info)
+        {
+        }
+
+        ///<inheritdoc/>
+        public override IAsyncCache<K, V> Build()
+        {
+            switch (info)
+            {
+                case LruInfo<K> i when i.WithMetrics && !i.TimeToExpireAfterWrite.HasValue:
+                    return new ConcurrentLru<K, V>(info.ConcurrencyLevel, info.Capacity, info.KeyComparer);
+                case LruInfo<K> i when i.WithMetrics && i.TimeToExpireAfterWrite.HasValue:
+                    return new ConcurrentTLru<K, V>(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value);
+                case LruInfo<K> i when i.TimeToExpireAfterWrite.HasValue:
+                    return new FastConcurrentTLru<K, V>(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value);
+                default:
+                    return new FastConcurrentLru<K, V>(info.ConcurrencyLevel, info.Capacity, info.KeyComparer);
+            }
+        }
+    }
+}
diff --git a/BitFaster.Caching/Lru/Builder/AtomicLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AtomicLruBuilder.cs
new file mode 100644
index 00000000..cc1940b5
--- /dev/null
+++ b/BitFaster.Caching/Lru/Builder/AtomicLruBuilder.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BitFaster.Caching.Synchronized;
+
+namespace BitFaster.Caching.Lru.Builder
+{
+    public class AtomicLruBuilder<K, V> : LruBuilderBase<K, V, AtomicLruBuilder<K, V>, ICache<K, V>>
+    {
+        private readonly ConcurrentLruBuilder<K, AtomicFactory<K, V>> inner;
+
+        internal AtomicLruBuilder(ConcurrentLruBuilder<K, AtomicFactory<K, V>> inner)
+            : base(inner.info)
+        {
+            this.inner = inner;
+        }
+
+        public override ICache<K, V> Build()
+        {
+            var level1 = inner.Build();
+            return new AtomicFactoryCache<K, V>(level1);
+        }
+    }
+}
diff --git a/BitFaster.Caching/Lru/Builder/ScopedAsyncAtomicLruBuilder.cs b/BitFaster.Caching/Lru/Builder/ScopedAsyncAtomicLruBuilder.cs
new file mode 100644
index 00000000..8553f91f
--- /dev/null
+++ b/BitFaster.Caching/Lru/Builder/ScopedAsyncAtomicLruBuilder.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BitFaster.Caching.Synchronized;
+
+namespace BitFaster.Caching.Lru.Builder
+{
+    public sealed class ScopedAsyncAtomicLruBuilder<K, V> : LruBuilderBase<K, V, ScopedAsyncAtomicLruBuilder<K, V>, IScopedAsyncCache<K, V>> where V : IDisposable
+    {
+        private readonly AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>> inner;
+
+        internal ScopedAsyncAtomicLruBuilder(AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>> inner)
+            : base(inner.info)
+        {
+            this.inner = inner;
+        }
+
+        ///<inheritdoc/>
+        public override IScopedAsyncCache<K, V> Build()
+        {
+            // this is a legal type conversion due to the generic constraint on W
+            var scopedInnerCache = inner.Build() as ICache<K, ScopedAsyncAtomicFactory<K, V>>;
+
+            return new AtomicFactoryScopedAsyncCache<K, V>(scopedInnerCache);
+        }
+    }
+}
diff --git a/BitFaster.Caching/Lru/Builder/ScopedAsyncLruBuilder.cs b/BitFaster.Caching/Lru/Builder/ScopedAsyncLruBuilder.cs
new file mode 100644
index 00000000..2b280728
--- /dev/null
+++ b/BitFaster.Caching/Lru/Builder/ScopedAsyncLruBuilder.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching.Lru.Builder
+{
+    public sealed class ScopedAsyncLruBuilder<K, V> : LruBuilderBase<K, V, ScopedAsyncLruBuilder<K, V>, IScopedAsyncCache<K, V>> where V : IDisposable
+    {
+        private readonly AsyncConcurrentLruBuilder<K, Scoped<V>> inner;
+
+        internal ScopedAsyncLruBuilder(AsyncConcurrentLruBuilder<K, Scoped<V>> inner)
+            : base(inner.info)
+        {
+            this.inner = inner;
+        }
+
+        ///<inheritdoc/>
+        public override IScopedAsyncCache<K, V> Build()
+        {
+            // this is a legal type conversion due to the generic constraint on W
+            var scopedInnerCache = inner.Build() as IAsyncCache<K, Scoped<V>>;
+
+            return new ScopedAsyncCache<K, V>(scopedInnerCache);
+        }
+    }
+}
diff --git a/BitFaster.Caching/Lru/Builder/ScopedAtomicLruBuilder.cs b/BitFaster.Caching/Lru/Builder/ScopedAtomicLruBuilder.cs
new file mode 100644
index 00000000..25b15daf
--- /dev/null
+++ b/BitFaster.Caching/Lru/Builder/ScopedAtomicLruBuilder.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BitFaster.Caching.Synchronized;
+
+namespace BitFaster.Caching.Lru.Builder
+{
+    public class ScopedAtomicLruBuilder<K, V> : LruBuilderBase<K, V, ScopedAtomicLruBuilder<K, V>, IScopedCache<K, V>> where V : IDisposable
+    {
+        private readonly ConcurrentLruBuilder<K, ScopedAtomicFactory<K, V>> inner;
+
+        internal ScopedAtomicLruBuilder(ConcurrentLruBuilder<K, ScopedAtomicFactory<K, V>> inner)
+            : base(inner.info)
+        {
+            this.inner = inner;
+        }
+
+        public override IScopedCache<K, V> Build()
+        {
+            var level1 = inner.Build() as ICache<K, ScopedAtomicFactory<K, V>>;
+            return new AtomicFactoryScopedCache<K, V>(level1);
+        }
+    }
+}
diff --git a/BitFaster.Caching/Lru/Builder/ScopedLruBuilder.cs b/BitFaster.Caching/Lru/Builder/ScopedLruBuilder.cs
index e445de71..8007103a 100644
--- a/BitFaster.Caching/Lru/Builder/ScopedLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/ScopedLruBuilder.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using BitFaster.Caching.Synchronized;
 
 namespace BitFaster.Caching.Lru.Builder
 {
diff --git a/BitFaster.Caching/Lru/ClassicLru.cs b/BitFaster.Caching/Lru/ClassicLru.cs
index 26fd3eb2..b787d37b 100644
--- a/BitFaster.Caching/Lru/ClassicLru.cs
+++ b/BitFaster.Caching/Lru/ClassicLru.cs
@@ -18,7 +18,7 @@ namespace BitFaster.Caching.Lru
     /// </remarks>
     /// <typeparam name="K">The type of the key</typeparam>
     /// <typeparam name="V">The type of the value</typeparam>
-    public sealed class ClassicLru<K, V> : ICache<K, V>, IEnumerable<KeyValuePair<K, V>>
+    public sealed class ClassicLru<K, V> : ICache<K, V>, IAsyncCache<K, V>, IEnumerable<KeyValuePair<K, V>>
     {
         private readonly int capacity;
         private readonly ConcurrentDictionary<K, LinkedListNode<LruItem>> dictionary;
diff --git a/BitFaster.Caching/Lru/ConcurrentLruBuilderExtensions.cs b/BitFaster.Caching/Lru/ConcurrentLruBuilderExtensions.cs
index 0e3dd1c8..8805d849 100644
--- a/BitFaster.Caching/Lru/ConcurrentLruBuilderExtensions.cs
+++ b/BitFaster.Caching/Lru/ConcurrentLruBuilderExtensions.cs
@@ -4,6 +4,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using BitFaster.Caching.Lru.Builder;
+using BitFaster.Caching.Synchronized;
 
 namespace BitFaster.Caching.Lru
 {
@@ -22,5 +23,71 @@ public static ScopedLruBuilder<K, V, Scoped<V>> WithScopedValues<K, V>(this Conc
             var scoped = new ConcurrentLruBuilder<K, Scoped<V>>(builder.info);
             return new ScopedLruBuilder<K, V, Scoped<V>>(scoped);
         }
+
+        public static AtomicLruBuilder<K, V> WithAtomicCreate<K, V>(this ConcurrentLruBuilder<K, V> b)
+        {
+            var a = new ConcurrentLruBuilder<K, AtomicFactory<K, V>>(b.info);
+            return new AtomicLruBuilder<K, V>(a);
+        }
+
+        public static ScopedAtomicLruBuilder<K, V> WithAtomicCreate<K, V, W>(this ScopedLruBuilder<K, V, W> b) where V : IDisposable where W : IScoped<V>
+        {
+            var atomicScoped = new ConcurrentLruBuilder<K, ScopedAtomicFactory<K, V>>(b.info);
+
+            return new ScopedAtomicLruBuilder<K, V>(atomicScoped);
+        }
+
+        public static ScopedAtomicLruBuilder<K, V> WithScopedValues<K, V>(this AtomicLruBuilder<K, V> b) where V : IDisposable
+        {
+            var atomicScoped = new ConcurrentLruBuilder<K, ScopedAtomicFactory<K, V>>(b.info);
+            return new ScopedAtomicLruBuilder<K, V>(atomicScoped);
+        }
+
+        public static AsyncConcurrentLruBuilder<K, V> AsAsyncCache<K, V>(this ConcurrentLruBuilder<K, V> builder)
+        {
+            return new AsyncConcurrentLruBuilder<K, V>(builder.info);
+        }
+
+        public static ScopedAsyncLruBuilder<K, V> WithScopedValues<K, V>(this AsyncConcurrentLruBuilder<K, V> b) where V : IDisposable
+        {
+            var asyncScoped = new AsyncConcurrentLruBuilder<K, Scoped<V>>(b.info);
+            return new ScopedAsyncLruBuilder<K, V>(asyncScoped);
+        }
+
+        public static ScopedAsyncLruBuilder<K, V> AsAsyncCache<K, V>(this ScopedLruBuilder<K, V, Scoped<V>> b) where V : IDisposable
+        {
+            var asyncScoped = new AsyncConcurrentLruBuilder<K, Scoped<V>>(b.info);
+            return new ScopedAsyncLruBuilder<K, V>(asyncScoped);
+        }
+
+        public static AsyncAtomicLruBuilder<K, V> AsAsyncCache<K, V>(this AtomicLruBuilder<K, V> b)
+        {
+            var a = new ConcurrentLruBuilder<K, AsyncAtomicFactory<K, V>>(b.info);
+            return new AsyncAtomicLruBuilder<K, V>(a);
+        }
+
+        public static AsyncAtomicLruBuilder<K, V> WithAtomicCreate<K, V>(this AsyncConcurrentLruBuilder<K, V> b)
+        {
+            var a = new ConcurrentLruBuilder<K, AsyncAtomicFactory<K, V>>(b.info);
+            return new AsyncAtomicLruBuilder<K, V>(a);
+        }
+
+        public static ScopedAsyncAtomicLruBuilder<K, V> AsAsyncCache<K, V>(this ScopedAtomicLruBuilder<K, V> b) where V : IDisposable
+        {
+            var a = new AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>>(b.info);
+            return new ScopedAsyncAtomicLruBuilder<K, V>(a);
+        }
+
+        public static ScopedAsyncAtomicLruBuilder<K, V> WithScopedValues<K, V>(this AsyncAtomicLruBuilder<K, V> b) where V : IDisposable
+        {
+            var a = new AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>>(b.info);
+            return new ScopedAsyncAtomicLruBuilder<K, V>(a);
+        }
+
+        public static ScopedAsyncAtomicLruBuilder<K, V> WithAtomicCreate<K, V>(this ScopedAsyncLruBuilder<K, V> b) where V : IDisposable
+        {
+            var a = new AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>>(b.info);
+            return new ScopedAsyncAtomicLruBuilder<K, V>(a);
+        }
     }
 }
diff --git a/BitFaster.Caching/Lru/TemplateConcurrentLru.cs b/BitFaster.Caching/Lru/TemplateConcurrentLru.cs
index 0190072e..c332fa97 100644
--- a/BitFaster.Caching/Lru/TemplateConcurrentLru.cs
+++ b/BitFaster.Caching/Lru/TemplateConcurrentLru.cs
@@ -28,7 +28,7 @@ namespace BitFaster.Caching.Lru
     /// 5. When warm is full, warm tail is moved to warm head or cold depending on WasAccessed.
     /// 6. When cold is full, cold tail is moved to warm head or removed from dictionary on depending on WasAccessed.
     /// </remarks>
-    public class TemplateConcurrentLru<K, V, I, P, T> : ICache<K, V>, IEnumerable<KeyValuePair<K, V>>
+    public class TemplateConcurrentLru<K, V, I, P, T> : ICache<K, V>, IAsyncCache<K, V>, IEnumerable<KeyValuePair<K, V>>
         where I : LruItem<K, V>
         where P : struct, IItemPolicy<K, V, I>
         where T : struct, ITelemetryPolicy<K, V>
diff --git a/BitFaster.Caching/ScopedAsyncCache.cs b/BitFaster.Caching/ScopedAsyncCache.cs
new file mode 100644
index 00000000..97195fa1
--- /dev/null
+++ b/BitFaster.Caching/ScopedAsyncCache.cs
@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching
+{
+    /// <summary>
+    /// A cache decorator for working with Scoped IDisposable values. The Scoped methods (e.g. ScopedGetOrAdd)
+    /// are threadsafe and create lifetimes that guarantee the value will not be disposed until the
+    /// lifetime is disposed.
+    /// </summary>
+    /// <typeparam name="K">The type of keys in the cache.</typeparam>
+    /// <typeparam name="V">The type of values in the cache.</typeparam>
+    public sealed class ScopedAsyncCache<K, V> : IScopedAsyncCache<K, V> where V : IDisposable
+    {
+        private readonly IAsyncCache<K, Scoped<V>> cache;
+
+        public ScopedAsyncCache(IAsyncCache<K, Scoped<V>> cache)
+        {
+            if (cache == null)
+            {
+                throw new ArgumentNullException(nameof(cache));
+            }
+
+            this.cache = cache;
+        }
+
+        ///<inheritdoc/>
+        public int Capacity => this.cache.Capacity;
+
+        ///<inheritdoc/>
+        public int Count => this.cache.Count;
+
+        ///<inheritdoc/>
+        public ICacheMetrics Metrics => this.cache.Metrics;
+
+        ///<inheritdoc/>
+        public ICacheEvents<K, Scoped<V>> Events => this.cache.Events;
+
+        ///<inheritdoc/>
+        public void AddOrUpdate(K key, V value)
+        {
+            this.cache.AddOrUpdate(key, new Scoped<V>(value));
+        }
+
+        ///<inheritdoc/>
+        public void Clear()
+        {
+            this.cache.Clear();
+        }
+
+        ///<inheritdoc/>
+        public async Task<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
+        {
+            int c = 0;
+            var spinwait = new SpinWait();
+            while (true)
+            {
+                var scope = await cache.GetOrAddAsync(key, valueFactory);
+
+                if (scope.TryCreateLifetime(out var lifetime))
+                {
+                    return lifetime;
+                }
+
+                spinwait.SpinOnce();
+
+                if (c++ > ScopedCacheDefaults.MaxRetry)
+                {
+                    throw new InvalidOperationException(ScopedCacheDefaults.RetryFailureMessage);
+                }
+            }
+        }
+
+        ///<inheritdoc/>
+        public void Trim(int itemCount)
+        {
+            this.cache.Trim(itemCount);
+        }
+
+        ///<inheritdoc/>
+        public bool ScopedTryGet(K key, out Lifetime<V> lifetime)
+        {
+            if (this.cache.TryGet(key, out var scope))
+            {
+                if (scope.TryCreateLifetime(out lifetime))
+                {
+                    return true;
+                }
+            }
+
+            lifetime = default;
+            return false;
+        }
+
+        ///<inheritdoc/>
+        public bool TryRemove(K key)
+        {
+            return this.cache.TryRemove(key);
+        }
+
+        ///<inheritdoc/>
+        public bool TryUpdate(K key, V value)
+        {
+            return this.cache.TryUpdate(key, new Scoped<V>(value));
+        }
+    }
+}
diff --git a/BitFaster.Caching/ScopedCache.cs b/BitFaster.Caching/ScopedCache.cs
index 4dcb3797..8d34e229 100644
--- a/BitFaster.Caching/ScopedCache.cs
+++ b/BitFaster.Caching/ScopedCache.cs
@@ -75,29 +75,6 @@ public Lifetime<V> ScopedGetOrAdd(K key, Func<K, Scoped<V>> valueFactory)
             }
         }
 
-        ///<inheritdoc/>
-        public async Task<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
-        {
-            int c = 0;
-            var spinwait = new SpinWait();
-            while (true)
-            {
-                var scope = await cache.GetOrAddAsync(key, valueFactory);
-
-                if (scope.TryCreateLifetime(out var lifetime))
-                {
-                    return lifetime;
-                }
-
-                spinwait.SpinOnce();
-
-                if (c++ > ScopedCacheDefaults.MaxRetry)
-                {
-                    throw new InvalidOperationException(ScopedCacheDefaults.RetryFailureMessage);
-                }
-            }
-        }
-
         ///<inheritdoc/>
         public void Trim(int itemCount)
         {
diff --git a/BitFaster.Caching/Synchronized/AtomicFactoryAsyncCache.cs b/BitFaster.Caching/Synchronized/AtomicFactoryAsyncCache.cs
index 41c141c5..ae015686 100644
--- a/BitFaster.Caching/Synchronized/AtomicFactoryAsyncCache.cs
+++ b/BitFaster.Caching/Synchronized/AtomicFactoryAsyncCache.cs
@@ -7,7 +7,7 @@
 
 namespace BitFaster.Caching.Synchronized
 {
-    public sealed class AtomicFactoryAsyncCache<K, V> : ICache<K, V>
+    public sealed class AtomicFactoryAsyncCache<K, V> : IAsyncCache<K, V>
     {
         private readonly ICache<K, AsyncAtomicFactory<K, V>> cache;
         private readonly EventProxy eventProxy;
@@ -41,11 +41,6 @@ public void Clear()
             cache.Clear();
         }
 
-        public V GetOrAdd(K key, Func<K, V> valueFactory)
-        {
-            throw new NotImplementedException();
-        }
-
         public Task<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
         {
             var synchronized = cache.GetOrAdd(key, _ => new AsyncAtomicFactory<K, V>());
diff --git a/BitFaster.Caching/Synchronized/AtomicFactoryScopedAsyncCache.cs b/BitFaster.Caching/Synchronized/AtomicFactoryScopedAsyncCache.cs
index 4f62e203..c717c713 100644
--- a/BitFaster.Caching/Synchronized/AtomicFactoryScopedAsyncCache.cs
+++ b/BitFaster.Caching/Synchronized/AtomicFactoryScopedAsyncCache.cs
@@ -8,7 +8,7 @@
 
 namespace BitFaster.Caching.Synchronized
 {
-    public sealed class AtomicFactoryScopedAsyncCache<K, V> : IScopedCache<K, V> where V : IDisposable
+    public sealed class AtomicFactoryScopedAsyncCache<K, V> : IScopedAsyncCache<K, V> where V : IDisposable
     {
         private readonly ICache<K, ScopedAsyncAtomicFactory<K, V>> cache;
         private readonly EventProxy eventProxy;
@@ -42,11 +42,6 @@ public void Clear()
             this.cache.Clear();
         }
 
-        public Lifetime<V> ScopedGetOrAdd(K key, Func<K, Scoped<V>> valueFactory)
-        {
-            throw new NotImplementedException();
-        }
-
         public async Task<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
         {
             int c = 0;
diff --git a/BitFaster.Caching/Synchronized/AtomicFactoryScopedCache.cs b/BitFaster.Caching/Synchronized/AtomicFactoryScopedCache.cs
index 3e317441..62f85883 100644
--- a/BitFaster.Caching/Synchronized/AtomicFactoryScopedCache.cs
+++ b/BitFaster.Caching/Synchronized/AtomicFactoryScopedCache.cs
@@ -64,11 +64,6 @@ public Lifetime<V> ScopedGetOrAdd(K key, Func<K, Scoped<V>> valueFactory)
             }
         }
 
-        public Task<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
-        {
-            throw new NotImplementedException();
-        }
-
         public bool ScopedTryGet(K key, out Lifetime<V> lifetime)
         {
             if (this.cache.TryGet(key, out var scope))