Local AI models: should two of them share one laptop, or take turns?

By the Cerevisor team. Measured on 13 October 2026 on one laptop. Product details checked against the source code of Cerevisor 3.8.1.

On a laptop with 64 GB of memory and no graphics card, a 30B model took 15.48 seconds to load and then 261.36 seconds to write a three-bullet summary of a page of warehouse notes. I had braced for the first number to be the problem. It was the second.

That is the short version of a morning spent on one question: when a workflow uses two local AI models, should both stay in memory, or should they take turns?

Why local AI models now come in pairs

For a long time a local setup meant one model. That is changing. On 30 September, Laurence Moroney wrote about small decision models arriving in local runtimes. A decision model is a small model that answers a narrow question, such as a yes or no, instead of writing paragraphs.

He describes the pattern as “lots of cheap local judgments feeding a bigger agent”. On 12 October, LM Studio’s changelog for Bionic 1.1.8 listed “Decision model load settings, activity status, and cancellation controls.” Two signals in two weeks point the same way: a small model beside a large one, on the same machine.

That makes memory a planning question. A model that is loaded is held in the computer’s memory, ready to answer. A model that is not loaded has to be read from disk first. Two models can both stay loaded, or the machine can unload one and load the other each time the work changes hands.

What two local AI models cost in memory on one laptop

The machine: an Intel Core i9-12950HX laptop, 64 GB of memory, graphics card not used. The server: LM Studio, with both models set to a working memory of 8,192 tokens. A token is a piece of a word, and it is the unit models read and write in.

The two models were Muse Glimmer 30B and Gemma 4 E2B, both at Q4_K_M. That label means a compressed copy of the model that trades a little accuracy for a much smaller file. On disk they are 18.16 GB and 4.41 GB.

I measured the local server directly, which is the same kind of endpoint Cerevisor connects to.

So on this machine the pair fits, with room left for a browser and the rest of a working day. On a machine with less memory, the same reading shows when taking turns is the only option.

Loading and unloading: what taking turns costs

Across nine loads, the large model took between 15.41 and 20.84 seconds to come off disk. Across eleven loads, the small one took between 6.53 and 18.35 seconds, and nine of those were under 9 seconds.

Then I ran the same two-step job both ways, twice each. The large model drafts the summary. The small model reviews it against the notes.

The loading column is the honest cost of taking turns. The rest of the gap between the rows is not. The drafts came out at different lengths from run to run, and at around one token per second on this laptop, a longer draft moves the total far more than a reload does. Four runs on one machine cannot separate those two things, so I will not pretend they do.

On a laptop without a graphics card, loading a model is the cheap part. Every extra sentence it writes is the expensive part.

The small reviewer that returned nothing, and the fix

Here is the failure I did not expect. In the first pass, the small reviewer took 89.37 seconds, used all 800 tokens it was allowed, and returned an empty answer.

The cause was reasoning tokens. Those are the words a model writes to itself before it answers, and they count against the same limit as the answer. The log shows 797 of the 800 tokens went to that private thinking. The reply ran out of room before it started.

The fix was one setting: reasoning switched off for the small model. In the second pass the same reviewer answered in 36.43 and 35.21 seconds with a real list of points.

The large model had the same habit in a milder form. As its own reviewer, in a single earlier run, it took 492.31 seconds and spent 619 of its 711 tokens thinking.

Best local AI models for a reviewer role: read the output, not the speed

I also let the small model do both jobs. It finished in 61.33, 57.48 and 61.99 seconds across three runs, which looks like a clear win.

Then I read what it wrote. Reviewing its own drafts, it returned the same 37-character all-clear three times. On three of the four large-model drafts it had listed specific points. I did not grade whether each point was right, only that it engaged. A reviewer that never objects is quick, and that is all it is.

So the pair earned its memory. The large model writes the thing worth checking, and the small model checks it without making the large one stop and read its own work.

How to set up a drafter and a reviewer, and what to measure first

In Cerevisor, the choice of model is made per agent. For each agent, the app picks a connection in this order: the agent’s own, then the workflow’s, then the app default, then the first one that is switched on. An agent that names a specific model gets that model. The per-agent overrides guide shows where to click, and the local models guide covers connecting a server on the same machine.

1. Read free memory with both models loaded

   If what is left would not hold the rest of a working day, plan for taking turns.

2. Time one load of each model

   Compare it with how long one answer takes. On my laptop the load was seconds and the answer was minutes.

3. Open the reviewer's reply before timing it

   An empty or one-line reply means the setting needs fixing, not the hardware.

4. Give the drafter the large model and the reviewer the small one

   Set each on its own agent and run the same job twice.

These are numbers from one laptop on one morning, and a machine with a graphics card will produce different ones. The method travels better than the figures: measure the load, measure the answer, and read the answer. It took me a morning, most of it spent waiting for a 30B model to finish a sentence, which is its own kind of meditation.