Citations

Yan Desbiens · 2026-07-11 · software · v0.1.0

On context-window overflow, Ollama silently discards the front of the prompt and returns 200 OK: given a 160,689-token prompt against a 32k window it evaluated 16,387 tokens, reported nothing, and the model confidently invented an answer to a question whose ground truth sat in the discarded head. llama.cpp instead returns a hard 400 exceed_context_size_error, which is honest but fatal to an agent turn. ContextPaw is an MIT-licensed proxy speaking both the Ollama and OpenAI APIs that makes overflow honest: it evicts middle-out (preserving the prompt-cache prefix and the system prompt that head-truncation destroys), reports every eviction in the body, the headers, and inline to the model, and recovers llama.cpp 400s by compacting and retrying. We further show that notifying the model of the eviction is insufficient: with three facts buried in the evicted region, a marker stating in plain language that the information was removed still yielded 0/3 recovered facts and three confabulated ones, while summarizing the evicted span with a 1B local model yielded 3/3. Telling an agent it lost information does not stop it hallucinating; the content must be returned.

Code (MIT) · pip install contextpaw · Reproduction scripts

@misc{desbiens2026contextpaw,
  title = {ContextPaw: making LLM context-window overflow honest and survivable},
  author = {Yan Desbiens},
  year = {2026},
  howpublished = {\url{https://yandesbiens.com/blog/contextpaw-silent-truncation/}},
  institution = {Éthiqueia Québec inc.},
  version = {v0.1.0},
  note = {Reproducible benchmark, Éthiqueia Québec inc.},
  url = {https://yandesbiens.com/blog/contextpaw-silent-truncation/},
}

Yan Desbiens · 2026-07-11 · article

We report a negative result from a long-running autonomous cognitive agent (Hermes/NeuroArch) whose idle reasoning loop executed 27,834 cycles over several months on local hardware. The system did not accumulate knowledge; it converged on unfalsifiable certainty. Belief revision reported an identical result in 300 of the last 300 cycles (606 strengthened, 0 contradictions, 0 merged, 0 decayed), leaving 207 beliefs at confidence >= 0.99. We identify the full mechanism. A monotonic strengthening rule selects on a historical evidence counter that is never re-evaluated; a staleness-based decay exists but never fires, because the evidence-writing path resets the same updated_at timestamp the decay reads, and additionally un-archives archived beliefs — so manufacturing evidence for a belief is what makes it immortal. Of 882,602 evidence rows, 0 are CONTRADICTING (the schema supports the type; it was never used) and the contradictions table is empty. Critically, the strengthening path writes confidence without emitting an audit event: the per-belief log records 5 reinforcements against roughly 16.9 million performed, so the system was blind precisely where it mattered. 31.3% of ratchet-eligible beliefs claim evidence that has zero corresponding rows. The self-generated fine-tuning corpus (923,789 examples in one shard) contains only 8,858 unique texts (0.96%), 13.3% empty, and is 85.4% self-referential. The failure is architectural rather than a defect, and requires the conjunction of four common design choices; removing any one stalls the ratchet. Practical recommendation: alarm when an autonomous system reports zero contradictions.

Forensic report · Figures

@misc{desbiens2026ratchet,
  title = {The certainty ratchet: what an autonomous cognitive loop converges to when nothing can prove it wrong},
  author = {Yan Desbiens},
  year = {2026},
  howpublished = {\url{https://yandesbiens.com/blog/hermes-certainty-ratchet/}},
  institution = {Éthiqueia Québec inc.},
  note = {Reproducible benchmark, Éthiqueia Québec inc.},
  url = {https://yandesbiens.com/blog/hermes-certainty-ratchet/},
}

Yan Desbiens · 2026-06-29 · benchmark · v0.1.0

A single consumer RTX 4090 (24 GB) pretrains ForgeLM's entire 30M-500M model family from scratch. We measure the real training envelope — VRAM, throughput, and tokens/day per config — with `forge plan` (real forward+backward+optimizer steps, torch.compile off as a conservative floor), and report the loss curve from an actual 120M run (cross-entropy 9.65 -> 2.78 over 9.04B tokens, ~20h wall-clock at a sustained 126k tok/s). The practical cost beats the spec sheet: the real run held 126k tok/s at 11.6 GB versus the planner's 84.5k tok/s at 15.8 GB, and VRAM is non-monotonic in parameters (250M fits in less than 120M because it runs a smaller micro-batch). Engineering numbers only — model-quality metrics (perplexity, HellaSwag, ARC) are left as honest 'run it' placeholders. The 24 GB ceiling is real: 500M at 20.4 GB OOMs against a live desktop session.

Code + one-command repro · Loss curve

@misc{desbiens2026forgelm4090cost,
  title = {What it costs to train an LLM from scratch on one RTX 4090},
  author = {Yan Desbiens},
  year = {2026},
  howpublished = {\url{https://yandesbiens.com/blog/forgelm-4090-cost/}},
  institution = {Éthiqueia Québec inc.},
  version = {v0.1.0},
  note = {Reproducible benchmark, Éthiqueia Québec inc.},
  url = {https://yandesbiens.com/blog/forgelm-4090-cost/},
}

Yan Desbiens · 2026-06-27 · benchmark · v0.3.0

Topic-scoped retrieval (Proof Drop #2) wins decisively when the topic is known, but production has no oracle: a router must pick the scope. We replace the oracle with the cheapest router that could work — one centroid per topic subtree (the mean of its items, already held by the store) — and measure end-to-end retrieval in Fractal Memory (FMM) on the same synthetic hierarchy (16 domains x 8 subtopics, dim 128). When topics are separable, the router is nearly free (~0.002 ms/query, ~4000x cheaper than the 8 ms flat scan it replaces) and cashes the win: at 128k items a top-3 centroid router recovers 98% of the oracle recall (0.965 vs 0.985) while staying ~60x faster than flat; top-1 is ~159x faster at 92%. As topics overlap, realized recall falls along a continuous curve that tracks routing accuracy — from the oracle ceiling toward chance (top-1 routing accuracy 0.07 at high overlap). The tie-back: Proof Drop #2 ran at exactly that high-overlap regime, so its oracle advantage, though real, was uncashable by a trivial router. Routing quality gates the locality bet; a learned router is the next proof. Embeddings are synthetic; the claim is the shape (routing accuracy gates realized recall) and that centroid routing is essentially free.

Code + one-command repro · Figures

@misc{desbiens2026fmmrouter,
  title = {Does a cheap router cash the locality bet? Centroid routing for topic-scoped memory},
  author = {Yan Desbiens},
  year = {2026},
  howpublished = {\url{https://yandesbiens.com/blog/fmm-router/}},
  institution = {Éthiqueia Québec inc.},
  version = {v0.3.0},
  note = {Reproducible benchmark, Éthiqueia Québec inc.},
  url = {https://yandesbiens.com/blog/fmm-router/},
}

Yan Desbiens · 2026-06-27 · benchmark · v0.2.0

We benchmark topic-scoped retrieval against a flat scan in Fractal Memory (FMM) on a synthetic hierarchical corpus (16 domains x 8 subtopics). As the store grows to 128k items, a flat vector scan degrades on both axes: latency rises ~linearly (8.3 ms) and recall@k falls (0.48 to 0.155) as cross-topic distractors accumulate. Restricting search to the query's subtree is sublinear and removes distractors: leaf-scoped retrieval is ~164x faster and ~3.7x more accurate than flat at 128k. The cost is strict: a misrouted scope (wrong topic) has recall 0.0. Hierarchical memory is a bet on routing locality — it pays only when the correct region can be addressed, making the topic router the next thing to measure. Embeddings are synthetic; the claim is the relative advantage and scaling trend.

Code + one-command repro · Figures

@misc{desbiens2026fmm,
  title = {Hierarchical scoping beats flat semantic search: topic-scoped retrieval in Fractal Memory},
  author = {Yan Desbiens},
  year = {2026},
  howpublished = {\url{https://yandesbiens.com/blog/fmm-benchmark/}},
  institution = {Éthiqueia Québec inc.},
  version = {v0.2.0},
  note = {Reproducible benchmark, Éthiqueia Québec inc.},
  url = {https://yandesbiens.com/blog/fmm-benchmark/},
}

Yan Desbiens · 2026-06-27 · benchmark · v0.1.1

We benchmark Unified Fractal Memory (UFM), a residency manager that treats GPU VRAM and CPU RAM as one elastic pool, on a routed Mixture-of-Experts whose expert bank exceeds device memory. On a 23.5 GB RTX 4090, the standard all-on-GPU placement OOMs at a 24 GB bank; UFM runs the same model holding VRAM at 19.6 GB. When the active working set fits the VRAM budget, UFM matches baseline throughput within ~1% and is ~240x faster than naive per-call CPU offloading; when every expert is touched every step (no locality), UFM is transfer-bound and offers no speedup over naive streaming. UFM is a bet on routing locality, not unbounded memory.

Code + one-command repro · Benchmark report · Figures

@misc{desbiens2026ufm,
  title = {Unified Fractal Memory: running a routed model larger than VRAM on a single consumer GPU},
  author = {Yan Desbiens},
  year = {2026},
  howpublished = {\url{https://yandesbiens.com/blog/ufm-benchmark/}},
  institution = {Éthiqueia Québec inc.},
  version = {v0.1.1},
  note = {Reproducible benchmark, Éthiqueia Québec inc.},
  url = {https://yandesbiens.com/blog/ufm-benchmark/},
}