This whole project actually started with me just trying to get Strata working on my Intel Arc GPUs. I wasn't originally planning on making a fork or adding a bunch of features. I just wanted to get the engine running on my hardware.

But as I got things working and started benchmarking, I noticed something interesting. A single request was generating around 40–45 tokens/sec, while multiple concurrent requests could make use of a lot more of the server's processing capacity.

That got me thinking. Since I'm the only one using my server, why not try putting those extra batch slots to work on a single complicated request?

That's basically how Strata Void started. It's an experimental fork of Niko1221's Strata, with a feature I've been working on called Task-Parallel Requests.

The idea is pretty simple. Instead of having the model work through one big question sequentially, it can break suitable requests into smaller independent tasks, process them concurrently using the same loaded model, and then combine everything into one final response.

You can enable it with "task_parallel": "auto". Simple questions go through normally, while more complicated requests can be split up if the planner thinks it would help.

The results so far

I ran 10 different complex tasks with a 32K context window, using cold runs with one test per task and mode.

• Normal request: 181 seconds median
• Four parallel subtasks + synthesis: 68 seconds median
• AUTO mode: 78 seconds median

The important distinction is that this doesn't actually increase single-stream token generation speed. That's still around 40–45 tok/s on my setup. What improves is the total time it takes to finish a complicated request.

For reference, my setup is:

• Intel Arc Pro B70 (32GB) + B65 (32GB) + B60 (24GB)
• 88GB total VRAM
• Ryzen 9 9950X / 64GB DDR5
• Ubuntu Server 26.04
• Swift 1.5 Qwen3.8 Flash-Next, IQ4_XS

All of the model's expert weights are loaded into VRAM, so there's no RAM spilling involved in these benchmarks.

I've also been experimenting with faster prompt processing on Intel Arc, shared-context caching between subtasks, and larger context configurations up to 128K.

A few caveats

This isn't some magical free performance boost. Splitting a request means additional planning, processing, and synthesis, so it uses more total compute. It's also not useful for every prompt, and I've seen cases where parallel tasks make mistakes or disagree on numerical results.

The benchmarks are preliminary and all come from one machine and model, so I'm definitely not claiming everyone will see the same improvements.

Also, credit where it's due: the underlying engine comes from Niko1221 and the Strata contributors. I worked on the direction of this fork and its evaluation, with Claude assisting heavily with implementation, debugging, and benchmarking. Task parallelism itself isn't a new concept; I wanted to see how well it could work integrated directly into Strata.

I'm sharing this because I'd genuinely love to see how it performs on other hardware, especially different Intel Arc configurations or NVIDIA CUDA setups.

If anyone feels like experimenting with it, I'd love to hear what works, what breaks, or whether the performance improvements hold up on your system. Contributions and bug reports are welcome too.

GitHub: https://github.com/Jumbomuffin777/Strata-Void

The repository has the setup instructions, benchmark methodology, and raw results if anyone wants to dig into the details.