diff --git a/CMakeLists.txt b/CMakeLists.txt
index 412585b..b09caa9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,8 +18,8 @@ file(GLOB_RECURSE SOURCES
 )
 
 file(GLOB_RECURSE HEADERS
-        "${CMAKE_SOURCE_DIR}/include/vibe/*.h")
-
+        "${CMAKE_SOURCE_DIR}/include/vibe/*.h"
+)
 add_library(vibe STATIC ${SOURCES} ${HEADERS})
 
 install(TARGETS vibe
diff --git a/include/vibe/main_process.h b/include/vibe/main_process.h
deleted file mode 100644
index c9d20b5..0000000
--- a/include/vibe/main_process.h
+++ /dev/null
@@ -1,213 +0,0 @@
-//
-// Created by scythe on 5/07/23.
-//
-
-#ifndef MAIN_PROCESS_H
-#define MAIN_PROCESS_H
-
-#include <stdexcept>
-#include <memory>
-#include <array>
-#include <sys/socket.h>
-#include <sys/epoll.h>
-#include <netinet/in.h>
-#include <unistd.h>
-#include <unordered_map>
-
-#include "util/enums.h"
-#include "util/parameter_proccess.h"
-
-#include "routes.hpp"
-#include "util/request.hpp"
-#include "util/nterminal.h"
-
-
-constexpr int BUFFER = enums::neo::eSize::BUFFER;
-constexpr int SESSION = enums::neo::eSize::SESSION;
-constexpr int INIT_MAX_EVENTS = 10;
-
-namespace workers {
-using RoutesMap = std::unordered_map<string, std::unique_ptr<listen_routes>>;
-
-    template<class T>
-    class pMain_t {
-                       int epoll_fd;
-        unsigned short int next_register;
-
-        std::vector<epoll_event> events;
-        std::shared_ptr<RoutesMap>  routes;
-        std::shared_ptr<T> connection;
-
-    public:
-
-        explicit pMain_t(const std::shared_ptr<T> &conn, const shared_ptr<RoutesMap> &_routes) :
-
-        epoll_fd(epoll_create1(0)),
-        next_register(enums::neo::eSize::DEF_REG),
-
-        events(std::vector<epoll_event>(INIT_MAX_EVENTS)),
-        routes(_routes),
-        connection(conn) {}
-
-        auto getMainProcess(std::shared_ptr<HTTP_QUERY> &qProcess){
-            return [&]()->void {
-                // creacion del socket
-                connection->on();
-                const int file_descriptor = connection->getDescription();
-                constexpr auto socket_len_error_value = static_cast<socklen_t>(-1);
-
-                if(Server::setNonblocking(file_descriptor) == MG_ERROR){
-                    close(file_descriptor);
-                }
-
-                if (epoll_fd == -1) {
-                    throw std::range_error(VB_EPOLL_RANGE);
-                }
-
-                epoll_event event{};
-                event.events = EPOLLIN;
-                event.data.fd = file_descriptor;
-
-                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, file_descriptor, &event) == VB_NVALUE) {
-                    close(epoll_fd);
-                    throw std::range_error(VB_EPOLL_CTL);
-                }
-
-                while (static_cast<bool>(enums::neo::eStatus::START)){
-                    try {
-                        qProcess = make_shared<HTTP_QUERY>();
-
-                        int notice = epoll_wait(epoll_fd, events.data(), INIT_MAX_EVENTS, VB_NVALUE);
-                        if (notice == -1) {
-                            terminal(VB_EPOLL_CERR, strerror(errno));
-                            break;
-                        }
-
-                        for( int i = 0; i < notice; i++) {
-                            if(events[i].data.fd == file_descriptor) {
-
-                                sockaddr_in client_addr{};
-                                socklen_t  client_adrr_len = sizeof(client_addr);
-                                int client_file_descriptor = accept(file_descriptor, reinterpret_cast<sockaddr*>(&client_addr), &client_adrr_len);
-                                if(client_adrr_len == socket_len_error_value) {
-                                    continue;
-                                }
-                                Server::setNonblocking(client_file_descriptor);
-
-                                event.events = EPOLLIN | EPOLLET;
-                                event.data.fd = client_file_descriptor;
-                                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_file_descriptor, &event) == VB_NVALUE) {
-                                    terminal(VB_EPOLL_CERR, strerror(errno));
-                                    close(client_file_descriptor);
-                                    continue;
-                                }
-                            } else {
-
-                                // char buffer[DEF_BUFFER_SIZE] = {0};
-                                std::array<char, DEF_BUFFER_SIZE> buffer{};
-
-                                if (const int bytes = recv(events[i].data.fd, buffer.data(), buffer.size(), VB_OK); bytes == VB_NVALUE) {
-                                    if (errno == EWOULDBLOCK) {
-                                        continue;
-                                    }
-                                    terminal(VB_EPOLL_CERR, strerror(errno));
-                                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, nullptr);
-                                    close(events[i].data.fd);
-                                    continue;
-                                } else if(bytes == VB_OK) {
-                                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, nullptr);
-                                    close(events[i].data.fd);
-                                } else {
-
-                                    shared_ptr<T> base = std::make_shared<T>();
-
-                                    base->setPort(connection->getPort());
-                                    base->setSocketId(events[i].data.fd);
-                                    base->setResponse(buffer);
-                                    base->setEpollEvents(events);
-                                    base->setEpollfd(epoll_fd);
-                                    base->setNotices(notice);
-
-                                    ExecuteRoute(base, qProcess, routes);
-
-                                }
-                            }
-                        }
-                    }
-
-                    catch(const std::exception& e) {
-                       terminal(e.what());
-                        close(epoll_fd);
-                        if(close(file_descriptor) < VB_OK)
-                            throw std::range_error(VB_MAIN_THREAD);
-                    }
-                }
-            };
-
-        }
-
-                 static void ExecuteRoute(const shared_ptr<T> &base,const shared_ptr<HTTP_QUERY>&qProcess, const shared_ptr<RoutesMap> &routes)  {
-
-                                    string send_target = ERROR_GET;
-
-                                     const string socket_response = base->getResponse();
-
-                                        if (socket_response.empty()){
-                                            throw std::range_error(VB_SOCKET_FAIL);
-                                        }
-
-                                    auto [type, route] = HTTP_QUERY::route_refactor(socket_response);
-
-                                        if(const auto itr = routes->find(route + type); itr != routes->end()) {
-
-                                          if(not timeGuard(itr)) {
-
-                                              const string parameters = type == GET_TYPE ?
-                                                    HTTP_QUERY::route_refactor_params_get(socket_response)
-                                                   : HTTP_QUERY::route_refactor_params(socket_response);
-
-                                              auto [data, time_key] = itr->second->middlewares.execute(parameters,
-                                              HTTP_QUERY::headers_from(socket_response),
-                                              itr->second->guardRouteMsg
-                                              );
-
-                                              if(time_key > VB_OK) {
-                                                  itr->second->time_key = time_key;
-                                                  itr->second->time_point = std::chrono::system_clock::now();
-                                              }
-                                              send_target = std::move(data);
-                                          } else {
-                                              send_target = itr->second->guardRouteMsg != nullptr ?
-                                                             utility_t::guard_route(itr->second->time_key, *itr->second->guardRouteMsg)
-                                                            : utility_t::guard_route(itr->second->time_key);
-                                          }
-                                        }
-
-                                        base->sendResponse(send_target);
-
-                                        if (close(base->getDescription()) < enums::neo::eReturn::OK) {
-                                            throw std::range_error(VB_SOCKET_CLOSE);
-                                        }
-            }
-
-
-
-            static bool timeGuard(const RoutesMap::const_iterator & itr) {
-
-                if(itr->second->time_key <= 0)
-                    return false;
-                if(itr->second->time_point == std::chrono::time_point<std::chrono::system_clock>())
-                    return false;
-
-                const auto now = std::chrono::system_clock::now();
-
-                const std::chrono::duration<double> distance = now - itr->second->time_point;
-                return distance.count() < itr->second->time_key;
-            }
-
-
-    };
-}
-
-
-#endif //MAIN_PROCESS_H
diff --git a/include/vibe/request/io.h b/include/vibe/request/io.h
new file mode 100644
index 0000000..68b47fc
--- /dev/null
+++ b/include/vibe/request/io.h
@@ -0,0 +1,61 @@
+//
+// Created by owl on 19/08/24.
+//
+
+#ifndef IO_H
+#define IO_H
+
+#include <memory>
+#include <sys/epoll.h>
+#include <netinet/in.h>
+#include <unordered_map>
+#include <atomic>
+
+#include "../util/enums.h"
+#include "../util/parameter_proccess.h"
+
+#include "../routes.hpp"
+#include "request.hpp"
+#include "../util/nterminal.h"
+#include "../sockets.h"
+#include "../threading/thread_pool.h"
+
+using std::make_shared, std::vector, std::unique_ptr;
+
+using RoutesMap = std::unordered_map<string, std::unique_ptr<listen_routes>>;
+/*
+ *  RequestIO for Server socket class, if you want implement other Server, you should create other RequestIO for the implementation
+ */
+class RequestIO {
+
+    private:
+    shared_ptr<std::vector<epoll_event>> events;
+    shared_ptr<RoutesMap>  routes;
+    unique_ptr<int> file_descriptor;
+    unique_ptr<int> epoll_fd;
+    shared_ptr<Server> connection;
+
+    shared_ptr<threading::ThreadPool> thread_pool_;
+
+    size_t threads_{4};
+
+    void Process(int, epoll_event&) const;
+    void ProcessFileDescriptor(int, int) const;
+
+    public:
+
+     RequestIO(const shared_ptr<vector<epoll_event>>&,
+               const shared_ptr<RoutesMap> &,
+               int &,
+               int &,
+               const shared_ptr<Server>&);
+
+
+    void Dispatch(int id, epoll_event &event) const;
+    void SetThreads(size_t size);
+
+    static bool TimeGuard(const RoutesMap::const_iterator & itr);
+    static void ExecuteRoute(const shared_ptr<Server> &instance, const shared_ptr<RoutesMap> &routes);
+};
+
+#endif //IO_H
diff --git a/include/vibe/util/parameters.hpp b/include/vibe/request/parameters.hpp
similarity index 100%
rename from include/vibe/util/parameters.hpp
rename to include/vibe/request/parameters.hpp
diff --git a/include/vibe/util/request.hpp b/include/vibe/request/request.hpp
similarity index 96%
rename from include/vibe/util/request.hpp
rename to include/vibe/request/request.hpp
index 27c4a0a..3adc384 100644
--- a/include/vibe/util/request.hpp
+++ b/include/vibe/request/request.hpp
@@ -7,7 +7,7 @@
 #include <algorithm>
 #include <memory>
 #include "parameters.hpp"
-#include "sysprocess.h"
+#include "../util/sysprocess.h"
 
 using std::string;
 using std::vector;
diff --git a/include/vibe/request/router_epoll.h b/include/vibe/request/router_epoll.h
new file mode 100644
index 0000000..c2f4107
--- /dev/null
+++ b/include/vibe/request/router_epoll.h
@@ -0,0 +1,84 @@
+//
+// Created by scythe on 5/07/23.
+//
+
+#ifndef MAIN_PROCESS_H
+#define MAIN_PROCESS_H
+
+#include <stdexcept>
+#include <memory>
+#include <sys/epoll.h>
+#include <unistd.h>
+#include <unordered_map>
+
+#include "../util/enums.h"
+#include "../util/parameter_proccess.h"
+
+#include "../routes.hpp"
+#include "../util/nterminal.h"
+#include "io.h"
+
+constexpr int BUFFER = enums::neo::eSize::BUFFER;
+constexpr int SESSION = enums::neo::eSize::SESSION;
+constexpr int INIT_MAX_EVENTS = 10;
+
+namespace workers {
+using RoutesMap = std::unordered_map<string, std::unique_ptr<listen_routes>>;
+
+    template<class T>
+    class RouterEpoll {
+
+        int epoll_fd;
+        shared_ptr<std::vector<epoll_event>> events;
+        shared_ptr<T> connection;
+        shared_ptr<RequestIO> request_t;
+
+    public:
+
+        explicit RouterEpoll(const shared_ptr<T> &conn) :
+        epoll_fd(epoll_create1(0)),
+        events(make_shared<vector<epoll_event>>(INIT_MAX_EVENTS)),
+        connection(conn)
+        {}
+
+        auto getMainProcess(const shared_ptr<RoutesMap> &_routes){
+
+                connection->on();
+                int file_descriptor = connection->getDescription();
+
+                if(Server::setNonblocking(file_descriptor) == MG_ERROR)
+                    close(file_descriptor);
+
+                if (epoll_fd == -1)
+                    throw std::range_error(VB_EPOLL_RANGE);
+
+
+                epoll_event event{};
+                event.events = EPOLLIN;
+                event.data.fd = file_descriptor;
+
+                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, file_descriptor, &event) == VB_NVALUE) {
+                    close(epoll_fd);
+                    throw std::range_error(VB_EPOLL_CTL);
+                }
+
+                request_t = make_shared<RequestIO>(events, _routes, file_descriptor, epoll_fd, connection);
+
+                while (static_cast<bool>(enums::neo::eStatus::START)){
+                    try {
+                        const int notice = epoll_wait(epoll_fd, events->data(), INIT_MAX_EVENTS, VB_NVALUE);
+                        request_t->Dispatch(notice, event);
+                    }
+                    catch(const std::exception& e) {
+                       terminal(e.what());
+                        close(epoll_fd);
+                        if(close(file_descriptor) < VB_OK)
+                            throw std::range_error(VB_MAIN_THREAD);
+                    }
+                }
+        }
+    };
+}
+
+
+#endif //MAIN_PROCESS_H
diff --git a/include/vibe/routes.hpp b/include/vibe/routes.hpp
index c4d34a5..8e2f6df 100644
--- a/include/vibe/routes.hpp
+++ b/include/vibe/routes.hpp
@@ -11,7 +11,7 @@
 #include <future>
 
 
-#include "util/request.hpp"
+#include "request/request.hpp"
 
 #include "util/basic_render.h"
 #include "util/cpp_reader.h"
diff --git a/include/vibe/sockets.h b/include/vibe/sockets.h
index 5902c7b..6b2c752 100644
--- a/include/vibe/sockets.h
+++ b/include/vibe/sockets.h
@@ -7,6 +7,7 @@
 #include <sys/epoll.h>
 #include <arpa/inet.h>
 #include <fcntl.h>
+#include <memory>
 #include <stdexcept>
 
 
@@ -64,10 +65,11 @@ class Engine {
         virtual ~Engine() = default;
 
 
-    [[maybe_unused]] [[nodiscard]] int
+    [[maybe_unused]] int
              setBuffer(int),
-             setPort(uint16_t),
-             getPort() const;
+             setPort(uint16_t);
+
+    [[nodiscard]] int getPort() const;
 
         virtual int on() = 0;
         virtual void getResponseProcessing() = 0;
@@ -102,7 +104,7 @@ class Server final : public Engine {
 
     [[maybe_unused]] [[nodiscard]] inline int getDescription() const {  return *socket_id;  }
     [[maybe_unused]] inline shared_ptr<int> getSocketId() { return socket_id; }
-    [[maybe_unused]] inline void setSocketId(int const identity) { socket_id.reset(new int(identity)); }
+    [[maybe_unused]] inline void setSocketId(int const identity) { socket_id = std::make_shared<int>(identity); }
 
      void setSessions(int);
      void sendResponse(const string&) const;
diff --git a/include/vibe/threading/thread_pool.h b/include/vibe/threading/thread_pool.h
new file mode 100644
index 0000000..d3bef0d
--- /dev/null
+++ b/include/vibe/threading/thread_pool.h
@@ -0,0 +1,45 @@
+#ifndef THREAD_POOL_H
+#define THREAD_POOL_H
+
+#include <mutex>
+#include <condition_variable>
+#include <vector>
+#include <queue>
+#include <atomic>
+#include <functional>
+#include <future>
+#include <thread>
+#include <memory>
+#include "../util/enums.h"
+
+
+namespace threading {
+
+    using std::vector, std::mutex, std::condition_variable, std::atomic, std::queue, std::thread;
+    using std::make_shared, std::shared_ptr, std::packaged_task, std::future;
+
+
+    class ThreadPool {
+
+        vector<thread> threads_;
+        size_t size_;
+
+        queue<std::function<void()>> queue_;
+        atomic<bool> stop_;
+
+        mutex mutex_;
+        condition_variable condition_;
+
+
+    public:
+
+       explicit ThreadPool(size_t threads);
+        ~ThreadPool();
+
+        future<void> addTask(std::function<void()> task);
+
+    };
+
+}
+
+#endif //THREAD_POOL_H
diff --git a/include/vibe/util/parameter_proccess.h b/include/vibe/util/parameter_proccess.h
index 18bbc95..88b5439 100644
--- a/include/vibe/util/parameter_proccess.h
+++ b/include/vibe/util/parameter_proccess.h
@@ -24,7 +24,7 @@ constexpr auto RAW_TARGET = "data=";
 #include <memory>
 #include <string>
 
-#include "request.hpp"
+#include "../request/request.hpp"
 
 using std::string;
 using std::make_shared;
diff --git a/include/vibe/util/worker_core.h b/include/vibe/util/worker_core.h
deleted file mode 100644
index 9bdc8ee..0000000
--- a/include/vibe/util/worker_core.h
+++ /dev/null
@@ -1,21 +0,0 @@
-//
-// Created by scythe on 15/07/23.
-//
-
-#ifndef VIBE_CORE_WORKER_CORE_H
-#define VIBE_CORE_WORKER_CORE_H
-
-#include "../main_process.h"
-
-namespace workers {
-    template <class Template>
-    class eWorkers {
-    public:
-        eWorkers();
-        std::unique_ptr<pMain_t<Template>> Main = nullptr;
-    };
-    template<class Template>
-    eWorkers<Template>::eWorkers() = default;
-}
-
-#endif //VIBE_CORE_WORKER_CORE_H
diff --git a/include/vibe/vibe.h b/include/vibe/vibe.h
index 3f90a38..69fedab 100644
--- a/include/vibe/vibe.h
+++ b/include/vibe/vibe.h
@@ -3,10 +3,8 @@
 
 #include "sockets.h"
 #include "routes.hpp"
-#include "util/request.hpp"
+#include "request/router_epoll.h"
 #include "util/enums.h"
-#include "util/worker_core.h"
-#include <thread>
 #include <memory>
 #include <string>
 
@@ -14,18 +12,14 @@ using std::make_shared;
 using std::make_unique;
 using std::string;
 
-using workers::eWorkers;
 using workers::RoutesMap;
 
 template <class T>
 class Vibe {
 
-    shared_ptr<::eWorkers<T>> eWorkers = nullptr;
-
+    shared_ptr<workers::RouterEpoll<T>> router_epoll;
     shared_ptr<RoutesMap> routes;
-
     std::shared_ptr<T> tcpControl;
-    std::shared_ptr<HTTP_QUERY> qProcess = nullptr;
 
     uint16_t PORT{enums::neo::eSize::DEF_PORT};
 
@@ -132,10 +126,10 @@ template <class T>
 
 template <class T>
 void Vibe<T>::listen() {
-    std::thread _main(eWorkers->Main->getMainProcess(qProcess));
-    _main.join();
+   router_epoll->getMainProcess(routes);
 }
 
+
 template <class T>
 int Vibe<T>::setPort(const uint16_t _port) noexcept {
     if (_port >= enums::neo::eSize::MIN_PORT) {
@@ -157,12 +151,9 @@ void Vibe<T>::tcpInt() {
     tcpControl->setSessions(SESSION);
 
     routes = make_shared<RoutesMap>();
-    eWorkers = make_shared<::eWorkers<T>>();
-    eWorkers->Main =make_unique<workers::pMain_t<T>>(tcpControl, routes);
-
-
+    router_epoll = make_shared<workers::RouterEpoll<T>>(tcpControl);
 }
-using Router = Vibe<Server>;
+using Router  = Vibe<Server>;
 using Convert = utility_t;
 
 
diff --git a/sources/request/io.cpp b/sources/request/io.cpp
new file mode 100644
index 0000000..6da7068
--- /dev/null
+++ b/sources/request/io.cpp
@@ -0,0 +1,160 @@
+#include "../../include/vibe/request/io.h"
+
+RequestIO::RequestIO(const shared_ptr<vector<epoll_event> > &events,
+                     const std::shared_ptr<RoutesMap> &routes,
+                     int &filed,
+                     int &epoll_fd,
+                     const shared_ptr<Server> &con) : events(events),
+                                                      routes(routes),
+                                                      file_descriptor(std::make_unique<int>(filed)),
+                                                      epoll_fd(std::make_unique<int>(epoll_fd)),
+                                                      connection(con) {
+
+    thread_pool_ = make_shared<threading::ThreadPool>(threads_);
+}
+
+
+void RequestIO::Dispatch(const int id, epoll_event &event) const {
+
+   auto task =  thread_pool_->addTask([&]()->void {
+        this->Process(id, event);
+    });
+    task.get();
+
+}
+
+
+void RequestIO::Process(const int id, epoll_event &event) const {
+
+    if (id == -1) {
+        terminal(VB_EPOLL_CERR, strerror(errno));
+        return;
+    }
+
+    constexpr auto socket_len_error_value = static_cast<socklen_t>(-1);
+
+    for (int i = 0; i < id; i++) {
+
+        if (const int event_fd = events->operator[](i).data.fd;
+            event_fd == *file_descriptor
+        ) {
+            sockaddr_in client_addr{};
+            socklen_t client_adrr_len = sizeof(client_addr);
+
+            int client_file_descriptor = accept(*file_descriptor, reinterpret_cast<sockaddr *>(&client_addr),
+                                                &client_adrr_len);
+
+            if (client_adrr_len == socket_len_error_value)
+                continue;
+
+            Server::setNonblocking(client_file_descriptor);
+
+            event.events = EPOLLIN | EPOLLET;
+            event.data.fd = client_file_descriptor;
+
+            if (epoll_ctl(*epoll_fd, EPOLL_CTL_ADD, client_file_descriptor, &event) == VB_NVALUE) {
+                terminal(VB_EPOLL_CERR, strerror(errno));
+                close(client_file_descriptor);
+            }
+
+        } else
+                ProcessFileDescriptor(event_fd, id);
+
+    }
+}
+
+
+
+void RequestIO::ProcessFileDescriptor(const int event_fd, const int notice) const {
+
+    std::array<char, DEF_BUFFER_SIZE> buffer{};
+
+    if (const ssize_t bytes = recv(event_fd, buffer.data(), buffer.size(), VB_OK); bytes == VB_NVALUE) {
+
+        if (errno == EWOULDBLOCK)
+            return;
+
+        terminal(VB_EPOLL_CERR, strerror(errno));
+        epoll_ctl(*epoll_fd, EPOLL_CTL_DEL, event_fd, nullptr);
+        close(event_fd);
+
+    } else if (bytes == VB_OK) {
+
+        epoll_ctl(*epoll_fd, EPOLL_CTL_DEL, event_fd, nullptr);
+        close(event_fd);
+
+    } else {
+        const auto base = std::make_shared<Server>();
+
+        base->setPort(connection->getPort());
+        base->setSocketId(event_fd);
+        base->setResponse(buffer);
+        base->setEpollEvents(*events);
+        base->setEpollfd(*epoll_fd);
+        base->setNotices(notice);
+
+        ExecuteRoute(base, routes);
+    }
+}
+
+
+
+
+
+void RequestIO::ExecuteRoute(const shared_ptr<Server> &instance, const shared_ptr<RoutesMap> &routes) {
+    string send_target = ERROR_GET;
+
+    const string socket_response = instance->getResponse();
+    if (socket_response.empty()) throw std::range_error(VB_SOCKET_FAIL);
+
+
+    auto [type, route] = HTTP_QUERY::route_refactor(socket_response);
+
+    if (const auto itr = routes->find(route + type); itr != routes->end()) {
+        if (not TimeGuard(itr)) {
+            const string parameters = type == GET_TYPE
+                                          ? HTTP_QUERY::route_refactor_params_get(socket_response)
+                                          : HTTP_QUERY::route_refactor_params(socket_response);
+
+            auto [data, time_key] = itr->second->middlewares.execute(parameters,
+                                                                     HTTP_QUERY::headers_from(socket_response),
+                                                                     itr->second->guardRouteMsg
+            );
+
+            if (time_key > VB_OK) {
+                itr->second->time_key = time_key;
+                itr->second->time_point = std::chrono::system_clock::now();
+            }
+            send_target = std::move(data);
+        } else
+            send_target = itr->second->guardRouteMsg != nullptr
+                              ? utility_t::guard_route(itr->second->time_key, *itr->second->guardRouteMsg)
+                              : utility_t::guard_route(itr->second->time_key);
+    }
+
+
+    instance->sendResponse(send_target);
+
+    if (close(instance->getDescription()) < enums::neo::eReturn::OK) {
+        throw std::range_error(VB_SOCKET_CLOSE);
+    }
+}
+
+
+bool RequestIO::TimeGuard(const RoutesMap::const_iterator &itr) {
+    if (itr->second->time_key <= 0)
+        return false;
+    if (itr->second->time_point == std::chrono::time_point<std::chrono::system_clock>())
+        return false;
+
+    const auto now = std::chrono::system_clock::now();
+
+    const std::chrono::duration<double> distance = now - itr->second->time_point;
+    return distance.count() < itr->second->time_key;
+}
+
+
+void RequestIO::SetThreads(size_t size) {
+    thread_pool_ = make_shared<threading::ThreadPool>(size);
+}
+
diff --git a/sources/parameters.cpp b/sources/request/parameters.cpp
similarity index 94%
rename from sources/parameters.cpp
rename to sources/request/parameters.cpp
index 810050e..cc91d24 100644
--- a/sources/parameters.cpp
+++ b/sources/request/parameters.cpp
@@ -1,4 +1,4 @@
-#include "../include/vibe/util/parameters.hpp"
+#include "../../include/vibe/request/parameters.hpp"
 
 #include <algorithm>
 #include <utility>
diff --git a/sources/request.cpp b/sources/request/request.cpp
similarity index 97%
rename from sources/request.cpp
rename to sources/request/request.cpp
index 52a19ca..12d75cd 100644
--- a/sources/request.cpp
+++ b/sources/request/request.cpp
@@ -1,4 +1,4 @@
-#include "../include/vibe/util/request.hpp"
+#include "../../include/vibe/request/request.hpp"
 
 Request::Request()= default;
 
diff --git a/sources/routes.cpp b/sources/request/routes.cpp
similarity index 98%
rename from sources/routes.cpp
rename to sources/request/routes.cpp
index 89e7b89..3b4bc3b 100644
--- a/sources/routes.cpp
+++ b/sources/request/routes.cpp
@@ -1,4 +1,4 @@
-#include "../include/vibe/routes.hpp"
+#include "../../include/vibe/routes.hpp"
 
 
 string  Query::getData() const noexcept                   {     return last;     }
diff --git a/sources/threading/thread_pool.cpp b/sources/threading/thread_pool.cpp
new file mode 100644
index 0000000..1c57fa4
--- /dev/null
+++ b/sources/threading/thread_pool.cpp
@@ -0,0 +1,58 @@
+#include "../../include/vibe/threading/thread_pool.h"
+
+using namespace threading;
+
+ThreadPool::ThreadPool(const size_t threads) : size_(threads), stop_(false) {
+
+  for (size_t i = 0; i < threads; i++) {
+
+    threads_.emplace_back([this]() {
+
+       while(static_cast<bool>(enums::neo::eStatus::START)){
+
+         std::function<void()> task;
+
+         {
+               std::unique_lock<std::mutex> lock(mutex_);
+               this->condition_.wait(lock, [this] { return this->stop_ || !this->queue_.empty();});
+
+               if(this->stop_ && this->queue_.empty())
+                 return;
+
+               task = std::move(this->queue_.front());
+               this->queue_.pop();
+         }
+
+         task();
+
+       }
+    });
+  }
+}
+
+ThreadPool::~ThreadPool() {
+
+    stop_.store(true);
+
+    for(thread &thread : threads_)
+      thread.join();
+}
+
+
+future<void> ThreadPool::addTask(std::function<void()> task) {
+
+  const auto task_ptr = std::make_shared<packaged_task<void()>>(std::move(task));
+
+  std::future<void> future = task_ptr->get_future();
+
+  {
+    std::unique_lock<std::mutex> lock(mutex_);
+    if(stop_.load())
+      throw std::runtime_error("ThreadPool::addTask: stopped");
+
+    queue_.emplace([task_ptr]() { (*task_ptr)(); });
+  }
+
+  condition_.notify_one();
+  return future;
+}
\ No newline at end of file