Several OpenMausBot Bots on One Local GPU: Where Each Message Waits
We ran up to eight OpenMausBot bots against one local Qwen server with two slots. Bots wait for a shared desktop that a Local VM bot holds for its whole turn, for the engine to read one prompt at a time, and from the third bot on, every message re-reads about 32K tokens.

Two bots taking turns on our local Qwen server answered a one-line question in a median of 29.8 seconds per message. Add a third bot and the same question took 64.3 seconds. With four to eight bots it settled at about 72 seconds, and doubling the conversation cache did not bring it back down. Nothing about the question changed. What changed is that from the third bot on, the engine read about 32,000 tokens of each bot's prompt again on every message.
That is the biggest of three waits we found when several OpenMausBot bots share one GPU. In part 1, two bots messaged at the same moment answered after 66.0 and 131.2 seconds, and we guessed the app was queueing them. The app has no general queue: bots with no computer chosen all started their turns within 1-3 seconds. The waits were in three places: a shared desktop that a Local VM bot holds for its whole turn, which is where part 1's two bots queued, an engine that reads one long prompt at a time, and a conversation cache that stops helping once more than two bots take turns.
What we ran
The setup is the one from part 1:
- OpenMausBot 0.1.138, installed with npm on the host.
- Strata 0.1.55 in Docker serving Qwen3.8-Flash-Next IQ2_XS with a 128K context, on one A100 80GB with the same memory setting as part 1 (
vram-reserve-mib=71300, which leaves Strata about 10.4GiB). The Strata processes used about 10GiB of GPU memory. Speeds below are A100 speeds. PARALLEL=2, which gives Strata two slots: two conversations can sit in GPU memory and decode together.- A conversation cache of 8,192MiB with four places, where Strata parks finished conversations in system RAM so a later turn does not have to read everything again.
One fact shapes everything that follows. Before a bot says anything, OpenMausBot sends the model about 51,000 tokens: the bot's instructions, tool descriptions and, because a Local VM was running, the desktop tools. The answer to our question is one sentence. So almost all of the work in a message is the engine reading the prompt, and the fastest message is the one whose prompt the engine has already read.
We ran four experiments, three repetitions each:
- At the same moment. One to four bots get the one-line question "Reply with one short sentence: what is 7 times 4?" (numbers vary) at once.
- Taking turns. Two to eight bots get the question one after another, three rounds, like a person working through a few chats. We count the first round as warm-up and report the second and third.
- Shared desktop. Two bots with a Local VM get a file task at the same moment: "create a file named v1_shared_r1.txt in your home folder containing exactly: hello from v1_shared_r1, 391". We ran it once with one desktop for all bots and once with a desktop per bot, and judged the result by reading the files inside the containers ourselves.
- One-line question to desktop bots. The same one-line question as experiment 1, sent to the two desktop bots.
The bots in experiments 1 and 2 had no computer chosen. OpenMausBot still attached the running Local VM's tools to them, which is why their prompts were 51,000 tokens, but a one-line question never made them touch it.
Wait 1: a bot holds the shared desktop for its whole turn
By default, every bot with a Local VM uses one shared desktop. When two such bots got the file task at the same moment, the second one did not start working until the first one's turn had ended. The app showed it as an activity line: "Waiting for its turn on this computer — 1st in queue — V2 is running", followed by "Computer free — continuing after waiting".

In all three repetitions, the waiting bot waited exactly as long as the other bot's whole turn: 106, 17 and 115 seconds. Both files were correct every time, and neither bot overwrote the other's file. With a desktop per bot, the two bots worked side by side and finished about 10 seconds apart or less in the second and third repetitions. Each per-bot desktop container used at most about 0.2GiB of RAM in this task.
The wait comes from how the app claims the desktop. We read the code (dist-server/server/index.js in 0.1.138): a bot whose computer is set to the Local VM claims it when its turn starts and releases it when the turn ends, whether or not the message needs the desktop. A bot with no computer chosen claims it only when it first calls a screen tool. Part 1's two bots, Flash and Flash2, both had the Local VM set, which fits the pattern we saw there: the second turn began 1.3 seconds after the first ended.
We checked this with the one-line question from experiment 1, sent to the two desktop bots at the same moment. The question needs no desktop, yet all three times the second bot showed the same "Waiting for its turn on this computer" line. It waited for the other bot's whole turn (95, 35 and 44 seconds) and answered at 159, 44 and 52 seconds.
The desktop-per-bot setting had one failure. In the first repetition neither bot had a desktop yet, and the app creates only one new desktop at a time. The second bot did not wait for it: it failed after 3 seconds with "Create the Local VM (App Settings → Computers)". The code matches this (a single flag guards desktop creation, and a turn that misses it gets the status "missing"). In the next repetition the second bot's desktop was created and both bots succeeded.
Wait 2: the engine reads one prompt at a time
Bots without a desktop claim do not wait for each other in the app. Their turns all started within 1-3 seconds of the message. So with two slots, we expected two bots to finish about as fast as one. They did not.

One bot alone took 46-74 seconds. Two bots at once took, for the slower bot, 42.8 to 113.6 seconds across the three repetitions, and in each one the engine spent 88-95% of the whole time reading prompts. With three and four bots the share was 83-94%. The answers themselves took a few seconds.
Strata's batching notes explain the shape: new long prompts are admitted one at a time and read one after the other. The two slots let conversations decode together, and a long read pauses at chunk boundaries so a waiting shorter request can go first. But a one-sentence answer gives the slots almost nothing to decode together. When the work is mostly reading long prompts, two slots do not make two bots faster than one bot twice.
Wait 3: from the third bot on, every message is read again
Reading a whole 51,000-token prompt takes about 90 seconds here, so the conversation cache matters most. With two bots taking turns, it worked: each message continued from a saved point about 37,000 tokens in, and the engine read only 14,000-15,000 new tokens.

| Bots taking turns | Messages that re-read the prompt | Median per message |
|---|---|---|
| 2 | 0 of 12 | 29.8 s |
| 3 | 18 of 18 | 64.3 s |
| 4 to 8 | all | 71.5 to 72.4 s |
| 3, cache off | 18 of 18 | 101.8 s |
| 8, cache 16,384MiB with 8 places | 48 of 48 | 72.5 s |
From three bots on, every message read about 32,000 tokens again. The cache still helped a little: the start of the prompt is the same for every bot, so the engine borrowed those first 17,000-19,000 tokens from a parked conversation. That is why three bots took 64.3 seconds a message with the cache on and 101.8 seconds with it off.
The cache seems to stop helping because the next bot's conversation is pushed out first. A bot's request is not only its message: OpenMausBot also sends small side requests around each turn, and each one is parked in the cache too. Between two turns of the same bot, the median number of conversations parked was 1 with two bots, 6 with three, 9 with four and 42 with eight. With four places and the oldest entry dropped first, the conversation of the bot whose turn comes next would be among the first pushed out. Doubling the cache to eight places at eight bots still left 21 parks between turns, and every message re-read.
The size of the prompt decides most of the per-message time. In one run of six bots with desktops set to per-bot, bots with no computer chosen got no desktop tools and their prompt shrank to about 20,000 tokens. Every message was still re-read, and the median was about 41 seconds instead of about 72.
What we would do with several bots on one GPU
If several bots on one GPU need a desktop, we would give each one its own desktop and create those desktops one at a time before the bots get work. In our runs that removed the longest wait, a bot sitting idle for another bot's whole turn, for about 0.2GiB of RAM per desktop, and creating them ahead of time avoids the one failure we saw.
Next in this series, we cut OpenMausBot off from the internet and see which jobs still work. It will land in the newsletter below.
New posts on this topic go into the weekly newsletter. One email a week at most.