Ollama No Longer Calls Home From Our Mini, and Our Local Reader Answers Every Message: the Week of 27 October
Everything built on the Mac mini this week, with the artefact behind each line. Ollama's daemon was calling ollama.com every four hours while the models sent nothing; the switch that stops it is now measured and on. The local reader's 22 empty answers were repetition loops: a bigger context moved them, a retry without thinking closed them, 0.882 → 0.914. The mini throttled itself to 8 tokens a second over a half-finished OS upgrade. Ten changes: two from real inputs, seven from tests, one from reading.
This is the week’s build log in one piece: the two results in full, the rest in a paragraph each, every number linked to the artefact that produced it. The daily version is the build log in the evidence repository.
The runtime phoned home every four hours. The switch that stops it works, measured.#
A colleague told us a local Qwen on his machine seemed to open connections while he used it: endpoints in China, then a host in France, “it just searches for data in a search engine.” That is the one failure the local-first thesis cannot survive. If inference is local, nothing leaves. We say so on this site and in Aprimerose’s material, and in exp_054 we had measured it for our own code. We had never watched a third-party model’s runtime while it ran. So we did, in exp_057, registered in the morning and run before lunch.
Model weights are inert. A .gguf file is tensors; it cannot open a socket. If a connection appears during “local inference”, it comes from the runtime that loads the weights (here Ollama’s daemon and the runner it spawns per model), or from a harness around it that reads the model’s output and executes a search request it finds there. The experiment was built to tell those apart: lsof every 0.2 s over the daemon and its runners, nettop every second over every process on the machine, and for each of ten subjects three watched windows: the load, 30 s idle, and ten frozen prompts, five of them written to tempt a search. Eight Qwen builds, gemma4:26b as the in-house control, and the embedding model. Three controls had to pass or the run was void; all three did.
Thirty windows, 29 minutes, no runner opened anything. The colleague’s report did not reproduce here. No model’s answer contained a tool call or a search request; they said they could not browse, or guessed and said so.
One connection did appear, and the daemon’s own log settles it to the millisecond. During one 35B model’s window, the Ollama daemon itself opened a TLS connection to the address ollama.com resolves to: 2,001 bytes out, 7,639 in. Fifty-eight milliseconds earlier the log had written that its “model recommendations” refresh ran and succeeded, and ~/.ollama/cache/model-recommendations.json was rewritten in the same second. The log on this machine holds 372 of those refreshes since 5 March, one every 3.5 to 4.6 hours and one at every daemon start: about six contacts with ollama.com a day, generating or not. It fell into that model’s window by arithmetic.
We had registered two claims: that plain inference opens no endpoint absent at idle, and that no external connection first appears inside a prompt’s window. Both fail. They were written to detect an appearance, not a cause, and they detected one. A 30 s idle baseline cannot see a four-hour timer. The explanation sits beside the fails in the record, not in place of them.
Ollama documents an off switch for its cloud features: OLLAMA_NO_CLOUD=1, or "disable_ollama_cloud": true in ~/.ollama/server.json, then a restart, after which the log reads Ollama cloud disabled: true. The documentation does not say whether that covers the recommendations refresh. So we registered a second run before making it: set the flag, restart, watch the daemon’s tree and the whole machine with nothing generating for longer than the longest interval we had seen, and count any refresh line in the log. On 1 November the production daemon was restarted with the flag at 07:25 and watched until 12:25. One refresh came due in that window, at 11:20.
a call to ollama.com, and the file it rewrotea scheduler line in the daemon logwatched window
1 November, CET. Before the flag, a refresh means three things at once: a log line, a connection and a rewritten cache file. After it, the log line at 11:20 came alone. Hover a mark for the record behind it.
Result
The log beside the new start
Ollama cloud disabled: true
Connections from the daemon’s tree in five hours, sampled at 0.2 s
its local listener, nothing else, including at 11:20
Any process on the machine reaching the address ollama.com resolves to
none
The recommendations cache file, rewritten by every past refresh in the same second
kept its 06:11 write, the last refresh before the flag
Refresh lines in the log
two “cache sleep scheduled” lines: one at the start, one when that wait ran out at 11:20
Those two lines make one of our registered claims fail: we had written “no refresh line after the restart”, because in every earlier log the line followed a successful fetch. With cloud disabled, the scheduler keeps its timer and skips the request. The start line was written one millisecond after the daemon began listening, too soon for a TLS exchange, and nothing on the network or on disk matched either line. The verdict stands as registered, with the cause next to it. For anyone checking a machine by its logs: a log line is not a call. The cache file’s write time and the network are the evidence.
What this does not show. Sampling at 0.2 s and 1 s can miss a shorter connection; the packet-capture arm did not run. The request’s content is unseen: two kilobytes out is a TLS handshake plus one HTTP request, and whether it carries anything about this machine beyond a timestamp, the bytes do not say. One runtime, Ollama 0.40.2; LM Studio, a bare llama.cpp server, MLX and desktop chat apps are untested. The harness layer, an app executing a model’s search request, is the layer most likely behind the report we started from, and it is the next experiment. Nine quiet models are nine quiet models, not “these models are safe”.
So what. “Nothing leaves the machine during local inference” is false for Ollama 0.40.2 as installed. The sentence our pages can carry is the measured one: the model sends nothing, and the runtime sends nothing once its cloud features are off. Every place we wrote the short version gets the long one. It is a documented feature with a documented switch; what was undocumented is the cadence, and that the switch covers the refresh. A baseline must outlast the longest timer. And read the daemon’s log before guessing at an address: it named the moment, the purpose and the URL.
In exp_055 we built 220 messages against a fictional person’s public footprint, 110 lures and 110 genuine, and asked gemma4:26b, alone on the Mac mini, to grade each one. It beat our engineered check (balanced accuracy 0.882 against 0.814). It also returned 22 empty answers. Every one of them took about 150 seconds, which is 8,192 tokens at the mini’s speed: the model thought until the context was full, and no answer token was ever written. Under the rule we had registered, an empty answer counts as “not flagged”, so the model’s catch rate was understated and its false-alarm rate flattered.
Our October post on a model that thinks met the same wall on a different task and drew the obvious lesson: thinking needs room. Four of thirty calls stopped before answering at 8K; at 16K they finished. Before building the next thing on this reader, we tested that lesson properly, in exp_060, registered before the kit was written.
Ollama 0.40.2 has no thinking budget for this model. ollama show lists the thinking levels as false and true; a request for "low" is accepted and ignored. So a budget has to be built around the model, and the mechanisms the runtime does offer are these:
Arm
The one change
The question
T
thinking off
does the reader need to think at all?
F
think as before; if the answer comes back empty, one retry of the same prompt with thinking off
can the loss be closed without touching any answer that worked?
C
the same call with a 32,768-token context
does the thinking finish when given room, and what does it then say?
Everything else was exp_055’s: the same 220 messages, the same prompt, temperature 0, seed 55, one call per message. Every call recorded what exp_055 had not: the token counts, why generation stopped, and the thinking text.
model step, thinking onmodel step, thinking offcode step
T — thinking off
modelgemma4:26b, thinking off, 8Kthe same prompt; answers in about 3 s
→ a verdict on every message
F — think, then retry without
1 · modelgemma4:26b, thinking on, 8Kexp_055's call, unchanged
2 · codeDid an answer come out?a parsable verdict ends here; an empty one goes on
3 · modelthe same prompt, thinking offone retry, only for the empties (21 of 220)
→ a verdict on every message; the 199 that answered first are untouched
C — more room
modelgemma4:26b, thinking on, 32Knum_ctx 32,768; the daemon reloads the model for it
→ 198 verdicts, 22 empty
Every arm sends exp_055's prompt with the footprint, the registry facts and the message, at temperature 0 with seed 55. Each changes one thing. Arm F's retry is arm T's call, made only when the first pass returns nothing.
Four controls had to pass. The baseline had to reproduce (F’s first pass gave exp_055’s verdict on 193 of 193 unchanged messages, and all 20 unchanged empties were empty again). The wall had to be the cause (all 21 empty first passes ended at exactly 8,192 tokens). Nothing could leave the machine (every connection went to the local daemon). And arm C had to run at 32K (the daemon reported 32,768 and 23 GB, against 18.7 GB at 8K).
By the rule we registered, the arm that answers at least 218 of 220, scores at least 0.882, and stays under 45 s median and 180 s at the 95th percentile with no call error, wins. F is the only arm that passes all of them. It takes the gap to Opus from 0.068 to 0.036.
F, the arm chosenthe other two armsfor reference: exp_055's run of the same call, and Opus
Answered, of 220
higher is better
Lures caught, of 110
higher is better
Genuine messages flagged, of 110
lower is better
Balanced accuracy
higher is better
An empty answer counts as not flagged, as registered, so the two arms with 198 answers carry 22 misses or clears they never made. Balanced accuracy is the mean of the catch rate and one minus the false-alarm rate.
More room moved the empty answers. It did not close them.#
At 32K, 22 answers were still empty. Not the same 22.
11 of the original 22 finished, all 11 right. None of them needed the room: they finished in 1,026 to 5,304 generated tokens, inside the 8K wall they had hit the first time.
The other 11 thought to the 32K wall: about 31,800 tokens and 885 seconds each.
11 messages that had answered fine at 8K now failed. Ten thought to the 32K wall. The eleventh was cut off by Ollama after 96 seconds with prediction aborted, token repeat limit reached, the runtime’s own loop guard.
answeredemptyempty at 8K, finished at 32Kanswered at 8K, empty at 32K
At 8K (exp_055)
22 empty: 11 lures, 11 genuine messages.
At 32K (arm C)
22 empty again: 11 of the original 22 and 11 that had answered at 8K, one of them cut off by Ollama's own repeat guard. The 11 that finished were all right.
One cell per message, in corpus order, the same cell in both grids. Four times the room finished half the empties and emptied as many answers that had worked. Hover a cell for the message id and its fate.
The prompt, the seed and the temperature were unchanged. Changing only the context size changed the generated text on 115 of the 188 messages that finished in both runs; 73 came out identical. Seven lures moved between “suspicious” and “likely scam”, two lures were newly caught, one genuine message was newly flagged and one false alarm cleared. We had registered a test for exactly this: a context change that moves verdicts it did not need to move is a different reader, not a fix. It failed.
The wall is where they end. The thinking text shows why they do not end sooner: they loop. We measured repetition as the share of the last 200 lines of the thinking that repeat a line written earlier.
At 32K, every one of the 21 runaways ends in a loop. In 19 the share is 92 % or more (median 99 %). One of the other two writes no line breaks at all: its last 20,000 characters hold three distinct 40-character chunks out of 500.
At 8K the same loops are younger. Median 99 %, but 14 of 21 above 92 %. One message was at 45 % when the 8K wall cut it and at 99 % by the 32K wall.
The commonest loop is a mis-copied id. The footprint lists a notes page as A-0a9fbf and five contact items numbered C-. The model writes C-0a9fbf, checks the footprint for it, writes “C-0a9fbf is not there”, and checks again. One answer writes that id 1,745 times. The invented id appears in 11 of the 21 runaways at 8K, against 14 of the 199 answers that finished.
So the fix in arm F is not a budget. It is a detector with one test, “did an answer come out”, and a second call with the thinking switched off. The retry gave arm T’s verdict on all 21 messages it was asked.
Arm T is thirteen times faster and answers everything. It also flags 24 of the 110 genuine messages, including 15 of the 20 from young domains, where F flags 5. T and F disagree on 38 messages. On 19 of them only F is right (17 genuine messages T flagged, 2 lures T missed); on 5 only T is right; on 14 they differ only in strength. Thinking buys precision. T catches one lure more than F and cries wolf three times as often.
The cost sits in 21 of F’s 220 messages: each spent about 160 seconds thinking into the wall and 3 seconds on the retry. The other 199 took a median of 35 seconds, with a 95th percentile of 80 s, so the fallbacks alone set the run’s 95th percentile at 162 s. The budget curve from the first pass says what a plain token cap would have done: every answer that finished did so within 7,000 tokens, so a cap there saves about 4 seconds per runaway; a cap at 4,000 saves about 65 seconds but sends 7 answers that would have finished to the thinking-off retry.
a message answered within the contexta message that thought to the wallaborted by Ollama's repeat guard
One dot per message, stacked where they fall, on a log axis. Arm T answers in 3 s. Arm F's 199 first-pass answers sit around 35 s; its 21 fallbacks spend about 160 s thinking into the 8K wall and 3 s on the retry. Arm C's 21 runaways take about 885 s each. The two rules are H4's: median at most 45 s and 95th percentile at most 180 s.
What this does not show. This is the reader-alone call; the next experiment hands the model our rules as evidence and a longer prompt, and its empty answers are a declared measure of its own. One model, one build, one runtime: gemma4:26b Q4_K_M on Ollama 0.40.2; a loop guard inside the runtime would be a different fix, and Ollama’s own fired once here, at 32K, never at 8K. Synthetic messages from one family of writers, at temperature 0, one pass: the rate of about 10 % held on two configurations, which messages loop did not. The loop figures are post hoc; the repetition measure was chosen after reading the runaways, and it measures repetition, not intent. The run moved from macOS 26.5.1 to 27.2 between the two experiments, and at a fixed context nothing changed: 193 of 193 verdicts, 20 of 20 empties.
So what.
The reader in our review now answers every message: 198 → 220, balanced accuracy 0.882 → 0.914, false alarms 8 → 9. The price is one message in ten taking 2.7 minutes instead of 35 seconds.
“Thinking needs room” needs a qualifier. On a bounded task, more room is not a fix you can rely on: here it finished half the empties and broke as many answers that had worked. We have added a dated note to the October post.
Do not raise the context to fix a loop. Our bot lost answers the same way in exp_052 and exp_053. The production cap stays at 8,192, now for a second reason beside the slowdown an uncapped context caused.
The context size is part of the model’s identity. Same weights, same seed, same prompt, a different num_ctx: different text on 115 of 188 messages. Every comparison between runs has to pin it. Our next experiment runs the same weights on three chips, and now has to run them at the same context, or the chip is not the only thing that changed.
Thinking text is private by default. The loops copied and garbled strings from the messages, including addresses and a phone number that could be real. No scorer reads that text. It is recorded, hashed in the published record, and held back.
Two seeds, each to be registered before use: a loop detector on the output stream, which could end the 160-second runaways early without cutting an answer that would have finished; and attribution ids a model cannot confuse across item types.
The first attempt at that experiment ran at a fraction of the machine’s speed: 56 tokens a second at the first message, 8.5 by the fortieth. The system’s thermal pressure level read 4, the highest, and stayed there with the machine idle, drawing 36 mW, every die sensor under 55 °C. It was not heat. A staged macOS upgrade had written new firmware while the old system still booted; the firmware version was newer than the boot loader’s. Finishing the upgrade put the level at 0 and the speed back at 58 to 60 tokens a second. The run was aborted, kept unscored in aborted/, and the launch block now records the thermal level every minute, with a rule for what a raised level does to the timing claims. Amendment 1.
Registered, not yet run: the same weights on three chips#
Update, 19 November 2026. This experiment was stopped on 11 November and never run: the phone arm’s app was not built, and the Mac arms were not run. The registration and the kit stay in the folder as written. The sentence above that calls it our next experiment is from 2 November.
Our 4B decision model, the same quantised file, answering the same 331 sealed enquiries on the mini’s M4 Pro, a MacBook’s M5 Max and an iPhone 18 Pro’s A20 Pro, through llama.cpp on all three. Band and action by the same frozen rules on every arm. The question is whether a decision model’s answers survive the chip, and what the phone costs in time. This week’s result above adds a condition: the context size has to be pinned identically on every arm. exp_059.
The lecture study bot reads names, and a second author#
A Telegram bot that answers questions about a recorded psychology lecture course got a lexical index beside its embeddings: stems for Russian and English, a key for names, BM25, fused with the semantic ranks. Three months of its log said the misses were exact names. On 29 real questions it went from 19 right to 29. A second corpus joined it, Mamardashvili’s two lecture courses on Proust, in Russian; the English translation we made for it was rejected by the rubric fixed before the run (78 % of sampled units read right against a 97 % bar), so the bot shows the Russian and uses the rejected translation only to find passages. Embedding windows over whole sentences took recall of a sentence from the back half of a lecture from 11.6 % to 80.1 % at five results. Two things learned about gemma4:26b on the way: at temperature 0 a retry reproduces a rejected output exactly, so a retry has to change the request; and it misspells proper names at decoding time (“Proust” came out wrong in 53 of 2,729 units), which no prompt rule prevents and a glossary check catches. Log, 28 October.
Let the AI Ask the Questions. Malaga-AI at Google’s cybersecurity centre in Málaga: a developer’s survival guide and thirty-year-old change theory, ending in the same place.
A field note: does this record publish its failures?#
Prompted by reading, not an incident: The Economist’s package on AI in science reports a record filling with fluent output faster than it can be checked, and the signal reviewers used, the quality of the writing, inverted. So we checked our own record against the bias it describes. 14 of the 52 experiment rows in the Chronos index say a hypothesis failed. The rule that survives is the one that never read the prose: a claim with no artefact under chronos/ is commentary. Field note.
this week10changes
input · real2a colleague's report; three months of a bot's questions
input · test7failures found by our own experiments
input · reading1a lecture course added to the study bot
The counts are the point of the log: a change that starts from something real is worth more than one that starts from a test.
The week in the log’s own count: 10 changes · inputs real 2, test 7, reading 1. The one thing worth remembering: raising the context did not fix the model’s empty answers, it moved them; a retry without thinking did.
Every prompt, sample, verdict, token count, control and scorer: exp_057 and exp_060. The messages, the person and every domain in exp_060 are fictional. The machine-wide egress logs and the thinking text of the two thinking arms are held back and hashed in the record. This post was drafted with Claude from the published record; every model under test ran locally, no cloud model judged anything here, and the Opus figure is exp_055’s, where Opus was an arm, not a judge.