I recently read about [PHP's true async RFC][1]. The initial real life "picture" (unrelated to PHP or sync processing) that I imagined was a waiter in a restaurant. He/She/It works async, taking orders from the customers, delivering the orders to the kitchen, cleaning up tables, bringing orders to the tables, cashing in the money and so on, all async. Then I remembered about the lost time that gets in between all of these processes and I pictured this visual simple representation of it (time laps from top to bottom like rain drops fall thanks to gravity): [![enter image description here][2]][2] I noticed this also while using Javascript to simulate in parallel some (automotive acceleration) graphs in my portal. The idea that I understood was that the worker can **switch "tasks" only at certain points** NOT when the **response came from DB** or **from the HTTP request**. Also I understood that the **scope "sticks" with the task and not with the worker**. All is fine so far but I wonder. Is there anything better than this? This seems like gambling with lost and gained processing time. Laravel Octane (if I understood right) works pretty much in the same way, not waiting for DB OR HTTP responses but that is in another context (outside of one http request's scope or CLI command's scope) than my question. PHP 8.1 Fibers work kind of in the same way with the difference that the developer decides (hardcoded in his code logic) when the worker should switch tasks/fibers. I understand that the number of workers must be limited and that starting as much needed workers as possible to eliminate the wasted time is improbable to happen. Still... if the scope is not carried around by the worker, in theory, starting as many workers as needed could help eliminating the dead/unused time. Ideal (if possible) each worker that does not have a task to pick on, should be stopped and also when there is no available worker to pick up a task, a new worker should be started. [![enter image description here][3]][3] Of course there should be a hard limit on the max number of workers that can coexist. When that hard limit is reached the wasted time makes its way into the situation. I have no idea how this would behave, that is the reason for asking this question. Maybe the async is already like this and I did not understand it right. Another reason why I ask this is because the PHP RFC would imply huge work to be done that (maybe) would generate issues and if the end result is not "perfect", I wonder what would happen by spending that amount of resources on a better approach, better than async if that solution CAN exist. What I tried for example, is running the queries for eager loading from Eloquent concurrently via [mysqli_poll][4] for bind-less selects and async via curl_multi_init but I saw that the time gained is less than the time spent on initiating those parallel HTTP requests if each query would generate a call. Then I split the queries in two batches when the number of relations is over 30 for example. So when I think of async I always relate to real life needs that can be covered by it or by something similar to async. **UPDATE 2025.11.26** **It seems the [True Async RFC from PHP falls into the first picture][5] logic with a single thread. So my question is about that scenario: a request or a command situation.** **UPDATE 2025.11.28** **For single threaded request/command situation the only situation where a time improvement could be possible is when a call is made to outside with some info (not with the whole scope) and a waiting time is needed. So maybe going on that path could be a BETTER alternative to async (curl_multi_init, mysqli_poll, starting parallel new processes like laravel does with their concurrency, amphp/mysql package that already uses php fibers etc).** This would be the current doable situation via the above: [![enter image description here][6]][6] Can it be that the worker starts processing the response from call 1 as soon as it arrives with the condition that it is after the call 3 was initiated while the worker waits? In current implementation or new feature implementation of PHP I mean. Something like this: [![enter image description here][7]][7] [1]: https://wiki.php.net/rfc/true_async [2]: https://i.sstatic.net/LHiQhEdr.png [3]: https://i.sstatic.net/4fhnKSLj.png [4]: https://github.com/laravel/framework/discussions/55316#discussioncomment-13663660 [5]: https://github.com/true-async/php-true-async-rfc/discussions/10#discussioncomment-15088501 [6]: https://i.sstatic.net/kEtogV0b.png [7]: https://i.sstatic.net/yrGqu9Y0.png