diff --git a/README.md b/README.md
index 7b9883e..1dc9f6a 100644
--- a/README.md
+++ b/README.md
@@ -24,7 +24,6 @@ dotnet add package PipelineNet
 - [Middleware](#middleware)
 - [Pipelines](#pipelines)
 - [Chains of responsibility](#chains-of-responsibility)
-- [Pipeline and Chain of responsibility factories](#pipeline-and-chain-of-responsibility-factories)
 - [Middleware resolver](#middleware-resolver)
   - [ServiceProvider implementation](#serviceprovider-implementation)
   - [Unity implementation](#unity-implementation)
@@ -197,18 +196,6 @@ result = await exceptionHandlersChain.Execute(new ArgumentException()); // Resul
 result = await exceptionHandlersChain.Execute(new InvalidOperationException()); // Result will be false
 ```
 
-## Pipeline and Chain of responsibility factories
-Instead of instantiating `IPipeline<TParamater>` and `IAsyncPipeline<TParamater>` directly, you can use `PipelineFactory<TParamater>` and `AsyncPipelineFactory<TParamater>` to instantiate them:
-```C#
-var pipelineFactory = new AsyncPipelineFactory<Bitmap>(new ActivatorMiddlewareResolver());
-
-var pipeline = pipelineFactory.Create()
-    .Add<RoudCornersAsyncMiddleware>()
-    .Add<AddTransparencyAsyncMiddleware>()
-    .Add<AddWatermarkAsyncMiddleware>();
-```
-To instantiate `IResponsibilityChain<TParameter, TReturn>` and `IAsyncResponsibilityChain<TParameter, TReturn>` you can use `ResponsibilityChainFactory<TParameter, TReturn>` and `AsyncResponsibilityChainFactory<TParameter, TReturn>`.
-
 ## Middleware resolver
 You may be wondering what is all this `ActivatorMiddlewareResolver` class being passed to every instance of pipeline and chain of responsibility.
 This is a default implementation of the `IMiddlewareResolver`, which is used to create instances of the middleware types.
@@ -227,11 +214,27 @@ You can grab it from nuget with:
 Install-Package PipelineNet.ServiceProvider
 ```
 
-Use it as follows:
+Instead of instantiating pipelines directly, `PipelineNet.ServiceProvider` uses factories to instantiate them:
+```C#
+IAsyncPipelineFactory<Bitmap> pipelineFactory = new AsyncPipelineFactory<Bitmap>();
+IServiceProvider serviceProvider = GetServiceProviderSomehow();
 
+IAsyncPipeline<Bitmap> pipeline = pipelineFactory.Create(serviceProvider)
+    .Add<RoudCornersAsyncMiddleware>()
+    .Add<AddTransparencyAsyncMiddleware>()
+    .Add<AddWatermarkAsyncMiddleware>();
+```
+
+It includes four types of factories:
+- `PipelineFactory<TParamater>` for pipelines.
+- `AsyncPipelineFactory<TParamater>` for asynchronous pipelines.
+- `ResponsibilityChainFactory<TParameter, TReturn>` for chains of responsibility.
+- `AsyncResponsibilityChainFactory<TParameter, TReturn>` for asynchronous chains of responsibility.
+
+It also includes extension methods for registering factories and automatic middleware registration through assembly scanning:
 ```C#
-services.AddPipelineNet(typeof(RoudCornersAsyncMiddleware).Assembly); // Add core PipelineNet services and all middleware from the assembly.
-services.AddScoped<IMyService, MyService>();
+services.AddPipelineNet(typeof(RoudCornersAsyncMiddleware).Assembly); // Add pipeline and chain of responsibility factories and all middleware from the assembly
+services.AddScoped<IMyService, MyService>(); // Add service as scoped so that scoped IServiceProvider gets injected
 
 public interface IMyService
 {
@@ -241,17 +244,21 @@ public interface IMyService
 public class MyService : IMyService
 {
     private readonly IAsyncPipelineFactory<Bitmap> _pipelineFactory;
+    private readonly IServiceProvider _serviceProvider;
 
-    public MyService(IAsyncPipelineFactory<Bitmap> pipelineFactory)
+    public MyService(
+        IAsyncPipelineFactory<Bitmap> pipelineFactory,
+        IServiceProvider serviceProvider)
     {
         _pipelineFactory = pipelineFactory;
+        _serviceProvider = serviceProvider;
     }
 
     public async Task DoSomething()
     {
         Bitmap image = (Bitmap) Image.FromFile("party-photo.png");
 
-        IAsyncPipeline<Bitmap> pipeline = _pipelineFactory.Create()
+        IAsyncPipeline<Bitmap> pipeline = _pipelineFactory.Create(_serviceProvider)
             .Add<RoudCornersAsyncMiddleware>()
             .Add<AddTransparencyAsyncMiddleware>()
             .Add<AddWatermarkAsyncMiddleware>();
@@ -264,7 +271,7 @@ public class RoudCornersAsyncMiddleware : IAsyncMiddleware<Bitmap>
 {
     private readonly ILogger<RoudCornersAsyncMiddleware> _logger;
 
-    // The following constructor argument will be provided by IServiceProvider
+    // The following constructor arguments will be provided by the IServiceProvider
     public RoudCornersAsyncMiddleware(ILogger<RoudCornersAsyncMiddleware> logger)
     {
         _logger = logger;
@@ -279,37 +286,6 @@ public class RoudCornersAsyncMiddleware : IAsyncMiddleware<Bitmap>
 }
 ```
 
-You can also instantiate the factory directly:
-
-```C#
-services.AddMidlewaresFromAssembly(typeof(RoudCornersAsyncMiddleware).Assembly); // Add all middleware from the assembly.
-services.AddScoped<IMyService, MyService>();
-
-public class MyService : IMyService
-{
-    private readonly IServiceProvider _serviceProvider;
-
-    public MyService(IServiceProvider serviceProvider)
-    {
-        _serviceProvider = serviceProvider;
-    }
-
-    public async Task DoSomething()
-    {
-        Bitmap image = (Bitmap) Image.FromFile("party-photo.png");
-
-        IAsyncPipelineFactory<Bitmap> pipelineFactory = new AsyncPipelineFactory<Bitmap>(new SeriveProviderMiddlewareResolver(_serviceProvider));
-
-        IAsyncPipeline<Bitmap> pipeline = pipelineFactory.Create()
-            .Add<RoudCornersAsyncMiddleware>()
-            .Add<AddTransparencyAsyncMiddleware>()
-            .Add<AddWatermarkAsyncMiddleware>();
-
-        await pipeline.Execute(image);
-    }
-}
-```
-
 Note that `IServiceProvider` lifetime can vary based on the lifetime of the containing class. For example, if you resolve service from a scope, and it takes an `IServiceProvider`, it'll be a scoped instance.
 
 For more information on dependency injection, see: [Dependency injection - .NET](https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection).
diff --git a/src/PipelineNet.ServiceProvider.Tests/ServiceCollectionExtensionsTests.cs b/src/PipelineNet.ServiceProvider.Tests/ServiceCollectionExtensionsTests.cs
index ffc5099..e64362b 100644
--- a/src/PipelineNet.ServiceProvider.Tests/ServiceCollectionExtensionsTests.cs
+++ b/src/PipelineNet.ServiceProvider.Tests/ServiceCollectionExtensionsTests.cs
@@ -1,8 +1,8 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using PipelineNet.Middleware;
-using PipelineNet.PipelineFactories;
 using PipelineNet.Pipelines;
+using PipelineNet.ServiceProvider.PipelineFactories;
 using Xunit.Abstractions;
 
 namespace PipelineNet.ServiceProvider.Tests
@@ -22,17 +22,21 @@ public interface IMyService
         public class MyService : IMyService
         {
             private readonly IAsyncPipelineFactory<Bitmap> _pipelineFactory;
+            private readonly IServiceProvider _serviceProvider;
 
-            public MyService(IAsyncPipelineFactory<Bitmap> pipelineFactory)
+            public MyService(
+                IAsyncPipelineFactory<Bitmap> pipelineFactory,
+                IServiceProvider serviceProvider)
             {
                 _pipelineFactory = pipelineFactory;
+                _serviceProvider = serviceProvider;
             }
 
             public async Task DoSomething()
             {
-                var image = new Bitmap();
+                Bitmap image = new Bitmap();
 
-                IAsyncPipeline<Bitmap> pipeline = _pipelineFactory.Create()
+                IAsyncPipeline<Bitmap> pipeline = _pipelineFactory.Create(_serviceProvider)
                     .Add<RoudCornersAsyncMiddleware>()
                     .Add<AddTransparencyAsyncMiddleware>()
                     .Add<AddWatermarkAsyncMiddleware>();
@@ -73,7 +77,6 @@ public class RoudCornersAsyncMiddleware : IAsyncMiddleware<Bitmap>
         {
             private readonly ILogger<RoudCornersAsyncMiddleware> _logger;
 
-            // The following constructor argument will be provided by IServiceProvider
             public RoudCornersAsyncMiddleware(ILogger<RoudCornersAsyncMiddleware> logger)
             {
                 _logger = logger;
@@ -82,7 +85,6 @@ public RoudCornersAsyncMiddleware(ILogger<RoudCornersAsyncMiddleware> logger)
             public async Task Run(Bitmap parameter, Func<Bitmap, Task> next)
             {
                 _logger.LogInformation("Running RoudCornersAsyncMiddleware.");
-                // Handle somehow
                 await next(parameter);
             }
         }
diff --git a/src/PipelineNet.ServiceProvider/ChainOfResponsibilityFactories/AsyncResponsibilityChainFactory.cs b/src/PipelineNet.ServiceProvider/ChainOfResponsibilityFactories/AsyncResponsibilityChainFactory.cs
new file mode 100644
index 0000000..47b4607
--- /dev/null
+++ b/src/PipelineNet.ServiceProvider/ChainOfResponsibilityFactories/AsyncResponsibilityChainFactory.cs
@@ -0,0 +1,20 @@
+using PipelineNet.ChainsOfResponsibility;
+using PipelineNet.ServiceProvider.MiddlewareResolver;
+using System;
+
+namespace PipelineNet.ServiceProvider.ChainOfResponsibilityFactories
+{
+    /// <inheritdoc/>
+    public class AsyncResponsibilityChainFactory<TParameter, TReturn>
+        : IAsyncResponsibilityChainFactory<TParameter, TReturn>
+    {
+        /// <inheritdoc/>
+        public IAsyncResponsibilityChain<TParameter, TReturn> Create(IServiceProvider serviceProvider)
+        {
+            if (serviceProvider == null) throw new ArgumentNullException("serviceProvider");
+
+            return new AsyncResponsibilityChain<TParameter, TReturn>(
+                new ServiceProviderMiddlewareResolver(serviceProvider));
+        }
+    }
+}
diff --git a/src/PipelineNet/ChainOfResponsibilityFactories/IAsyncResponsibilityChainFactory.cs b/src/PipelineNet.ServiceProvider/ChainOfResponsibilityFactories/IAsyncResponsibilityChainFactory.cs
similarity index 65%
rename from src/PipelineNet/ChainOfResponsibilityFactories/IAsyncResponsibilityChainFactory.cs
rename to src/PipelineNet.ServiceProvider/ChainOfResponsibilityFactories/IAsyncResponsibilityChainFactory.cs
index 81ce5d3..1de8e57 100644
--- a/src/PipelineNet/ChainOfResponsibilityFactories/IAsyncResponsibilityChainFactory.cs
+++ b/src/PipelineNet.ServiceProvider/ChainOfResponsibilityFactories/IAsyncResponsibilityChainFactory.cs
@@ -1,6 +1,7 @@
 using PipelineNet.ChainsOfResponsibility;
+using System;
 
-namespace PipelineNet.PipelineFactories
+namespace PipelineNet.ServiceProvider.ChainOfResponsibilityFactories
 {
     /// <summary>
     /// Used to create new instances of an asynchronous chain of responsibility.
@@ -12,7 +13,8 @@ public interface IAsyncResponsibilityChainFactory<TParameter, TReturn>
         /// <summary>
         /// Creates a new asynchronous chain of responsibility.
         /// </summary>
+        /// <param name="serviceProvider">The <see cref="IServiceProvider"/> that middlewares will be resolved from.</param>
         /// <returns>A new instance of an asynchronous chain.</returns>
-        IAsyncResponsibilityChain<TParameter, TReturn> Create();
+        IAsyncResponsibilityChain<TParameter, TReturn> Create(IServiceProvider serviceProvider);
     }
 }
diff --git a/src/PipelineNet/ChainOfResponsibilityFactories/IResponsibilityChainFactory.cs b/src/PipelineNet.ServiceProvider/ChainOfResponsibilityFactories/IResponsibilityChainFactory.cs
similarity index 64%
rename from src/PipelineNet/ChainOfResponsibilityFactories/IResponsibilityChainFactory.cs
rename to src/PipelineNet.ServiceProvider/ChainOfResponsibilityFactories/IResponsibilityChainFactory.cs
index 70716ca..cb5ece0 100644
--- a/src/PipelineNet/ChainOfResponsibilityFactories/IResponsibilityChainFactory.cs
+++ b/src/PipelineNet.ServiceProvider/ChainOfResponsibilityFactories/IResponsibilityChainFactory.cs
@@ -1,6 +1,7 @@
 using PipelineNet.ChainsOfResponsibility;
+using System;
 
-namespace PipelineNet.PipelineFactories
+namespace PipelineNet.ServiceProvider.ChainOfResponsibilityFactories
 {
     /// <summary>
     /// Used to create new instances of a chain of responsibility.
@@ -12,7 +13,8 @@ public interface IResponsibilityChainFactory<TParameter, TReturn>
         /// <summary>
         /// Creates a new chain of responsibility.
         /// </summary>
+        /// <param name="serviceProvider">The <see cref="IServiceProvider"/> that middlewares will be resolved from.</param>
         /// <returns>A new instance of a chain.</returns>
-        IResponsibilityChain<TParameter, TReturn> Create();
+        IResponsibilityChain<TParameter, TReturn> Create(IServiceProvider serviceProvider);
     }
 }
diff --git a/src/PipelineNet.ServiceProvider/ChainOfResponsibilityFactories/ResponsibilityChainFactory.cs b/src/PipelineNet.ServiceProvider/ChainOfResponsibilityFactories/ResponsibilityChainFactory.cs
new file mode 100644
index 0000000..7c319f2
--- /dev/null
+++ b/src/PipelineNet.ServiceProvider/ChainOfResponsibilityFactories/ResponsibilityChainFactory.cs
@@ -0,0 +1,20 @@
+using PipelineNet.ChainsOfResponsibility;
+using PipelineNet.ServiceProvider.MiddlewareResolver;
+using System;
+
+namespace PipelineNet.ServiceProvider.ChainOfResponsibilityFactories
+{
+    /// <inheritdoc/>
+    public class ResponsibilityChainFactory<TParameter, TReturn>
+        : IResponsibilityChainFactory<TParameter, TReturn>
+    {
+        /// <inheritdoc/>
+        public IResponsibilityChain<TParameter, TReturn> Create(IServiceProvider serviceProvider)
+        {
+            if (serviceProvider == null) throw new ArgumentNullException("serviceProvider");
+
+            return new ResponsibilityChain<TParameter, TReturn>(
+                new ServiceProviderMiddlewareResolver(serviceProvider));
+        }
+    }
+}
diff --git a/src/PipelineNet.ServiceProvider/MiddlewareResolver/ActivatorUtilitiesMiddlewareResolver.cs b/src/PipelineNet.ServiceProvider/MiddlewareResolver/ActivatorUtilitiesMiddlewareResolver.cs
index 6e2fd95..9439bc2 100644
--- a/src/PipelineNet.ServiceProvider/MiddlewareResolver/ActivatorUtilitiesMiddlewareResolver.cs
+++ b/src/PipelineNet.ServiceProvider/MiddlewareResolver/ActivatorUtilitiesMiddlewareResolver.cs
@@ -6,7 +6,7 @@ namespace PipelineNet.ServiceProvider.MiddlewareResolver
 {
     /// <summary>
     /// An implementation of <see cref="IMiddlewareResolver"/> that creates
-    /// instances using the <see cref="Microsoft.Extensions.DependencyInjection.ActivatorUtilities"/>.
+    /// instances using the <see cref="ActivatorUtilities"/>.
     /// </summary>
     public class ActivatorUtilitiesMiddlewareResolver : IMiddlewareResolver
     {
diff --git a/src/PipelineNet.ServiceProvider/MiddlewareResolver/ServiceProviderMiddlewareResolver.cs b/src/PipelineNet.ServiceProvider/MiddlewareResolver/ServiceProviderMiddlewareResolver.cs
index 19179ae..fad2bc0 100644
--- a/src/PipelineNet.ServiceProvider/MiddlewareResolver/ServiceProviderMiddlewareResolver.cs
+++ b/src/PipelineNet.ServiceProvider/MiddlewareResolver/ServiceProviderMiddlewareResolver.cs
@@ -22,7 +22,11 @@ public ServiceProviderMiddlewareResolver(IServiceProvider serviceProvider)
                 "An instance of IServiceProvider must be provided."); ;
         }
 
-        /// <inheritdoc/>
+        /// <summary>
+        /// Resolves an instance of the give middleware type.
+        /// </summary>
+        /// <param name="type">The middleware type that will be resolved.</param>
+        /// <returns>An instance of the middleware.</returns>
         public MiddlewareResolverResult Resolve(Type type)
         {
             var middleware = _serviceProvider.GetRequiredService(type);
diff --git a/src/PipelineNet.ServiceProvider/PipelineFactories/AsyncPipelineFactory.cs b/src/PipelineNet.ServiceProvider/PipelineFactories/AsyncPipelineFactory.cs
new file mode 100644
index 0000000..5349d18
--- /dev/null
+++ b/src/PipelineNet.ServiceProvider/PipelineFactories/AsyncPipelineFactory.cs
@@ -0,0 +1,20 @@
+using PipelineNet.Pipelines;
+using PipelineNet.ServiceProvider.MiddlewareResolver;
+using System;
+
+namespace PipelineNet.ServiceProvider.PipelineFactories
+{
+    /// <inheritdoc/>
+    public class AsyncPipelineFactory<TParameter>
+        : IAsyncPipelineFactory<TParameter>
+    {
+        /// <inheritdoc/>
+        public IAsyncPipeline<TParameter> Create(IServiceProvider serviceProvider)
+        {
+            if (serviceProvider == null) throw new ArgumentNullException("serviceProvider");
+
+            return new AsyncPipeline<TParameter>(
+                new ServiceProviderMiddlewareResolver(serviceProvider));
+        }
+    }
+}
diff --git a/src/PipelineNet/PipelineFactories/IAsyncPipelineFactory.cs b/src/PipelineNet.ServiceProvider/PipelineFactories/IAsyncPipelineFactory.cs
similarity index 63%
rename from src/PipelineNet/PipelineFactories/IAsyncPipelineFactory.cs
rename to src/PipelineNet.ServiceProvider/PipelineFactories/IAsyncPipelineFactory.cs
index ab93735..00f8b1a 100644
--- a/src/PipelineNet/PipelineFactories/IAsyncPipelineFactory.cs
+++ b/src/PipelineNet.ServiceProvider/PipelineFactories/IAsyncPipelineFactory.cs
@@ -1,6 +1,7 @@
 using PipelineNet.Pipelines;
+using System;
 
-namespace PipelineNet.PipelineFactories
+namespace PipelineNet.ServiceProvider.PipelineFactories
 {
     /// <summary>
     /// Used to create new instances of an asynchronous pipeline.
@@ -11,7 +12,8 @@ public interface IAsyncPipelineFactory<TParameter>
         /// <summary>
         /// Creates a new asynchronous pipeline.
         /// </summary>
+        /// <param name="serviceProvider">The <see cref="IServiceProvider"/> that middlewares will be resolved from.</param>
         /// <returns>A new instance of an asynchronous pipeline.</returns>
-        IAsyncPipeline<TParameter> Create();
+        IAsyncPipeline<TParameter> Create(IServiceProvider serviceProvider);
     }
 }
diff --git a/src/PipelineNet/PipelineFactories/IPipelineFactory.cs b/src/PipelineNet.ServiceProvider/PipelineFactories/IPipelineFactory.cs
similarity index 61%
rename from src/PipelineNet/PipelineFactories/IPipelineFactory.cs
rename to src/PipelineNet.ServiceProvider/PipelineFactories/IPipelineFactory.cs
index d1ea85c..638e7f3 100644
--- a/src/PipelineNet/PipelineFactories/IPipelineFactory.cs
+++ b/src/PipelineNet.ServiceProvider/PipelineFactories/IPipelineFactory.cs
@@ -1,6 +1,7 @@
 using PipelineNet.Pipelines;
+using System;
 
-namespace PipelineNet.PipelineFactories
+namespace PipelineNet.ServiceProvider.PipelineFactories
 {
     /// <summary>
     /// Used to create new instances of a pipeline.
@@ -11,7 +12,8 @@ public interface IPipelineFactory<TParameter>
         /// <summary>
         /// Creates a new pipeline.
         /// </summary>
+        /// <param name="serviceProvider">The <see cref="IServiceProvider"/> that middlewares will be resolved from.</param>
         /// <returns>A new instance of a pipeline.</returns>
-        IPipeline<TParameter> Create();
+        IPipeline<TParameter> Create(IServiceProvider serviceProvider);
     }
 }
diff --git a/src/PipelineNet.ServiceProvider/PipelineFactories/PipelineFactory.cs b/src/PipelineNet.ServiceProvider/PipelineFactories/PipelineFactory.cs
new file mode 100644
index 0000000..a501d46
--- /dev/null
+++ b/src/PipelineNet.ServiceProvider/PipelineFactories/PipelineFactory.cs
@@ -0,0 +1,20 @@
+using PipelineNet.Pipelines;
+using PipelineNet.ServiceProvider.MiddlewareResolver;
+using System;
+
+namespace PipelineNet.ServiceProvider.PipelineFactories
+{
+    /// <inheritdoc/>
+    public class PipelineFactory<TParameter>
+        : IPipelineFactory<TParameter>
+    {
+        /// <inheritdoc/>
+        public IPipeline<TParameter> Create(IServiceProvider serviceProvider)
+        {
+            if (serviceProvider == null) throw new ArgumentNullException("serviceProvider");
+
+            return new Pipeline<TParameter>(
+                new ServiceProviderMiddlewareResolver(serviceProvider));
+        }
+    }
+}
diff --git a/src/PipelineNet.ServiceProvider/ServiceCollectionExtensions.cs b/src/PipelineNet.ServiceProvider/ServiceCollectionExtensions.cs
index 403ccbf..7b60a04 100644
--- a/src/PipelineNet.ServiceProvider/ServiceCollectionExtensions.cs
+++ b/src/PipelineNet.ServiceProvider/ServiceCollectionExtensions.cs
@@ -1,8 +1,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using PipelineNet.Middleware;
-using PipelineNet.MiddlewareResolver;
-using PipelineNet.PipelineFactories;
-using PipelineNet.ServiceProvider.MiddlewareResolver;
+using PipelineNet.ServiceProvider.ChainOfResponsibilityFactories;
+using PipelineNet.ServiceProvider.PipelineFactories;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -16,37 +15,37 @@ namespace PipelineNet.ServiceProvider
     public static class ServiceCollectionExtensions
     {
         /// <summary>
-        /// Adds core PipelineNet services and all middleware from the assemblies.
+        /// Adds pipeline and chain of responsibility factories. Adds all middleware from assemblies.
         /// </summary>
         /// <param name="services">The service collection.</param>
-        /// <param name="assemblies">The assemblies to scan.</param>
-        /// <param name="lifetime">The lifetime of the registered services and middleware.</param>
+        /// <param name="assemblies">Assemblies to scan.</param>
+        /// <param name="lifetime">The lifetime of the registered middleware.</param>
         /// <returns>The service collection.</returns>
         public static IServiceCollection AddPipelineNet(
             this IServiceCollection services,
             IEnumerable<Assembly> assemblies,
-            ServiceLifetime lifetime = ServiceLifetime.Scoped)
+            ServiceLifetime lifetime = ServiceLifetime.Transient)
         {
             if (services == null) throw new ArgumentNullException("services");
             if (assemblies == null) throw new ArgumentNullException("assemblies");
 
-            services.AddPipelineNetCore(lifetime);
-            services.AddMidlewaresFromAssemblies(assemblies, lifetime);
+            services.AddMiddlewareFlowFactories();
+            services.AddMidlewareFromAssemblies(assemblies, lifetime);
 
             return services;
         }
 
         /// <summary>
-        /// Adds core PipelineNet services and all middleware from the assambly.
+        /// Adds pipeline and chain of responsibility factories. Adds all middleware from the assambly.
         /// </summary>
         /// <param name="services">The service collection.</param>
         /// <param name="assembly">The assembly to scan.</param>
-        /// <param name="lifetime">The lifetime of the registered services and middleware.</param>
+        /// <param name="lifetime">The lifetime of the registered middleware.</param>
         /// <returns>The service collection.</returns>
         public static IServiceCollection AddPipelineNet(
             this IServiceCollection services,
             Assembly assembly,
-            ServiceLifetime lifetime = ServiceLifetime.Scoped)
+            ServiceLifetime lifetime = ServiceLifetime.Transient)
         {
             if (services == null) throw new ArgumentNullException("services");
             if (assembly == null) throw new ArgumentNullException("assembly");
@@ -55,44 +54,41 @@ public static IServiceCollection AddPipelineNet(
         }
 
         /// <summary>
-        /// Adds core PipelineNet services.
+        /// Adds pipeline and chain of responsibility factories.
         /// </summary>
         /// <param name="services">The service collection.</param>
-        /// <param name="lifetime">The lifetime of the registered services.</param>
         /// <returns>The service collection.</returns>
-        public static IServiceCollection AddPipelineNetCore(
-            this IServiceCollection services,
-            ServiceLifetime lifetime = ServiceLifetime.Scoped)
+        public static IServiceCollection AddMiddlewareFlowFactories(
+            this IServiceCollection services)
         {
             if (services == null) throw new ArgumentNullException("services");
 
-            services.Add(new ServiceDescriptor(typeof(IMiddlewareResolver), typeof(ServiceProviderMiddlewareResolver), lifetime));
-            services.Add(new ServiceDescriptor(typeof(IPipelineFactory<>), typeof(PipelineFactory<>), lifetime));
-            services.Add(new ServiceDescriptor(typeof(IAsyncPipelineFactory<>), typeof(AsyncPipelineFactory<>), lifetime));
-            services.Add(new ServiceDescriptor(typeof(IResponsibilityChainFactory<,>), typeof(ResponsibilityChainFactory<,>), lifetime));
-            services.Add(new ServiceDescriptor(typeof(IAsyncResponsibilityChainFactory<,>), typeof(AsyncResponsibilityChainFactory<,>), lifetime));
+            services.AddSingleton(typeof(IPipelineFactory<>), typeof(PipelineFactory<>));
+            services.AddSingleton(typeof(IAsyncPipelineFactory<>), typeof(AsyncPipelineFactory<>));
+            services.AddSingleton(typeof(IResponsibilityChainFactory<,>), typeof(ResponsibilityChainFactory<,>));
+            services.AddSingleton(typeof(IAsyncResponsibilityChainFactory<,>), typeof(AsyncResponsibilityChainFactory<,>));
 
             return services;
         }
 
         /// <summary>
-        /// Adds all middleware from the assemblies.
+        /// Adds all middleware from assemblies.
         /// </summary>
         /// <param name="services">The service collection.</param>
-        /// <param name="assemblies">The assemblies to scan.</param>
+        /// <param name="assemblies">Assemblies to scan.</param>
         /// <param name="lifetime">The lifetime of the registered middleware.</param>
         /// <returns>The service collection.</returns>
-        public static IServiceCollection AddMidlewaresFromAssemblies(
+        public static IServiceCollection AddMidlewareFromAssemblies(
             this IServiceCollection services,
             IEnumerable<Assembly> assemblies,
-            ServiceLifetime lifetime = ServiceLifetime.Scoped)
+            ServiceLifetime lifetime = ServiceLifetime.Transient)
         {
             if (services == null) throw new ArgumentNullException("services");
             if (assemblies == null) throw new ArgumentNullException("assemblies");
 
             foreach (var assembly in assemblies)
             {
-                services.AddMidlewaresFromAssembly(assembly, lifetime);
+                services.AddMidlewareFromAssembly(assembly, lifetime);
             }
 
             return services;
@@ -105,10 +101,10 @@ public static IServiceCollection AddMidlewaresFromAssemblies(
         /// <param name="assembly">The assembly to scan.</param>
         /// <param name="lifetime">The lifetime of the registered middleware.</param>
         /// <returns>The service collection.</returns>
-        public static IServiceCollection AddMidlewaresFromAssembly(
+        public static IServiceCollection AddMidlewareFromAssembly(
             this IServiceCollection services,
             Assembly assembly,
-            ServiceLifetime lifetime = ServiceLifetime.Scoped)
+            ServiceLifetime lifetime = ServiceLifetime.Transient)
         {
             if (services == null) throw new ArgumentNullException("services");
             if (assembly == null) throw new ArgumentNullException("assembly");
diff --git a/src/PipelineNet/ChainOfResponsibilityFactories/AsyncResponsibilityChainFactory.cs b/src/PipelineNet/ChainOfResponsibilityFactories/AsyncResponsibilityChainFactory.cs
deleted file mode 100644
index 2b50b22..0000000
--- a/src/PipelineNet/ChainOfResponsibilityFactories/AsyncResponsibilityChainFactory.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-using PipelineNet.ChainsOfResponsibility;
-using PipelineNet.MiddlewareResolver;
-using System;
-
-namespace PipelineNet.PipelineFactories
-{
-    /// <inheritdoc/>
-    public class AsyncResponsibilityChainFactory<TParameter, TReturn>
-        : IAsyncResponsibilityChainFactory<TParameter, TReturn>
-    {
-        private readonly IMiddlewareResolver _middlewareResolver;
-
-        /// <summary>
-        /// Creates a new asynchronous chain of responsibility factory.
-        /// </summary>
-        /// <param name="middlewareResolver">The resolver used to create the middleware types.</param>
-        public AsyncResponsibilityChainFactory(IMiddlewareResolver middlewareResolver)
-        {
-            _middlewareResolver = middlewareResolver ?? throw new ArgumentNullException("middlewareResolver",
-                "An instance of IMiddlewareResolver must be provided.");
-        }
-
-        /// <inheritdoc/>
-        public IAsyncResponsibilityChain<TParameter, TReturn> Create() =>
-            new AsyncResponsibilityChain<TParameter, TReturn>(_middlewareResolver);
-    }
-}
diff --git a/src/PipelineNet/ChainOfResponsibilityFactories/ResponsibilityChainFactory.cs b/src/PipelineNet/ChainOfResponsibilityFactories/ResponsibilityChainFactory.cs
deleted file mode 100644
index 6b264dc..0000000
--- a/src/PipelineNet/ChainOfResponsibilityFactories/ResponsibilityChainFactory.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-using PipelineNet.ChainsOfResponsibility;
-using PipelineNet.MiddlewareResolver;
-using System;
-
-namespace PipelineNet.PipelineFactories
-{
-    /// <inheritdoc/>
-    public class ResponsibilityChainFactory<TParameter, TReturn>
-        : IResponsibilityChainFactory<TParameter, TReturn>
-    {
-        private readonly IMiddlewareResolver _middlewareResolver;
-
-        /// <summary>
-        /// Creates a new chain of responsibility factory.
-        /// </summary>
-        /// <param name="middlewareResolver">The resolver used to create the middleware types.</param>
-        public ResponsibilityChainFactory(IMiddlewareResolver middlewareResolver)
-        {
-            _middlewareResolver = middlewareResolver ?? throw new ArgumentNullException("middlewareResolver",
-                "An instance of IMiddlewareResolver must be provided.");
-        }
-
-        /// <inheritdoc/>
-        public IResponsibilityChain<TParameter, TReturn> Create() =>
-            new ResponsibilityChain<TParameter, TReturn>(_middlewareResolver);
-    }
-}
diff --git a/src/PipelineNet/ChainsOfResponsibility/AsyncResponsibilityChainExtensions.cs b/src/PipelineNet/ChainsOfResponsibility/AsyncResponsibilityChainExtensions.cs
index 6263806..c61f3f3 100644
--- a/src/PipelineNet/ChainsOfResponsibility/AsyncResponsibilityChainExtensions.cs
+++ b/src/PipelineNet/ChainsOfResponsibility/AsyncResponsibilityChainExtensions.cs
@@ -8,7 +8,7 @@ namespace PipelineNet.ChainsOfResponsibility
     public static class AsyncResponsibilityChainExtensions
     {
         /// <summary>
-        /// Throws an <see cref="InvalidOperationException"/> at the end of the chain as a fallback.
+        /// Throws the <see cref="InvalidOperationException"/> at the end of the chain as a fallback.
         /// A chain can only have one finally function. Calling this method
         /// a second time will just replace the existing finally <see cref="Func{TParameter, TResult}"/>.
         /// </summary>
diff --git a/src/PipelineNet/MiddlewareResolver/ActivatorMiddlewareResolver.cs b/src/PipelineNet/MiddlewareResolver/ActivatorMiddlewareResolver.cs
index f9345dd..1dd5deb 100644
--- a/src/PipelineNet/MiddlewareResolver/ActivatorMiddlewareResolver.cs
+++ b/src/PipelineNet/MiddlewareResolver/ActivatorMiddlewareResolver.cs
@@ -4,7 +4,7 @@ namespace PipelineNet.MiddlewareResolver
 {
     /// <summary>
     /// A default implementation of <see cref="IMiddlewareResolver"/> that creates
-    /// instances using the <see cref="System.Activator"/>.
+    /// instances using the <see cref="Activator"/>.
     /// </summary>
     public class ActivatorMiddlewareResolver : IMiddlewareResolver
     {
diff --git a/src/PipelineNet/PipelineFactories/AsyncPipelineFactory.cs b/src/PipelineNet/PipelineFactories/AsyncPipelineFactory.cs
deleted file mode 100644
index fc2f65b..0000000
--- a/src/PipelineNet/PipelineFactories/AsyncPipelineFactory.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-using PipelineNet.MiddlewareResolver;
-using PipelineNet.Pipelines;
-using System;
-
-namespace PipelineNet.PipelineFactories
-{
-    /// <inheritdoc/>
-    public class AsyncPipelineFactory<TParameter>
-        : IAsyncPipelineFactory<TParameter>
-    {
-        private readonly IMiddlewareResolver _middlewareResolver;
-
-        /// <summary>
-        /// Creates a new asynchronous pipeline factory.
-        /// </summary>
-        /// <param name="middlewareResolver">The resolver used to create the middleware types.</param>
-        public AsyncPipelineFactory(IMiddlewareResolver middlewareResolver)
-        {
-            _middlewareResolver = middlewareResolver ?? throw new ArgumentNullException("middlewareResolver",
-                "An instance of IMiddlewareResolver must be provided.");
-        }
-
-        /// <inheritdoc/>
-        public IAsyncPipeline<TParameter> Create() =>
-            new AsyncPipeline<TParameter>(_middlewareResolver);
-    }
-}
diff --git a/src/PipelineNet/PipelineFactories/PipelineFactory.cs b/src/PipelineNet/PipelineFactories/PipelineFactory.cs
deleted file mode 100644
index e2cb54b..0000000
--- a/src/PipelineNet/PipelineFactories/PipelineFactory.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-using PipelineNet.MiddlewareResolver;
-using PipelineNet.Pipelines;
-using System;
-
-namespace PipelineNet.PipelineFactories
-{
-    /// <inheritdoc/>
-    public class PipelineFactory<TParameter>
-        : IPipelineFactory<TParameter>
-    {
-        private readonly IMiddlewareResolver _middlewareResolver;
-
-        /// <summary>
-        /// Creates a new pipeline factory.
-        /// </summary>
-        /// <param name="middlewareResolver">The resolver used to create the middleware types.</param>
-        public PipelineFactory(IMiddlewareResolver middlewareResolver)
-        {
-            _middlewareResolver = middlewareResolver ?? throw new ArgumentNullException("middlewareResolver",
-                "An instance of IMiddlewareResolver must be provided.");
-        }
-
-        /// <inheritdoc/>
-        public IPipeline<TParameter> Create() =>
-            new Pipeline<TParameter>(_middlewareResolver);
-    }
-}