A Flexible Orchestra for Language Models ✛

Original: "Elastic Gang: Per-Token Membership Change for a Hard-Barriered LLM Inference Gang Co-Scheduled with OS Processes"
· Daeyeon Son
arXiv:2607.04668 · 2026-07-06 · CC BY-SA 4.0 · 2 min
A group of processor cores can flexibly adapt to the load, running language models without errors or hangs.

Eight musicians freeze before the start of a symphony. Their part is to take turns answering a large Large Language Models. But here’s the trouble: if one is late, all the others can’t play — not a single note. That’s how regular processors work: when many cores collaborate on Machine Learning tasks, they have to meet at strictly defined points (barriers). If even one core strays, the whole group hangs, and replacing it with another can distort the result.

In Anima OS — an operating system written in Rust — they solved this problem by turning a rigid group into a flexible orchestra without a conductor. Each core-musician can join or leave only between musical phrases — that is, between tokens (word fragments). The system uses a simple protocol: before a phrase begins, all cores respond, agreeing to play, and a list is formed from them. That list is locked in, and from then on, only those on it do the work. If a core misses the cue, no big deal — it skips that phrase, and its neighbors cover its part.

Even with three hundred task switches in 10 seconds, the AI never made a single word error, and speed fluctuations stayed under 0,9%.

Tests on an AMD Ryzen 9 processor with SmolLM2-135M and Qwen2.5-7B models showed: when a quarter of the time was given to AI, overall throughput for regular tasks jumped 1,75 times — from 327 to 574 service operations per second. At the same time, the model responded just as fast, and every single word matched exactly what a strict isolated group would output. Returning a busy core took almost no time — just 0,22 microseconds (a millionth of a second). Even if a core was tied up with another process, it was picked up at most 16 milliseconds later.

With a quarter of the load from AI, the flexible core group boosted overall system speed 1,75 times — and never made a mistake.

The flexible orchestra breaks the old rule that synchronous computing can't be shared with others. Now language models aren't isolated programs but elastic tasks that can negotiate for resources. Like an orchestra that changes its lineup between symphony movements, the processor can lend cores to AI for a moment and instantly get them back for other work. In the future, this solution could be ported to standard Linux, adapted for mobile processors, and built into power-saving systems. Now a late core is no disaster. Missing the common start, it simply skips a beat, and the flexible orchestra plays on — without a single false note.

Even with 301 task switches in 10 seconds, the model didn't produce a single wrong word, and speed fluctuated within 0,9%.

Concepts
Turing machine Large Language Models