An 8 GB MacBook Air can generate an answer with a local language model. Can it finish a real job while Chrome stays open? That is a different question—and, in my experiments so far, the answer is still not demonstrated.
I used an Apple MacBook Air M3 with 8 GB of unified memory. Instead of quietly closing all normal applications or accepting an out-of-memory crash as a benchmark, I maintained the existing background services and used a swap-out watchdog. These are field notes from distinct runs, not a controlled leaderboard.
The results at a glance
| Experiment | Local model / task | Actual outcome | What it proves |
|---|---|---|---|
| R13 | Qwen3.5 4B, UD-Q3_K_XL; one controlled question | Correct answer 56 in 19.023 s including startup | The 4B model did generate locally, once |
| R14, 2B | Qwen3.5 2B, UD-IQ3_XXS; 13 frozen prompts | 13/13 responses completed; 4/13 combined-correct | Some local completion, limited accuracy |
| R14, 4B | Qwen3.5 4B, UD-Q3_K_XL; same planned suite | 7/13 requested, 6 completed, 4/7 attempted correct; 6 NOT_RUN | Safety-limited sample, not a 13-task head-to-head win |
| R15 | 4B loading attempt with no-cache-prompt option | Guard stopped the load at 672.312 MiB/5 s; zero generated requests | Loading itself can cross the guard |
| R18, 2B agent | Fix a Python sales-summarization bug | Native tool calls worked; repeated README reads; zero writes, zero model test runs | Function-call syntax is not autonomous task completion |
| Earlier R19 stand-alone, 3B coder | Qwen2.5-Coder-3B Q5_K_M load | Guard stopped loading at 550,043,648 bytes/5 s; zero inference | No evidence of this 3B model’s coding ability |
| R19 consolidated batch, LFM | LFM2.5-2.6B; frozen code-edit task | Completed inference; produced no verified edit or model-origin test; independent check 27.0 vs 39.0 | Agent task FAIL; model-load WARN, no HARD STOP |
| R19 consolidated batch, Qwen3.5 | Qwen3.5 candidate; same intended task | Completed inference; no verified code edit or model-origin test; independent check 27.0 vs 39.0 | Agent task FAIL; no HARD STOP |
| R19 consolidated batch, remaining | Granite 4.2 3B; Qwen2.5-Coder historical arm; Spark-X2.6; Nanbeige4.2 | Granite downloaded and hash-verified but not loaded; coder was not retried; Spark and Nanbeige NOT_RUN | No new model-capability assessment |
Measurement status: These figures come from preserved local operator reports, traces, independent tests and checksums. They were not reproduced independently by the publishing site. The raw private run files are not embedded in this article.
The 4B result was real, but narrow
In R13 the Qwen3.5 4B quantized model completed one controlled request. It returned the expected value, 56, and the elapsed 19.023 seconds included startup. This does not establish reliable multi-step reasoning, useful agent behavior, or browser responsiveness under repeatable conditions.
R14 is more informative. On the same intended set of 13 prompts, the smaller 2B model finished all 13, scoring four correct. The 4B model answered seven requests before a 15-second rolling swap-out guard stopped the run at 777.562 MiB, above its 768 MiB limit. It scored four correct among those seven attempted, with one empty/interrupted response and six prompts never attempted. Counting those six as wrong—or comparing 4/7 directly with 4/13 as though both were complete panels—would mislead.
An earlier R13 run had a different guard configuration and machine state. A successful R13 and a stopped R14 therefore do not contradict each other.
The actual agent experiment: a README loop
The practical task was to inspect a small local project, find and fix a bug in its Python sales-summarization script, run the tests, and explain the change. The independent test expected 39.0; the unchanged script returned 27.0.
The first live 2B attempt produced native tool calls, but repeatedly opened README.md rather than reading the target script. A harness compactor had truncated the README and misleadingly suggested a follow-up read method that did not exist. I fixed that harness issue offline and regression-tested it.
In the next separate, single live 2B run, the model still called read_file four times, each targeting the README. A repeated-read guard stopped the loop. There was no model-origin file edit and no model-origin test invocation. The independent verifier still saw 27.0 instead of 39.0.
This is a failure of the full agent task. It is not evidence that function calling itself failed: native calls were parsed and executed. It does not prove the model would fail every other workflow either.
Why the 3B coding result is currently unknown
The next candidate was Qwen2.5-Coder-3B-Instruct Q5_K_M using the canonical upstream GGUF basename. A fresh preflight passed, but while the model was loading, a rolling five-second swap-out measurement reached 550,043,648 bytes = 524.56 MiB. That exceeded the unchanged 512 MiB/5 s hard threshold by 13,172,736 bytes (12.56 MiB).
The owned server was terminated and the host recovered with normal memory pressure. No generation request, function call, code edit, or independent model-output test occurred. Calling this a coding-model failure would be inaccurate: it is a resource-guard stop before inference.
This also shows why model-file size alone cannot guarantee that an 8 GB unified-memory Mac can run the model without memory pressure. macOS, Chrome, the server, weights, context and caches share the machine.
How I record a fair local-agent result
For each model, the essential fields are: model revision and quantization; llama.cpp or MLX version; context and output budget; cold versus warm load; task and evaluator hash; number of attempted and completed tasks; native versus fallback tool calls; real file diffs; tests invoked by the model; independent test outcomes; latency; rolling 5- and 15-second swap-out; and host recovery.
The actual task counts as a success only when the local model makes the tool choices, changes the sandboxed file, runs the authorized test, and the independent verifier passes. A successful mock harness test, a generated JSON string, or code repaired manually by the operator is not an agent-task success.
I preserved the old run markers and failed fixtures rather than rerunning them until the answer changed.
The November 4 multi-model batch was only partial
The next attempt was designed to evaluate six candidates on the same 27.0-versus-39.0 Python bug-fix task. The operator’s consolidated report records two models with actual inference: LFM2.5-2.6B and a Qwen3.5 candidate. Both failed independent verification. Neither changed the source code or invoked the target tests through model tools. Those are actual task failures, distinct from models that never ran.
The other candidate states matter just as much:
| Candidate / arm | Final status | Why |
|---|---|---|
| LFM2.5-2.6B | INFERENCE_COMPLETED / TASK_FAILED | 27.0 instead of 39.0; no edited code or model test; swap WARN crossed |
| Qwen3.5 | INFERENCE_COMPLETED / TASK_FAILED | 27.0 instead of 39.0; no edited code or model test |
| Granite 4.2 3B | VERIFIED_DOWNLOAD / NOT_LOADED | Only 214.7 s remained before the deadline; previous Qwen3.5 pass took 231.7 s through scoring and initial recovery |
| Qwen2.5-Coder-3B historical arm | NOT_RETRIED | Earlier stand-alone load had already hit a HARD STOP; no new inference in this batch |
| Spark-X2.6-4B | NOT_RUN | Not attempted in the time-bounded batch |
| Nanbeige4.2 | NOT_RUN | Not attempted; architecture/runtime compatibility remains an independent question |
In this consolidated batch, no model load crossed the HARD STOP. That does not erase the earlier, separately preserved Qwen2.5-Coder loading stop at 550,043,648 bytes/5 s. The distinction is the run scope, not a contradiction.
The batch’s 40 offline guardrail tests passed and the 8 GiB free-disk reserve was preserved. The no-load decision and final documentation were written after the 05:26:07 UTC deadline, but no model was started after the deadline. The previous frozen protocol and one-shot markers remained untouched.
Local report index: R19-local-agent-test/R19_CONSOLIDATED_REPORT_KO.md. SHA ledger: R19_CONSOLIDATED_SHA256SUMS. Model registry: models/model_registry_verified.json. These paths describe owner-private experiment files, not public downloadable traces. The summary was provided by the local operator; this article has not independently opened each raw file.
What comes next
A useful local agent must edit a real file, call the tests itself, and pass the independent check; neither of the completed R19 batch candidates did so. The pending Granite, Spark, Nanbeige and unretried coder arms must remain NOT_RUN or NOT_LOADED until actual evidence exists.
I want a local assistant that can fix a real bug, not just produce an impressive answer to a one-line prompt. Future successful runs will appear as dated addenda, not overwrite these failures.
Safety and interpretation
This was a machine-specific experiment, not a buying guide. The historical run policy included a warning at 128 MiB/5 s and hard stops at 512 MiB/5 s or 768 MiB/15 s; other host-pressure checks also applied. Swap-out counters are not measurements of physical SSD NAND wear. A shortened preflight can improve test turnaround but does not erase the need for an active watchdog from before model loading.
Updated 4 November 2026 with the partial six-model R19 batch. Local measurements are operator-reported; no public leaderboard submission or demonstrated autonomous desktop operator is claimed.