diff --git a/BitFaster.Caching.Benchmarks/Lru/LruAsyncGet.cs b/BitFaster.Caching.Benchmarks/Lru/LruAsyncGet.cs
new file mode 100644
index 00000000..02742ee1
--- /dev/null
+++ b/BitFaster.Caching.Benchmarks/Lru/LruAsyncGet.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using BitFaster.Caching.Lru;
+
+namespace BitFaster.Caching.Benchmarks.Lru
+{
+    /// <summary>
+    /// Verify 0 allocs for GetOrAddAsync cache hits.
+    /// </summary>
+    [SimpleJob(RuntimeMoniker.Net48)]
+    [SimpleJob(RuntimeMoniker.Net60)]
+    [DisassemblyDiagnoser(printSource: true, maxDepth: 5)]
+    [MemoryDiagnoser]
+    public class LruAsyncGet
+    {
+        // if the cache value is a value type, value task has no effect - so use string to repro.
+        private static readonly IAsyncCache<int, string> concurrentLru = new ConcurrentLruBuilder<int, string>().AsAsyncCache().Build();
+        private static readonly IAsyncCache<int, string> atomicConcurrentLru = new ConcurrentLruBuilder<int, string>().AsAsyncCache().WithAtomicCreate().Build();
+
+        private static Task<string> returnTask = Task.FromResult("1");
+
+        [Benchmark()]
+        public async ValueTask<string> GetOrAddAsync()
+        {
+            Func<int, Task<string>> func = x => returnTask;
+
+            return await concurrentLru.GetOrAddAsync(1, func);
+        }
+
+        [Benchmark()]
+        public async ValueTask<string> AtomicGetOrAddAsync()
+        {
+            Func<int, Task<string>> func = x => returnTask;
+
+            return await atomicConcurrentLru.GetOrAddAsync(1, func);
+        }
+    }
+}
diff --git a/BitFaster.Caching.UnitTests/Synchronized/AsyncAtomicFactoryTests.cs b/BitFaster.Caching.UnitTests/Synchronized/AsyncAtomicFactoryTests.cs
index 18f8e3ef..e2885f34 100644
--- a/BitFaster.Caching.UnitTests/Synchronized/AsyncAtomicFactoryTests.cs
+++ b/BitFaster.Caching.UnitTests/Synchronized/AsyncAtomicFactoryTests.cs
@@ -70,7 +70,7 @@ public async Task WhenCallersRunConcurrentlyResultIsFromWinner()
             var result = 0;
             var winnerCount = 0;
 
-            Task<int> first = atomicFactory.GetValueAsync(1, async k =>
+            var first = atomicFactory.GetValueAsync(1, async k =>
             {
                 enter.SetResult(true);
                 await resume.Task;
@@ -80,7 +80,7 @@ public async Task WhenCallersRunConcurrentlyResultIsFromWinner()
                 return 1;
             });
 
-            Task<int> second = atomicFactory.GetValueAsync(1, async k =>
+            var second = atomicFactory.GetValueAsync(1, async k =>
             {
                 enter.SetResult(true);
                 await resume.Task;
diff --git a/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryCacheTests.cs b/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryCacheTests.cs
index 55fa417e..722882d1 100644
--- a/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryCacheTests.cs
+++ b/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryCacheTests.cs
@@ -106,14 +106,6 @@ public void WhenKeyDoesNotExistGetOrAddAddsValue()
             value.Should().Be(1);
         }
 
-        [Fact]
-        public async Task GetOrAddAsyncThrows()
-        {
-            Func<Task> getOrAdd = async () => { await this.cache.GetOrAddAsync(1, k => Task.FromResult(k)); };
-
-            await getOrAdd.Should().ThrowAsync<NotImplementedException>();
-        }
-
         [Fact]
         public void WhenCacheContainsValuesTrim1RemovesColdestValue()
         {
diff --git a/BitFaster.Caching.UnitTests/Synchronized/ScopedAsyncAtomicFactoryTests.cs b/BitFaster.Caching.UnitTests/Synchronized/ScopedAsyncAtomicFactoryTests.cs
index bd04a979..f7b3833d 100644
--- a/BitFaster.Caching.UnitTests/Synchronized/ScopedAsyncAtomicFactoryTests.cs
+++ b/BitFaster.Caching.UnitTests/Synchronized/ScopedAsyncAtomicFactoryTests.cs
@@ -98,7 +98,7 @@ public async Task WhenCallersRunConcurrentlyResultIsFromWinner()
             var winningNumber = 0;
             var winnerCount = 0;
 
-            Task<(bool r, Lifetime<IntHolder> l)> first = atomicFactory.TryCreateLifetimeAsync(1, async k =>
+            ValueTask<(bool r, Lifetime<IntHolder> l)> first = atomicFactory.TryCreateLifetimeAsync(1, async k =>
             {
                 enter.SetResult(true);
                 await resume.Task;
@@ -108,7 +108,7 @@ public async Task WhenCallersRunConcurrentlyResultIsFromWinner()
                 return new Scoped<IntHolder>(new IntHolder() { actualNumber = 1 });
             });
 
-            Task<(bool r, Lifetime<IntHolder> l)> second = atomicFactory.TryCreateLifetimeAsync(1, async k =>
+            ValueTask<(bool r, Lifetime<IntHolder> l)> second = atomicFactory.TryCreateLifetimeAsync(1, async k =>
             {
                 enter.SetResult(true);
                 await resume.Task;
@@ -142,7 +142,7 @@ public async Task WhenDisposedWhileInitResultIsDisposed()
             var atomicFactory = new ScopedAsyncAtomicFactory<int, IntHolder>();
             var holder = new IntHolder() { actualNumber = 1 };
 
-            Task<(bool r, Lifetime<IntHolder> l)> first = atomicFactory.TryCreateLifetimeAsync(1, async k =>
+            ValueTask<(bool r, Lifetime<IntHolder> l)> first = atomicFactory.TryCreateLifetimeAsync(1, async k =>
             {
                 enter.SetResult(true);
                 await resume.Task;
@@ -171,7 +171,7 @@ public async Task WhenDisposedWhileThrowingNextInitIsDisposed()
             var atomicFactory = new ScopedAsyncAtomicFactory<int, IntHolder>();
             var holder = new IntHolder() { actualNumber = 1 };
 
-            Task<(bool r, Lifetime<IntHolder> l)> first = atomicFactory.TryCreateLifetimeAsync(1, async k =>
+            ValueTask<(bool r, Lifetime<IntHolder> l)> first = atomicFactory.TryCreateLifetimeAsync(1, async k =>
             {
                 enter.SetResult(true);
                 await resume.Task;
diff --git a/BitFaster.Caching/BitFaster.Caching.csproj b/BitFaster.Caching/BitFaster.Caching.csproj
index b217ca49..2a4fab3b 100644
--- a/BitFaster.Caching/BitFaster.Caching.csproj
+++ b/BitFaster.Caching/BitFaster.Caching.csproj
@@ -39,4 +39,8 @@
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
   </ItemGroup>
 
+  <ItemGroup Condition=" '$(TargetFramework)' == 'net472' or '$(TargetFramework)' == 'net48' or '$(TargetFramework)' == 'netstandard2.0'">
+     <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
+  </ItemGroup>
+
 </Project>
diff --git a/BitFaster.Caching/IAsyncCache.cs b/BitFaster.Caching/IAsyncCache.cs
index 7e547cb1..7f837876 100644
--- a/BitFaster.Caching/IAsyncCache.cs
+++ b/BitFaster.Caching/IAsyncCache.cs
@@ -48,7 +48,7 @@ public interface IAsyncCache<K, V>
         /// <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);
+        ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory);
 
         /// <summary>
         /// Attempts to remove the value that has the specified key.
diff --git a/BitFaster.Caching/IScopedAsyncCache.cs b/BitFaster.Caching/IScopedAsyncCache.cs
index 4906d441..32ba7150 100644
--- a/BitFaster.Caching/IScopedAsyncCache.cs
+++ b/BitFaster.Caching/IScopedAsyncCache.cs
@@ -53,7 +53,7 @@ public interface IScopedAsyncCache<K, V> where V : IDisposable
         /// <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);
+        ValueTask<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory);
 
         /// <summary>
         /// Attempts to remove the value that has the specified key.
diff --git a/BitFaster.Caching/Lru/ClassicLru.cs b/BitFaster.Caching/Lru/ClassicLru.cs
index b787d37b..0bfc8f62 100644
--- a/BitFaster.Caching/Lru/ClassicLru.cs
+++ b/BitFaster.Caching/Lru/ClassicLru.cs
@@ -149,7 +149,7 @@ public V GetOrAdd(K key, Func<K, V> valueFactory)
         }
 
         ///<inheritdoc/>
-        public async Task<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
+        public async ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
         {
             if (this.TryGet(key, out var value))
             {
diff --git a/BitFaster.Caching/Lru/TemplateConcurrentLru.cs b/BitFaster.Caching/Lru/TemplateConcurrentLru.cs
index c332fa97..4759222b 100644
--- a/BitFaster.Caching/Lru/TemplateConcurrentLru.cs
+++ b/BitFaster.Caching/Lru/TemplateConcurrentLru.cs
@@ -184,7 +184,7 @@ public V GetOrAdd(K key, Func<K, V> valueFactory)
         }
 
         ///<inheritdoc/>
-        public async Task<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
+        public async ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
         {
             while (true)
             {
diff --git a/BitFaster.Caching/ScopedAsyncCache.cs b/BitFaster.Caching/ScopedAsyncCache.cs
index 97195fa1..f15dbe53 100644
--- a/BitFaster.Caching/ScopedAsyncCache.cs
+++ b/BitFaster.Caching/ScopedAsyncCache.cs
@@ -53,7 +53,7 @@ public void Clear()
         }
 
         ///<inheritdoc/>
-        public async Task<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
+        public async ValueTask<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
         {
             int c = 0;
             var spinwait = new SpinWait();
diff --git a/BitFaster.Caching/Synchronized/AsyncAtomicFactory.cs b/BitFaster.Caching/Synchronized/AsyncAtomicFactory.cs
index c9f5f289..0c33122f 100644
--- a/BitFaster.Caching/Synchronized/AsyncAtomicFactory.cs
+++ b/BitFaster.Caching/Synchronized/AsyncAtomicFactory.cs
@@ -26,7 +26,7 @@ public AsyncAtomicFactory(V value)
             this.value = value;
         }
 
-        public async Task<V> GetValueAsync(K key, Func<K, Task<V>> valueFactory)
+        public async ValueTask<V> GetValueAsync(K key, Func<K, Task<V>> valueFactory)
         {
             if (initializer == null)
             {
@@ -51,7 +51,7 @@ public V ValueIfCreated
             }
         }
 
-        private async Task<V> CreateValueAsync(K key, Func<K, Task<V>> valueFactory)
+        private async ValueTask<V> CreateValueAsync(K key, Func<K, Task<V>> valueFactory)
         {
             var init = initializer;
 
@@ -70,7 +70,7 @@ private class Initializer
             private bool isInitialized;
             private Task<V> valueTask;
 
-            public async Task<V> CreateValueAsync(K key, Func<K, Task<V>> valueFactory)
+            public async ValueTask<V> CreateValueAsync(K key, Func<K, Task<V>> valueFactory)
             {
                 var tcs = new TaskCompletionSource<V>(TaskCreationOptions.RunContinuationsAsynchronously);
 
diff --git a/BitFaster.Caching/Synchronized/AtomicFactoryAsyncCache.cs b/BitFaster.Caching/Synchronized/AtomicFactoryAsyncCache.cs
index 2ebd7589..467d7f6b 100644
--- a/BitFaster.Caching/Synchronized/AtomicFactoryAsyncCache.cs
+++ b/BitFaster.Caching/Synchronized/AtomicFactoryAsyncCache.cs
@@ -40,7 +40,7 @@ public void Clear()
             cache.Clear();
         }
 
-        public Task<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
+        public ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
         {
             var synchronized = cache.GetOrAdd(key, _ => new AsyncAtomicFactory<K, V>());
             return synchronized.GetValueAsync(key, valueFactory);
diff --git a/BitFaster.Caching/Synchronized/AtomicFactoryCache.cs b/BitFaster.Caching/Synchronized/AtomicFactoryCache.cs
index 867f6e08..e84a74c3 100644
--- a/BitFaster.Caching/Synchronized/AtomicFactoryCache.cs
+++ b/BitFaster.Caching/Synchronized/AtomicFactoryCache.cs
@@ -46,11 +46,6 @@ public V GetOrAdd(K key, Func<K, V> valueFactory)
             return atomicFactory.GetValue(key, valueFactory);
         }
 
-        public Task<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
-        {
-            throw new NotImplementedException();
-        }
-
         public void Trim(int itemCount)
         {
             this.cache.Trim(itemCount);
diff --git a/BitFaster.Caching/Synchronized/AtomicFactoryScopedAsyncCache.cs b/BitFaster.Caching/Synchronized/AtomicFactoryScopedAsyncCache.cs
index b07de119..9ce1ecc8 100644
--- a/BitFaster.Caching/Synchronized/AtomicFactoryScopedAsyncCache.cs
+++ b/BitFaster.Caching/Synchronized/AtomicFactoryScopedAsyncCache.cs
@@ -41,7 +41,7 @@ public void Clear()
             this.cache.Clear();
         }
 
-        public async Task<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
+        public async ValueTask<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
         {
             int c = 0;
             var spinwait = new SpinWait();
diff --git a/BitFaster.Caching/Synchronized/ScopedAsyncAtomicFactory.cs b/BitFaster.Caching/Synchronized/ScopedAsyncAtomicFactory.cs
index c14d89d5..2355b30f 100644
--- a/BitFaster.Caching/Synchronized/ScopedAsyncAtomicFactory.cs
+++ b/BitFaster.Caching/Synchronized/ScopedAsyncAtomicFactory.cs
@@ -46,7 +46,7 @@ public bool TryCreateLifetime(out Lifetime<V> lifetime)
             return scope.TryCreateLifetime(out lifetime);
         }
 
-        public async Task<(bool success, Lifetime<V> lifetime)> TryCreateLifetimeAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
+        public async ValueTask<(bool success, Lifetime<V> lifetime)> TryCreateLifetimeAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
         {
             // if disposed, return
             if (scope?.IsDisposed ?? false)
@@ -64,7 +64,7 @@ public bool TryCreateLifetime(out Lifetime<V> lifetime)
             return (res, lifetime);
         }
 
-        private async Task InitializeScopeAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
+        private async ValueTask InitializeScopeAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
         {
             var init = initializer;
 
@@ -97,7 +97,7 @@ private class Initializer
             private bool isDisposeRequested;
             private Task<Scoped<V>> task;
 
-            public async Task<Scoped<V>> CreateScopeAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
+            public async ValueTask<Scoped<V>> CreateScopeAsync(K key, Func<K, Task<Scoped<V>>> valueFactory)
             {
                 var tcs = new TaskCompletionSource<Scoped<V>>(TaskCreationOptions.RunContinuationsAsynchronously);