diff --git a/.editorconfig b/.editorconfig
index 758eb9d9..ea604296 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -147,5 +147,5 @@ csharp_preserve_single_line_statements = true
 csharp_preserve_single_line_blocks = true
 
 # starting to convert to 4 spaces
-[*WindowsOpenSshPipe*.cs]
+[*{WindowsOpenSshPipe,WslSocket,UnixDomainSocketEndPoint}*.cs]
 indent_size = 4
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b7ffa653..5a0e4a5e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,8 @@
 
 ## Added
 - Added this changelog.
-- Added PuTTY private key v3 support
+- Added PuTTY private key v3 support.
+- Added Window UNIX socket for WSL `ssh-agent` support.
 
 ## Fixed
 - Fixed using incorrect unmanaged memory free function in `PagentClent.SendMessage()`.
diff --git a/SshAgentLib/Microsoft/UnixDomainSocketEndPoint.Windows.cs b/SshAgentLib/Microsoft/UnixDomainSocketEndPoint.Windows.cs
new file mode 100644
index 00000000..0274c1f5
--- /dev/null
+++ b/SshAgentLib/Microsoft/UnixDomainSocketEndPoint.Windows.cs
@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Net.Sockets
+{
+  /// <summary>Represents a Unix Domain Socket endpoint as a path.</summary>
+  public sealed partial class UnixDomainSocketEndPoint : EndPoint
+  {
+#pragma warning disable CA1802 // on Unix these need to be static readonly rather than const, so we do the same on Windows for consistency
+    private static readonly int s_nativePathOffset = 2; // sizeof(sun_family)
+    private static readonly int s_nativePathLength = 108; // sizeof(sun_path)
+    private static readonly int s_nativeAddressSize = s_nativePathOffset + s_nativePathLength; // sizeof(sockaddr_un)
+#pragma warning restore CA1802
+
+    private SocketAddress CreateSocketAddressForSerialize() =>
+        new SocketAddress(AddressFamily.Unix, s_nativeAddressSize);
+
+    // from afunix.h:
+    //#define UNIX_PATH_MAX 108
+    //typedef struct sockaddr_un
+    //{
+    //    ADDRESS_FAMILY sun_family;     /* AF_UNIX */
+    //    char sun_path[UNIX_PATH_MAX];  /* pathname */
+    //}
+    //SOCKADDR_UN, *PSOCKADDR_UN;
+  }
+}
diff --git a/SshAgentLib/Microsoft/UnixDomainSocketEndPoint.cs b/SshAgentLib/Microsoft/UnixDomainSocketEndPoint.cs
new file mode 100644
index 00000000..f2fe1716
--- /dev/null
+++ b/SshAgentLib/Microsoft/UnixDomainSocketEndPoint.cs
@@ -0,0 +1,161 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using System.Text;
+using System.IO;
+
+namespace System.Net.Sockets
+{
+    /// <summary>Represents a Unix Domain Socket endpoint as a path.</summary>
+    public sealed partial class UnixDomainSocketEndPoint : EndPoint
+    {
+        private const AddressFamily EndPointAddressFamily = AddressFamily.Unix;
+
+        private readonly string _path;
+        private readonly byte[] _encodedPath;
+
+        // Tracks the file Socket should delete on Dispose.
+        internal string BoundFileName { get; }
+
+        public UnixDomainSocketEndPoint(string path)
+            : this(path, null)
+        { }
+
+        private UnixDomainSocketEndPoint(string path, string boundFileName)
+        {
+            if (path == null)
+            {
+                throw new ArgumentNullException(nameof(path));
+            }
+
+            BoundFileName = boundFileName;
+
+            // Pathname socket addresses should be null-terminated.
+            // Linux abstract socket addresses start with a zero byte, they must not be null-terminated.
+            bool isAbstract = IsAbstract(path);
+            int bufferLength = Encoding.UTF8.GetByteCount(path);
+            if (!isAbstract)
+            {
+                // for null terminator
+                bufferLength++;
+            }
+
+            if (path.Length == 0 || bufferLength > s_nativePathLength)
+            {
+                const string ArgumentOutOfRange_PathLengthInvalid =
+                    "The path '{0}' is of an invalid length for use with domain sockets on this platform.  The length must be between 1 and {1} characters, inclusive.";
+
+                throw new ArgumentOutOfRangeException(
+                    nameof(path), path,
+                    string.Format(ArgumentOutOfRange_PathLengthInvalid, path, s_nativePathLength));
+                //SR.Format(SR.ArgumentOutOfRange_PathLengthInvalid, path, s_nativePathLength));
+            }
+
+            _path = path;
+            _encodedPath = new byte[bufferLength];
+            int bytesEncoded = Encoding.UTF8.GetBytes(path, 0, path.Length, _encodedPath, 0);
+            Debug.Assert(bufferLength - (isAbstract ? 0 : 1) == bytesEncoded);
+
+            // FIXME: see https://github.com/dotnet/runtime/blob/f85ea976f81945ea18cd5dc71959cccecdc93cd2/src/libraries/Common/src/System/Net/SocketProtocolSupportPal.Windows.cs#L14
+            //if (!Socket.OSSupportsUnixDomainSockets)
+            //{
+            //    throw new PlatformNotSupportedException();
+            //}
+        }
+
+        internal static int MaxAddressSize => s_nativeAddressSize;
+
+        internal UnixDomainSocketEndPoint(SocketAddress socketAddress)
+        {
+            if (socketAddress == null)
+            {
+                throw new ArgumentNullException(nameof(socketAddress));
+            }
+
+            if (socketAddress.Family != EndPointAddressFamily ||
+                socketAddress.Size > s_nativeAddressSize)
+            {
+                throw new ArgumentOutOfRangeException(nameof(socketAddress));
+            }
+
+            if (socketAddress.Size > s_nativePathOffset)
+            {
+                _encodedPath = new byte[socketAddress.Size - s_nativePathOffset];
+                for (int i = 0; i < _encodedPath.Length; i++)
+                {
+                    _encodedPath[i] = socketAddress[s_nativePathOffset + i];
+                }
+
+                // Strip trailing null of pathname socket addresses.
+                int length = _encodedPath.Length;
+                if (!IsAbstract(_encodedPath))
+                {
+                    // Since this isn't an abstract path, we're sure our first byte isn't 0.
+                    while (_encodedPath[length - 1] == 0)
+                    {
+                        length--;
+                    }
+                }
+                _path = Encoding.UTF8.GetString(_encodedPath, 0, length);
+            }
+            else
+            {
+                _encodedPath = Array.Empty<byte>();
+                _path = string.Empty;
+            }
+        }
+
+        public override SocketAddress Serialize()
+        {
+            SocketAddress result = CreateSocketAddressForSerialize();
+
+            for (int index = 0; index < _encodedPath.Length; index++)
+            {
+                result[s_nativePathOffset + index] = _encodedPath[index];
+            }
+
+            return result;
+        }
+
+        public override EndPoint Create(SocketAddress socketAddress) => new UnixDomainSocketEndPoint(socketAddress);
+
+        public override AddressFamily AddressFamily => EndPointAddressFamily;
+
+        public override string ToString()
+        {
+            bool isAbstract = IsAbstract(_path);
+            if (isAbstract)
+            {
+                // return string.Concat("@", _path.AsSpan(1));
+                return "@" + _path.Substring(1);
+            }
+            else
+            {
+                return _path;
+            }
+        }
+
+        internal UnixDomainSocketEndPoint CreateBoundEndPoint()
+        {
+            if (IsAbstract(_path))
+            {
+                return this;
+            }
+            return new UnixDomainSocketEndPoint(_path, Path.GetFullPath(_path));
+        }
+
+        internal UnixDomainSocketEndPoint CreateUnboundEndPoint()
+        {
+            if (IsAbstract(_path) || BoundFileName is null)
+            {
+                return this;
+            }
+            return new UnixDomainSocketEndPoint(_path, null);
+        }
+
+        private static bool IsAbstract(string path) => path.Length > 0 && path[0] == '\0';
+
+        private static bool IsAbstract(byte[] encodedPath) => encodedPath.Length > 0 && encodedPath[0] == 0;
+    }
+}
diff --git a/SshAgentLib/PageantAgent.cs b/SshAgentLib/PageantAgent.cs
index 872813e9..05244fa4 100644
--- a/SshAgentLib/PageantAgent.cs
+++ b/SshAgentLib/PageantAgent.cs
@@ -1,4 +1,4 @@
-//
+//
 // PageantAgent.cs
 //
 // Author(s): David Lechner <david@lechnology.com>
@@ -53,6 +53,7 @@ public class PageantAgent : Agent
     const int ERROR_CLASS_ALREADY_EXISTS = 1410;
     const int WM_COPYDATA = 0x004A;
     const int WSAECONNABORTED = 10053;
+    const int WSAECONNRESET = 10054;
 
     /* From PuTTY source code */
 
@@ -70,6 +71,7 @@ public class PageantAgent : Agent
     object lockObject = new object();
     CygwinSocket cygwinSocket;
     MsysSocket msysSocket;
+    WslSocket wslSocket;
     WindowsOpenSshPipe opensshPipe;
     Thread winThread;
 
@@ -287,6 +289,36 @@ public void StopMsysSocket()
       msysSocket = null;
     }
 
+    /// <summary>
+    /// Starts a wsl style socket that can be used by the ssh program
+    /// that comes with wsl.
+    /// </summary>
+    /// <param name="path">The path to the socket file that will be created.</param>
+    public void StartWslSocket(string path)
+    {
+      if (disposed) {
+        throw new ObjectDisposedException("PagentAgent");
+      }
+      if (wslSocket != null) {
+        return;
+      }
+      // only overwrite a file if it looks like a WslSocket file.
+      if (File.Exists(path) && WslSocket.TestFile(path)) {
+        File.Delete(path);
+      }
+      wslSocket = new WslSocket(path, connectionHandler);
+    }
+
+    public void StopWslSocket()
+    {
+      if (disposed)
+        throw new ObjectDisposedException("PagentAgent");
+      if (wslSocket == null)
+        return;
+      wslSocket.Dispose();
+      wslSocket = null;
+    }
+
     public void StartWindowsOpenSshPipe()
     {
       if (disposed) {
@@ -353,6 +385,7 @@ private void RunWindowInNewAppcontext()
       // make sure socket files are cleaned up when we stop.
       StopCygwinSocket();
       StopMsysSocket();
+      StopWslSocket();
       StopWindowsOpenSshPipe();
 
       if (hwnd != IntPtr.Zero) {
@@ -455,7 +488,8 @@ void connectionHandler(Stream stream, Process process)
           }
       } catch (IOException ex) {
         var socketException = ex.InnerException as SocketException;
-        if (socketException != null && socketException.ErrorCode == WSAECONNABORTED) {
+        if (socketException != null && (
+          socketException.ErrorCode == WSAECONNABORTED || socketException.ErrorCode == WSAECONNRESET)) {
           // expected error
           return;
         }
diff --git a/SshAgentLib/SshAgentLib.csproj b/SshAgentLib/SshAgentLib.csproj
index d56f83f1..a3523e30 100644
--- a/SshAgentLib/SshAgentLib.csproj
+++ b/SshAgentLib/SshAgentLib.csproj
@@ -95,6 +95,9 @@
     <Compile Include="Crypto\Ed25519PublicKeyParameter.cs" />
     <Compile Include="Crypto\Ed25519Signer.cs" />
     <Compile Include="Crypto\SaltParseException.cs" />
+    <Compile Include="Microsoft\UnixDomainSocketEndPoint.cs" />
+    <Compile Include="Microsoft\UnixDomainSocketEndPoint.Windows.cs" />
+    <Compile Include="WslSocket.cs" />
     <Compile Include="WindowsOpenSshPipe.cs" />
     <Compile Include="MsysSocket .cs" />
     <Compile Include="CygwinSocket.cs" />
@@ -159,6 +162,9 @@
     <PackageReference Include="Portable.BouncyCastle">
       <Version>1.8.1.3</Version>
     </PackageReference>
+    <PackageReference Include="System.Net.Sockets">
+      <Version>4.3.0</Version>
+    </PackageReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/SshAgentLib/WslSocket.cs b/SshAgentLib/WslSocket.cs
new file mode 100644
index 00000000..f125b14f
--- /dev/null
+++ b/SshAgentLib/WslSocket.cs
@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: GPL-2.0-only
+// Copyright (c) 2022 David Lechner <david@lechnology.com>
+
+// Allows WSL connections via AF_UNIX sockets on Windows 10 and above.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Net.Sockets;
+using System.Security.AccessControl;
+using System.Security.Principal;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace dlech.SshAgentLib
+{
+    public class WslSocket : IDisposable
+    {
+        // https://docs.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2
+        private const int WSAEADDRINUSE = 10048;
+
+        private readonly CancellationTokenSource cancelSource;
+        private readonly Task socketTask;
+
+        public delegate void ConnectionHandlerFunc(Stream stream, Process process);
+
+        /// <summary>
+        /// Create new "unix domain" socket for use with WSL.
+        /// </summary>
+        /// <param name="path">
+        /// The name of the file to use for the socket.
+        /// </param>
+        /// <param name="connectionHandler">
+        /// The callback that will be used to service client connetions.
+        /// </param>
+        public WslSocket(string path, ConnectionHandlerFunc connectionHandler)
+        {
+            var socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);
+
+            try
+            {
+                var endpoint = new UnixDomainSocketEndPoint(path);
+                try
+                {
+                    socket.Bind(endpoint);
+                }
+                catch (SocketException ex) when (ex.ErrorCode == WSAEADDRINUSE)
+                {
+                    throw new PageantRunningException();
+                }
+
+                var fileSecurity = File.GetAccessControl(path);
+                // This turns off ACL inheritance and removes all inherited rules
+                fileSecurity.SetAccessRuleProtection(true, false);
+                // We are left with no permissions at all, so we have to add them
+                // back for the current user
+                var userOnlyRule = new FileSystemAccessRule(
+                    WindowsIdentity.GetCurrent().User,
+                    FileSystemRights.FullControl,
+                    AccessControlType.Allow);
+                fileSecurity.SetAccessRule(userOnlyRule);
+                File.SetAccessControl(path, fileSecurity);
+
+                socket.Listen(5);
+
+                cancelSource = new CancellationTokenSource();
+                socketTask = AcceptConnectionsAsync(socket, connectionHandler, cancelSource.Token);
+
+                Debug.WriteLine("Started WSL socket");
+            }
+            catch (Exception)
+            {
+                socket.Dispose();
+                try
+                {
+                    File.Delete(path);
+                }
+                catch
+                {
+
+                }
+                throw;
+            }
+        }
+
+        private static async Task AcceptConnectionsAsync(
+            Socket socket,
+            ConnectionHandlerFunc connectionHandler,
+            CancellationToken cancellationToken)
+        {
+            cancellationToken.Register(() =>
+            {
+                // have to get endpoint before Dispose() to avoid exception.
+                var endpoint = socket.LocalEndPoint as UnixDomainSocketEndPoint;
+                socket.Dispose();
+
+                // In .NET core, the Socket.Dispose() will take care of this, but
+                // for now...
+                try
+                {
+                    File.Delete(endpoint.CreateBoundEndPoint().BoundFileName);
+                }
+                catch
+                {
+                    // we tried
+                }
+            });
+
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                using (var clientSocket = await socket.AcceptAsync().ConfigureAwait(false))
+                using (cancellationToken.Register(() => clientSocket.Close()))
+                {
+                    Debug.WriteLine("Accepted WSL socket client connection");
+
+                    await Task.Run(() =>
+                    {
+                        using (var stream = new NetworkStream(clientSocket))
+                        {
+                            var proc = default(Process);
+                            connectionHandler(stream, proc);
+                        }
+                    }).ConfigureAwait(false);
+                }
+            }
+
+        }
+
+        /// <summary>
+        /// Tests a file to see if it looks like a Unix socket file
+        /// </summary>
+        /// <param name="path">The path to the file.</param>
+        /// <returns><c>true</c> if the file contents look correct</returns>
+        public static bool TestFile(string path)
+        {
+            var info = new FileInfo(path);
+            return info.Length == 0;
+        }
+
+        public void Dispose()
+        {
+            cancelSource.Cancel();
+
+            if (!socketTask.IsCompleted)
+            {
+                // allow Dispose to be called multiple times.
+                return;
+            }
+
+            try
+            {
+                socketTask.Wait();
+            }
+            catch (AggregateException)
+            {
+                // happens because we canceled the task
+            }
+
+            Debug.WriteLine("Stopped WSL socket");
+        }
+    }
+}
diff --git a/SshAgentLibTests/SshAgentLibTests.csproj b/SshAgentLibTests/SshAgentLibTests.csproj
index db9cc03e..d865c69b 100644
--- a/SshAgentLibTests/SshAgentLibTests.csproj
+++ b/SshAgentLibTests/SshAgentLibTests.csproj
@@ -112,6 +112,7 @@
     <Compile Include="ISshKeyTest.cs" />
     <Compile Include="OpensshPublicKeyFormatterTests.cs" />
     <Compile Include="WindowsOpenSshPipeTests.cs" />
+    <Compile Include="WslSocketTests.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <ItemGroup>
diff --git a/SshAgentLibTests/WslSocketTests.cs b/SshAgentLibTests/WslSocketTests.cs
new file mode 100644
index 00000000..2f8b4f3a
--- /dev/null
+++ b/SshAgentLibTests/WslSocketTests.cs
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2022 David Lechner <david@lechnology.com>
+
+using System.IO;
+using System.Net.Sockets;
+using NUnit.Framework;
+using dlech.SshAgentLib;
+using System.Threading;
+
+namespace dlech.SshAgentLibTests
+{
+    [TestFixture, NonParallelizable, Platform("Win")]
+    public sealed class WslSocketTests
+    {
+        private const string testPath = "test-wsl-socket";
+
+        [SetUp]
+        public void Setup()
+        {
+            try
+            {
+                // Delete the socket file in case a bad test left it behind.
+                File.Delete(testPath);
+            }
+            catch
+            {
+                // expected most of the time
+            }
+        }
+
+        [Test, NonParallelizable]
+        public void TestMultipleInstancesThrowsException()
+        {
+            using (new WslSocket(testPath, (s, p) => { }))
+            {
+                Assert.That(() => new WslSocket(testPath, (s2, p2) => { }),
+                    Throws.TypeOf<PageantRunningException>());
+            }
+        }
+
+        [Test, NonParallelizable]
+        public void TestThatServerStopsListeningWhenDisposed()
+        {
+            using (new WslSocket(testPath, (s, p) => { }))
+            {
+                Assert.That(File.Exists(testPath),
+                    "Creating pipe should create socket file");
+            }
+            Assert.That(!File.Exists(testPath),
+                "Disposing pipe should remove file.");
+        }
+
+        [Test, NonParallelizable]
+        public void TestThatSequentialConnectionsWork()
+        {
+            using (new WslSocket(testPath, (s, p) => { }))
+            {
+                var endpoint = new UnixDomainSocketEndPoint(testPath);
+
+                using (var client = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified))
+                {
+                    client.Connect(endpoint);
+                }
+
+                using (var client = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified))
+                {
+                    client.Connect(endpoint);
+                }
+            }
+        }
+
+        [Test, NonParallelizable]
+        public void TestThatDisposingWhileClientIsConnectedWorks()
+        {
+            var callbackEvent = new AutoResetEvent(false);
+
+            using (var socket = new WslSocket(testPath, (s, p) =>
+            {
+                s.ReadByte();
+                callbackEvent.Set();
+                s.ReadByte();
+                callbackEvent.Set();
+            }))
+            {
+                var endpoint = new UnixDomainSocketEndPoint(testPath);
+
+                using (var client = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified))
+                {
+                    client.Connect(endpoint);
+                    client.Send(new byte[1]);
+                    // have to wait for callback, otherwise we might dispose server
+                    // before client connection is finished
+                    callbackEvent.WaitOne(1000);
+                    socket.Dispose();
+                    Assert.That(() => client.Send(new byte[1]), Throws.TypeOf<SocketException>());
+                }
+            }
+        }
+    }
+}