diff --git a/Include/Aurora/Async/IThreadPool.hpp b/Include/Aurora/Async/IThreadPool.hpp
index 0b160980..7bb06455 100644
--- a/Include/Aurora/Async/IThreadPool.hpp
+++ b/Include/Aurora/Async/IThreadPool.hpp
@@ -12,7 +12,6 @@ namespace Aurora::Async
     struct IThreadPool
     {
         // Spawning
-        /// @deprecated
         virtual bool Spawn(WorkerId_t workerId)                                         = 0;
 
         // Event runner threads release the entire application upon encountering a zero work condition allowing for a clean exit of event driven apps without the headache of carefully chaining together exit callbacks
@@ -20,7 +19,7 @@ namespace Aurora::Async
         // tl'dr: runner = true, async app; runner = false, thread pool
         virtual void SetRunningMode(bool eventRunning)                                  = 0;
         
-        // Converts the current thread into an async thread with runner = false
+        // Converts the current thread into an async thread
         // Use with RunOnce, Poll
         virtual bool Create(WorkerId_t workerId)                                        = 0;
         
diff --git a/Include/Aurora/Async/WorkBasic.hpp b/Include/Aurora/Async/WorkBasic.hpp
index d384295d..91b2d46d 100644
--- a/Include/Aurora/Async/WorkBasic.hpp
+++ b/Include/Aurora/Async/WorkBasic.hpp
@@ -24,13 +24,13 @@ namespace Aurora::Async
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, enableWait)->Dispatch();
     }
     
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b, class c, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> 
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b = Job_t, class c, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> 
     static AuSPtr<IWorkItem> NewWork(const WorkerPId_tt &worker, a task, b job, c info, bool enableWait = false)                                       
     {                                                                                                                                                
         return worker.pool->NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job, info), enableWait);                               
     }                                                                                                                                                
                                                                                                                                                      
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b, class c, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> 
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b = Job_t, class c, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> 
     static AuSPtr<IWorkItem> DispatchWork(const WorkerPId_tt &worker, a task, b job, c info, bool enableWait = false)                                  
     {                                                                                                                                                
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, info, enableWait)->Dispatch();                                            
@@ -69,13 +69,13 @@ namespace Aurora::Async
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, enableWait)->Dispatch();
     }
     
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b, class c, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> 
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b = Job_t, class c, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> 
     static AuSPtr<IWorkItem> NewWork(const WorkerId_tt &worker, a task, b job, c info, bool enableWait = false)                                       
     {                                                                                                                                                
         return NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job, info), enableWait);                               
     }                                                                                                                                                
                                                                                                                                                      
-    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b, class c, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> 
+    template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b = Job_t, class c, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> 
     static AuSPtr<IWorkItem> DispatchWork(const WorkerId_tt &worker, a task, b job, c info, bool enableWait = false)                                  
     {                                                                                                                                                
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, info, enableWait)->Dispatch();                                            
@@ -94,7 +94,7 @@ namespace Aurora::Async
     }
 
     template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)>
-    AuSPtr<IWorkItem> DispatchVoid(const WorkerId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
+    AuSPtr<IWorkItem> DispatchVoid(const WorkerId_t &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
     {
         return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromVoidVoid<Info_t, Result_t>(task), job, inputParameters, enableWait);
     }
diff --git a/Source/Console/Commands/Commands.cpp b/Source/Console/Commands/Commands.cpp
index ed5fc364..92a90f9d 100644
--- a/Source/Console/Commands/Commands.cpp
+++ b/Source/Console/Commands/Commands.cpp
@@ -110,7 +110,7 @@ namespace Aurora::Console::Commands
                 {
                     dispatch.callback->OnCommand(dispatch.arguments);
                 }),
-                AuAsync::FJob<CommandDispatch>{},
+                {},
                 CommandDispatch(res.result, callback),
                 false
             );