diff --git a/Classes/Job/ConfigurationFactory.php b/Classes/Job/ConfigurationFactory.php
index 74187bb..6640b29 100644
--- a/Classes/Job/ConfigurationFactory.php
+++ b/Classes/Job/ConfigurationFactory.php
@@ -8,6 +8,8 @@
 use Neos\Flow\Configuration\ConfigurationManager;
 use Neos\Flow\Core\Booting\Scripts;
 use Neos\Utility\ObjectAccess;
+use Netlogix\JobQueue\Pool\ProcessFactory;
+
 use function defined;
 use function preg_replace;
 use function rtrim;
@@ -59,16 +61,7 @@ public function buildJobConfiguration(string $queueName): array
             ConfigurationManager::CONFIGURATION_TYPE_SETTINGS,
             'Neos.Flow'
         );
-
-        $command = Scripts::buildPhpCommand(
-            $flowSettings
-        );
-        $command .= sprintf(
-            ' %s %s --queue=%s',
-            escapeshellarg(\FLOW_PATH_FLOW . 'Scripts/flow.php'),
-            escapeshellarg('flowpack.jobqueue.common:job:execute'),
-            escapeshellarg($queueName)
-        );
+        $command = (new ProcessFactory)->buildSubprocessCommand();
 
         $workerPool = (array)$this->configurationManager->getConfiguration(
             ConfigurationManager::CONFIGURATION_TYPE_SETTINGS,
diff --git a/Classes/Lock.php b/Classes/Lock.php
index 16b5c42..75c31b0 100644
--- a/Classes/Lock.php
+++ b/Classes/Lock.php
@@ -30,6 +30,11 @@ public function __construct(int $numberOfWorkers, string $lockFileDirectory)
         }
     }
 
+    /**
+     * @template T
+     * @param callable(): T $run
+     * @return T
+     */
     public function run(callable $run)
     {
         $this->findSlot();
diff --git a/Classes/Loop.php b/Classes/Loop.php
index 89fd1fe..3509eab 100644
--- a/Classes/Loop.php
+++ b/Classes/Loop.php
@@ -1,57 +1,86 @@
 <?php
+
 declare(strict_types=1);
 
 namespace Netlogix\JobQueue\FastRabbit;
 
 use Neos\Flow\Annotations as Flow;
+use Netlogix\JobQueue\Pool\Pool;
 use PhpAmqpLib\Exception\AMQPTimeoutException;
 use t3n\JobQueue\RabbitMQ\Queue\RabbitQueue;
 
-/**
- * @Flow\Proxy(false)
- */
+use function count;
+use function max;
+
+#[Flow\Proxy(false)]
 final class Loop
 {
-    protected $queue;
-
-    /**
-     * Unix timestamp after which the Loop should exit
-     *
-     * @var int|null
-     */
-    protected $exitAfterTimestamp;
-
-    /**
-     * Timeout in seconds when waiting for new messages
-     *
-     * @var int|null
-     */
-    protected $timeout;
-
-    /**
-     * @param RabbitQueue $queue The Queue to watch
-     * @param int $exitAfter Time in seconds after which the loop should exit
-     */
-    public function __construct(RabbitQueue $queue, int $exitAfter = 0)
-    {
-        $this->queue = $queue;
-        $this->exitAfterTimestamp = $exitAfter > 0 ? time() + $exitAfter : null;
-        $this->timeout = $exitAfter > 0 ? $exitAfter : null;
+    public const int SIX_HOURS_IN_SECONDS = 21600;
+
+    public function __construct(
+        /**
+         * The Queue to watch
+         */
+        protected RabbitQueue $queue,
+
+        protected readonly Pool $poolObject,
+
+        /**
+         * Time in seconds after which the loop should exit
+         */
+        protected readonly ?int $exitAfter
+    ) {
     }
 
     public function runMessagesOnWorker(Worker $worker)
     {
-        $worker->prepare();
-        do {
-            try {
-                $message = $this->queue->waitAndReserve($this->timeout);
-                $worker->executeMessage($message);
-            } catch (AMQPTimeoutException $e) {
-            }
+        $this
+            ->poolObject
+            ->runLoop(function (Pool $pool) use ($worker) {
+                $worker->prepare();
+
+                $runDueJobs = $pool->eventLoop->addPeriodicTimer(
+                    interval: 0.01,
+                    callback: fn () => $this->runDueJob($pool, $worker)
+                );
 
-            if ($this->exitAfterTimestamp !== null && time() >= $this->exitAfterTimestamp) {
-                break;
+                if ($this->exitAfter) {
+                    $pool->eventLoop->addTimer(
+                        interval: max($this->exitAfter, 1),
+                        callback: function () use ($pool, $runDueJobs) {
+                            $pool->eventLoop->cancelTimer($runDueJobs);
+                            $checkForPoolToClear = $pool->eventLoop->addPeriodicTimer(
+                                interval: 1,
+                                callback: function () use ($pool, &$checkForPoolToClear) {
+                                    if (count($pool) === 0) {
+                                        $pool->eventLoop->cancelTimer($checkForPoolToClear);
+                                        $pool->eventLoop->stop();
+                                    }
+                                }
+                            );
+                        }
+                    );
+                }
+            });
+    }
+
+    private function runDueJob(Pool $pool, Worker $worker): void
+    {
+        /**
+         * No parallel execution of multiple messages here, create multiple
+         * fast rabbit instances connected instead.
+         * Counting the running instances in the pool only prevents the
+         * pool from spawning too many workers.
+         */
+        if (count($pool)) {
+            return;
+        }
+        try {
+            $message = $this->queue->waitAndReserve(10);
+            if ($message) {
+                $pool->eventLoop->futureTick(fn () => $worker->executeMessage($message));
             }
-        } while (true);
+        } catch (AMQPTimeoutException $e) {
+        }
     }
 }
diff --git a/Classes/Package.php b/Classes/Package.php
new file mode 100644
index 0000000..e730447
--- /dev/null
+++ b/Classes/Package.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Netlogix\JobQueue\FastRabbit;
+
+use Neos\Flow\Core\Bootstrap;
+use Neos\Flow\Monitor\FileMonitor;
+use Neos\Flow\ObjectManagement\CompileTimeObjectManager;
+use Neos\Flow\ObjectManagement\ObjectManagerInterface;
+use Neos\Flow\ObjectManagement\Proxy\Compiler;
+use Neos\Flow\Package\Package as BasePackage;
+use Neos\Flow\SignalSlot\Dispatcher;
+use Netlogix\JobQueue\FastRabbit\SingletonPreloading\AllSingletonsPreloader;
+
+final class Package extends BasePackage
+{
+    public function boot(Bootstrap $bootstrap): void
+    {
+        $dispatcher = $bootstrap->getSignalSlotDispatcher();
+        assert($dispatcher instanceof Dispatcher);
+
+        /**
+         * @see Compiler::compiledClasses()
+         * @see FileMonitor::emitFilesHaveChanged()
+         * @see AllSingletonsPreloader::flush()
+         */
+        $dispatcher->connect(
+            signalClassName: FileMonitor::class,
+            signalName: 'filesHaveChanged',
+            slotClassNameOrObject: fn () => static::flushSingletonsPreloaderCache($bootstrap->getObjectManager())
+        );
+    }
+
+    private function flushSingletonsPreloaderCache(ObjectManagerInterface $objectManager): void
+    {
+        if ($objectManager instanceof CompileTimeObjectManager) {
+            return;
+        }
+        $objectManager
+            ->get(AllSingletonsPreloader::CACHE)
+            ->flush();
+    }
+}
diff --git a/Classes/PreventLoggingOfMissingInput/JobCommandInitializationAspect.php b/Classes/PreventLoggingOfMissingInput/JobCommandInitializationAspect.php
new file mode 100644
index 0000000..c193d66
--- /dev/null
+++ b/Classes/PreventLoggingOfMissingInput/JobCommandInitializationAspect.php
@@ -0,0 +1,51 @@
+<?php
+
+namespace Netlogix\JobQueue\FastRabbit\PreventLoggingOfMissingInput;
+
+use Flowpack\JobQueue\Common\Command\JobCommandController;
+use Neos\Flow\Annotations as Flow;
+use Neos\Flow\Aop\JoinPointInterface;
+use Neos\Flow\Cli\Exception\StopCommandException;
+use Neos\Flow\Reflection\ClassReflection;
+use Symfony\Component\Console\Exception\MissingInputException;
+
+/**
+ * There might be orphaned worker processes when the parent process
+ * of FastRabbit loop restarts due to its max wait time.
+ *
+ * Those are still waiting for message identifiers, which can never
+ * be fulfilled once their STDIN closes, so a MissingInputException
+ * gets thrown.
+ *
+ * This is expected and will happen every 6 hours due to the current
+ * configuration. We don't need those exceptions tracked. So redirect
+ * to StopCommandException instead.
+ */
+#[Flow\Aspect]
+#[Flow\Proxy(false)]
+class JobCommandInitializationAspect
+{
+    #[Flow\Around('within(' . JobCommandController::class . ') && method(.*->mapRequestArgumentsToControllerArguments())')]
+    public function preventLoggingOfMissingInputExceptions(JoinPointInterface $joinPoint): void
+    {
+        $jobCommandController = $joinPoint->getProxy();
+        assert($jobCommandController instanceof JobCommandController);
+
+        $reflection = new ClassReflection($jobCommandController);
+
+        $commandMethodName = $reflection
+            ->getProperty('commandMethodName')
+            ->getValue($jobCommandController);
+
+        if ($commandMethodName !== 'executeCommand') {
+            $joinPoint->getAdviceChain()->proceed($joinPoint);
+            return;
+        }
+
+        try {
+            $joinPoint->getAdviceChain()->proceed($joinPoint);
+        } catch (MissingInputException $e) {
+            throw new StopCommandException();
+        }
+    }
+}
diff --git a/Classes/SingletonPreloading/AllSingletonsPreloader.php b/Classes/SingletonPreloading/AllSingletonsPreloader.php
new file mode 100644
index 0000000..7993000
--- /dev/null
+++ b/Classes/SingletonPreloading/AllSingletonsPreloader.php
@@ -0,0 +1,154 @@
+<?php
+
+namespace Netlogix\JobQueue\FastRabbit\SingletonPreloading;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\ORM\EntityManagerInterface;
+use Neos\Cache\Frontend\VariableFrontend;
+use Neos\Flow\ObjectManagement\Configuration\Configuration;
+use Neos\Flow\ObjectManagement\ObjectManager;
+use Neos\Flow\ObjectManagement\ObjectManagerInterface;
+use Neos\Flow\Reflection\ReflectionService;
+use Neos\Flow\Annotations as Flow;
+use Throwable;
+use Traversable;
+
+use function class_exists;
+use function is_a;
+
+/**
+ * Fetch all known singleton classes from the ObjectManager to have
+ * all of them in the memory and ready to use.
+ *
+ * This should not be used "as is" because there's a high risk of
+ * creating singletons with expiring connections, like, for example,
+ * database connections.
+ *
+ * It's not enough to just exclude those database connections here
+ * because there might be other singletons depending on those connections
+ * through constructor injection, which triggers loading them anyway.
+ */
+class AllSingletonsPreloader implements SingletonsPreloader
+{
+    public const string CACHE = 'Netlogix.JobQueue.FakeQueue:SingletonPreloaderCache';
+
+    #[Flow\InjectConfiguration(path: 'AllSingletonsPreloader.ignoreClassNames', package: 'Netlogix.JobQueue.FastRabbit')]
+    protected array $ignoreClassNames = [];
+
+    #[Flow\Inject(name: AllSingletonsPreloader::CACHE, lazy: false)]
+    protected VariableFrontend $cache;
+
+    #[Flow\Inject(lazy: false)]
+    protected ObjectManager $objectManager;
+
+    #[Flow\Inject(lazy: false)]
+    protected ReflectionService $reflectionService;
+
+    public function collect(): void
+    {
+        foreach ($this->getClassList() as $className => $buildInstance) {
+            $this->preload(className: $className, buildInstance: $buildInstance);
+        }
+        $this->pauseExpiringObjects();
+    }
+
+    /**
+     * @return array<string, bool>
+     */
+    protected function getClassList(): array
+    {
+        if ($this->cache->has('classList')) {
+            return $this->cache->get('classList');
+        } else {
+            $list = [... $this->buildClassList()];
+            $this->cache->set('classList', $list);
+            return $list;
+        }
+    }
+
+    protected function preload(string $className, bool $buildInstance): void
+    {
+        try {
+            $buildInstance
+                ? $this->objectManager->get($className)
+                : class_exists(class: $className, autoload: true);
+        } catch (Throwable) {
+            // ignore
+        }
+    }
+
+    protected function pauseExpiringObjects()
+    {
+        if ($this->objectManager->has(EntityManagerInterface::class)) {
+            $this->objectManager
+                ->get(EntityManagerInterface::class)
+                ->getConnection()
+                ->close();
+        }
+        if ($this->objectManager->has(Connection::class)) {
+            $this->objectManager
+                ->get(Connection::class)
+                ->close();
+        }
+        // TODO: There are other objects that might expire, for example ´
+    }
+
+    /**
+     * @return Traversable<string, bool>
+     */
+    protected function buildClassList(): Traversable
+    {
+        foreach (self::getSingletonClassNamesFromReflection($this->objectManager) as $className => $buildInstance) {
+            yield $className => $buildInstance && !$this->ignoreClassName($className);
+        }
+    }
+
+    protected function ignoreClassName(string $className): bool
+    {
+        foreach ($this->ignoreClassNames as $ignoredClassName) {
+            if (is_a($className, $ignoredClassName, true)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @return array<string, bool>
+     */
+    #[Flow\CompileStatic]
+    public static function getSingletonClassNamesFromReflection(ObjectManagerInterface $objectManager): array
+    {
+        $reflection = $objectManager->get(ReflectionService::class);
+        assert($reflection instanceof ReflectionService);
+        $classNames = [];
+        foreach ($reflection->getAllClassNames() as $className) {
+            try {
+                if ($objectManager->getScope($className) !== Configuration::SCOPE_SINGLETON) {
+                    /**
+                     * Only preload singletons
+                     */
+                    $classNames[$className] = false;
+                    continue;
+                }
+            } catch (\Exception $e) {
+                $classNames[$className] = false;
+                continue;
+            }
+
+            $constructParameters = $reflection->getMethodParameters($className, '__construct');
+            if (count($constructParameters)) {
+                /**
+                 * Skip preloading for classes with constructor arguments because they are
+                 * likely to depend on stateful objects that, in one way or other, expire,
+                 * like database connections.
+                 */
+                $classNames[$className] = false;
+            } else {
+                $classNames[$className] = true;
+            }
+        }
+
+        return $classNames;
+    }
+}
diff --git a/Classes/SingletonPreloading/JobCommandInitializationAspect.php b/Classes/SingletonPreloading/JobCommandInitializationAspect.php
new file mode 100644
index 0000000..d4a6acd
--- /dev/null
+++ b/Classes/SingletonPreloading/JobCommandInitializationAspect.php
@@ -0,0 +1,58 @@
+<?php
+
+namespace Netlogix\JobQueue\FastRabbit\SingletonPreloading;
+
+use Flowpack\JobQueue\Common\Command\JobCommandController;
+use Neos\Flow\Annotations as Flow;
+use Neos\Flow\Aop\JoinPointInterface;
+use Neos\Flow\Cli\Request;
+use Neos\Flow\Mvc\Controller;
+use Neos\Flow\ObjectManagement\ObjectManagerInterface;
+use Neos\Flow\Reflection\ClassReflection;
+
+#[Flow\Aspect]
+class JobCommandInitializationAspect
+{
+    public function __construct(
+        protected readonly ObjectManagerInterface $objectManager
+    ) {
+    }
+
+    #[Flow\AfterReturning('within(' . JobCommandController::class . ') && method(.*->initializeCommandMethodArguments())')]
+    public function preloadSingletonsWhenJobCommandControllerGetsInitialized(JoinPointInterface $joinPoint): void
+    {
+        $jobCommandController = $joinPoint->getProxy();
+        assert($jobCommandController instanceof JobCommandController);
+
+        $reflection = new ClassReflection($jobCommandController);
+
+        $commandMethodName = $reflection
+            ->getProperty('commandMethodName')
+            ->getValue($jobCommandController);
+
+        if ($commandMethodName !== 'executeCommand') {
+            return;
+        }
+
+        $request = $reflection
+            ->getProperty('request')
+            ->getValue($jobCommandController);
+        assert($request instanceof Request);
+
+        $arguments = $reflection
+            ->getProperty('arguments')
+            ->getValue($jobCommandController);
+        assert($arguments instanceof Controller\Arguments);
+
+        foreach ($arguments as $argument) {
+            assert($argument instanceof Controller\Argument);
+            if ($argument->isRequired() && !$request->hasArgument($argument->getName())) {
+                // only preload if the request is blocked by fetching an argument via stdin
+                $this->objectManager
+                    ->get(SingletonsPreloader::class)
+                    ->collect();
+                return;
+            }
+        }
+    }
+}
diff --git a/Classes/SingletonPreloading/NoneSingletonsPreloader.php b/Classes/SingletonPreloading/NoneSingletonsPreloader.php
new file mode 100644
index 0000000..8dea0be
--- /dev/null
+++ b/Classes/SingletonPreloading/NoneSingletonsPreloader.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace Netlogix\JobQueue\FastRabbit\SingletonPreloading;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\ORM\EntityManagerInterface;
+use Neos\Cache\Frontend\VariableFrontend;
+use Neos\Flow\ObjectManagement\Configuration\Configuration;
+use Neos\Flow\ObjectManagement\ObjectManager;
+use Neos\Flow\ObjectManagement\ObjectManagerInterface;
+use Neos\Flow\Reflection\ReflectionService;
+use Neos\Flow\Annotations as Flow;
+use Throwable;
+use Traversable;
+
+use function class_exists;
+use function is_a;
+
+/**
+ * Fetch all known singleton classes from the ObjectManager to have
+ * all of them in the memory and ready to use.
+ *
+ * This should not be used "as is" because there's a high risk of
+ * creating singletons with expiring connections, like, for example,
+ * database connections.
+ *
+ * It's not enough to just exclude those database connections here
+ * because there might be other singletons depending on those connections
+ * through constructor injection, which triggers loading them anyway.
+ */
+final class NoneSingletonsPreloader implements SingletonsPreloader
+{
+    public function collect(): void
+    {
+    }
+
+}
diff --git a/Classes/SingletonPreloading/SingletonsPreloader.php b/Classes/SingletonPreloading/SingletonsPreloader.php
new file mode 100644
index 0000000..da1df7d
--- /dev/null
+++ b/Classes/SingletonPreloading/SingletonsPreloader.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Netlogix\JobQueue\FastRabbit\SingletonPreloading;
+
+interface SingletonsPreloader
+{
+    public function collect(): void;
+}
diff --git a/Classes/Worker.php b/Classes/Worker.php
index 0709622..cdcc7f9 100644
--- a/Classes/Worker.php
+++ b/Classes/Worker.php
@@ -1,4 +1,5 @@
 <?php
+
 declare(strict_types=1);
 
 namespace Netlogix\JobQueue\FastRabbit;
@@ -6,124 +7,81 @@
 use Flowpack\JobQueue\Common\Job\JobManager;
 use Flowpack\JobQueue\Common\Queue\Message;
 use Neos\Cache\Frontend\FrontendInterface;
-use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Cli\ConsoleOutput;
+use Netlogix\JobQueue\Pool\Pool;
+use React\ChildProcess\Process;
 use t3n\JobQueue\RabbitMQ\Queue\RabbitQueue;
 
-/**
- * @Flow\Proxy(false)
- */
+use function sha1;
+
 final class Worker
 {
-    /**
-     * @var string
-     */
-    protected $command;
-
-    /**
-     * @var RabbitQueue
-     */
-    protected $queue;
-
-    /**
-     * @var array
-     */
-    protected $queueSettings;
-
-    /**
-     * @var FrontendInterface
-     */
-    protected $messageCache;
-
-    /**
-     * @var ConsoleOutput
-     */
-    protected $output;
-
-    /**
-     * @var Lock
-     */
-    private $lock;
+    protected readonly ConsoleOutput $output;
 
     public function __construct(
-        string $command,
-        RabbitQueue $queue,
-        array $queueSettings,
-        FrontendInterface $messageCache,
-        Lock $lock
+        protected readonly string $command,
+        protected readonly Pool $poolObject,
+        protected readonly RabbitQueue $queue,
+        protected readonly array $queueSettings,
+        protected readonly FrontendInterface $messageCache,
+        protected readonly Lock $lock
     ) {
-        $this->command = $command;
-        $this->queue = $queue;
-        $this->queueSettings = $queueSettings;
-        $this->messageCache = $messageCache;
-        $this->lock = $lock;
     }
 
-    public function prepare()
+    public function prepare(): void
     {
         $this->output = new ConsoleOutput();
-        $this->outputLine('Watching queue <b>"%s"</b>', $this->queue->getName());
+        $this->output->outputLine('Watching queue <b>"%s"</b>', [$this->queue->getName()]);
     }
 
-    public function executeMessage(Message $message)
+    public function executeMessage(Message $message): void
     {
         $messageCacheIdentifier = sha1(serialize($message));
         $this->messageCache->set($messageCacheIdentifier, $message);
 
-        $this->lock->run(function() use (&$messageCacheIdentifier, &$commandOutput, &$result) {
-            exec(
-                $this->command . ' --messageCacheIdentifier=' . escapeshellarg($messageCacheIdentifier),
-                $commandOutput,
-                $result
-            );
-        });
+        $process = $this->lock->run(
+            fn () => $this->poolObject->runPayload(payload: $message->getPayload(), queueName: $this->queue->getName()),
+        );
+        assert($process instanceof Process);
 
-        if ($result === 0) {
+        $process->on(Pool::EVENT_SUCCESS, function () use ($message) {
             $this->queue->finish($message->getIdentifier());
-            $this->outputLine(
-                '<success>Successfully executed job "%s" (%s)</success>',
-                $message->getIdentifier(),
-                join('', $commandOutput)
+            $this->output->outputLine(
+                '<success>Successfully executed job "%s"</success>',
+                [$message->getIdentifier()]
             );
+        });
 
-        } else {
+        $process->on(Pool::EVENT_ERROR, function () use ($message) {
             $maximumNumberOfReleases = isset($this->queueSettings['maximumNumberOfReleases'])
-                ? (int)$this->queueSettings['maximumNumberOfReleases']
+                ? (int) $this->queueSettings['maximumNumberOfReleases']
                 : JobManager::DEFAULT_MAXIMUM_NUMBER_RELEASES;
 
             if ($message->getNumberOfReleases() < $maximumNumberOfReleases) {
                 $releaseOptions = isset($this->queueSettings['releaseOptions']) ? $this->queueSettings['releaseOptions'] : [];
                 $this->queue->release($message->getIdentifier(), $releaseOptions);
                 $this->queue->reQueueMessage($message, $releaseOptions);
-                $this->outputLine(
-                    'Job execution for job (message: "%s", queue: "%s") failed (%d/%d trials) - RELEASE',
-                    $message->getIdentifier(),
-                    $this->queue->getName(),
-                    $message->getNumberOfReleases() + 1,
-                    $maximumNumberOfReleases + 1
+                $this->output->outputLine(
+                    '<error>Job execution for job (message: "%s", queue: "%s") failed (%d/%d trials) - RELEASE</error>',
+                    [
+                        $message->getIdentifier(),
+                        $this->queue->getName(),
+                        $message->getNumberOfReleases() + 1,
+                        $maximumNumberOfReleases + 1,
+                    ]
                 );
-                $this->outputLine('<error>Message: %s</error>', join('', $commandOutput));
-
             } else {
                 $this->queue->abort($message->getIdentifier());
-                $this->outputLine(
-                    'Job execution for job (message: "%s", queue: "%s") failed (%d/%d trials) - ABORTING',
-                    $message->getIdentifier(),
-                    $this->queue->getName(),
-                    $message->getNumberOfReleases() + 1,
-                    $maximumNumberOfReleases + 1
+                $this->output->outputLine(
+                    '<error>Job execution for job (message: "%s", queue: "%s") failed (%d/%d trials) - ABORTING</error>',
+                    [
+                        $message->getIdentifier(),
+                        $this->queue->getName(),
+                        $message->getNumberOfReleases() + 1,
+                        $maximumNumberOfReleases + 1,
+                    ]
                 );
-                $this->outputLine('<error>Message: %s</error>', join('', $commandOutput));
             }
-        }
-
-        if ($messageCacheIdentifier !== null) {
-            $this->messageCache->remove($messageCacheIdentifier);
-        }
-    }
-
-    protected function outputLine(string $text, ...$arguments)
-    {
-        $this->output->outputLine($text, $arguments);
+        });
     }
 }
diff --git a/Configuration/Caches.yaml b/Configuration/Caches.yaml
new file mode 100644
index 0000000..1037265
--- /dev/null
+++ b/Configuration/Caches.yaml
@@ -0,0 +1,3 @@
+Netlogix_JobQueue_FastRabbit_SingletonPreloaderCache:
+  frontend: Neos\Cache\Frontend\VariableFrontend
+  backend:  Neos\Cache\Backend\SimpleFileBackend
diff --git a/Configuration/Objects.yaml b/Configuration/Objects.yaml
new file mode 100644
index 0000000..9244cc8
--- /dev/null
+++ b/Configuration/Objects.yaml
@@ -0,0 +1,28 @@
+'Netlogix\JobQueue\FastRabbit\SingletonPreloading\SingletonsPreloader':
+
+  # Don't create any singleton instances by default. This cautious setting completely
+  # avoids creating "expiring" singleton instances, like doctrine DBAL connections,
+  # during the preloading phase.
+
+  className: Netlogix\JobQueue\FastRabbit\SingletonPreloading\NoneSingletonsPreloader
+
+
+  # Create "all" singletons. Those with constructor argument injection are excluded
+  # to avoid the before-mentioned Doctrine DBAL, which comes through the EntityManager.
+  #
+  # As soon as injected properties are "lazy: false", which needs to be the case
+  # for properly typed ones and which usually comes when switching from doc comments
+  # to PHP 8 attributes, the loader can't easily decide which singleton depends on
+  # an "expiring" object, so the "all" preloader might silently load doctrine DBAL.
+  #
+  # className: Netlogix\JobQueue\FastRabbit\SingletonPreloading\AllSingletonsPreloader
+
+
+'Netlogix.JobQueue.FakeQueue:SingletonPreloaderCache':
+  className:         Neos\Cache\Frontend\VariableFrontend
+  scope:             singleton
+  factoryObjectName: Neos\Flow\Cache\CacheManager
+  factoryMethodName: getCache
+  arguments:
+    1:
+      value: Netlogix_JobQueue_FastRabbit_SingletonPreloaderCache
diff --git a/Configuration/Settings.SingletonsPreloader.yaml b/Configuration/Settings.SingletonsPreloader.yaml
new file mode 100644
index 0000000..8bb4e9d
--- /dev/null
+++ b/Configuration/Settings.SingletonsPreloader.yaml
@@ -0,0 +1,14 @@
+Netlogix:
+  JobQueue:
+    FastRabbit:
+
+      AllSingletonsPreloader:
+        ignoreClassNames:
+          # cannot be preloaded due to missing constructor arguments
+          Neos\Flow\ObjectManagement\CompileTimeObjectManager:                           Neos\Flow\ObjectManagement\CompileTimeObjectManager
+          Neos\Flow\Property\TypeConverter\AbstractTypeConverter:                        Neos\Flow\Property\TypeConverter\AbstractTypeConverter
+          Neos\Flow\Security\Authentication\Controller\AbstractAuthenticationController: Neos\Flow\Security\Authentication\Controller\AbstractAuthenticationController
+          Neos\Flow\Session\Aspect\SessionObjectMethodsPointcutFilter:                   Neos\Flow\Session\Aspect\SessionObjectMethodsPointcutFilter
+          # must not be preloaded because they hold connections that can expire
+          Doctrine\DBAL\Connection:                                                      Doctrine\DBAL\Connection
+          Doctrine\ORM\EntityManagerInterface:                                           Doctrine\ORM\EntityManagerInterface
diff --git a/bin/fast-rabbit b/bin/fast-rabbit
index cf96dd7..eae82f7 100755
--- a/bin/fast-rabbit
+++ b/bin/fast-rabbit
@@ -1,10 +1,12 @@
 #!/usr/bin/env php
 <?php
 
+use Neos\Cache\Frontend\VariableFrontend;
 use Netlogix\JobQueue\FastRabbit\Cache\CacheFactory;
 use Netlogix\JobQueue\FastRabbit\Lock;
 use Netlogix\JobQueue\FastRabbit\Loop;
 use Netlogix\JobQueue\FastRabbit\Worker;
+use Netlogix\JobQueue\Pool\Pool;
 use t3n\JobQueue\RabbitMQ\Queue\RabbitQueue;
 
 require_once __DIR__ . '/../src/autoload.php';
@@ -26,10 +28,22 @@ if (!is_a($queueClassName, RabbitQueue::class, true)) {
 }
 
 $queue = new $queueClassName($queueName, $queueOptions);
+assert($queue instanceof RabbitQueue);
 $messageCache = CacheFactory::get($config);
+assert($messageCache instanceof VariableFrontend);
 $lock = new Lock($config['workerPool']['numberOfWorkers'], $config['workerPool']['lockFileDirectory']);
 
-$worker = new Worker($command, $queue, $queueSettings, $messageCache, $lock);
-$loop = new Loop($queue, 21600);
+$pool = new Pool(
+    null,
+    false,
+    false,
+    max(0, (int) ($queueSettings['preforkSize'] ?? 1)),
+    $command,
+    \React\EventLoop\Loop::get()
+);
+$pool->injectMessageCache($messageCache);
+
+$worker = new Worker($command, $pool, $queue, $queueSettings, $messageCache, $lock);
+$loop = new Loop($queue, $pool, Loop::SIX_HOURS_IN_SECONDS);
 
 $loop->runMessagesOnWorker($worker);
diff --git a/composer.json b/composer.json
index 4fce6c0..49259c8 100644
--- a/composer.json
+++ b/composer.json
@@ -1,7 +1,7 @@
 {
     "name": "netlogix/jobqueue-fast-rabbit",
     "type": "neos-package",
-    "description": "Low memory footprint worker for RabbitMQ jobs",
+    "description": "Worker for RabbitMQ jobs",
     "license": "MIT",
     "autoload": {
         "psr-4": {
@@ -11,9 +11,13 @@
     "require": {
         "ext-json": "*",
         "flowpack/jobqueue-common": "^3.0.0",
+        "netlogix/jobqueue-pool": "^1.0",
         "netlogix/supervisor": "^1.0",
         "php-amqplib/php-amqplib": "^2.11",
-        "t3n/jobqueue-rabbitmq": "^2.3.0"
+        "react/child-process": "^0.6",
+        "react/event-loop": "^1.5",
+        "t3n/jobqueue-rabbitmq": "^2.3.0",
+        "php": "~8.2 || ~8.3 || ~8.4"
     },
     "extra": {
         "neos": {