1.26251 — 8 September 2026
Four days after 1.26247, and this one lives mostly under the floor. The visible half is a set of new controls over how a local model loads; the invisible half is the reason those controls are now safe to use.
If you read only one thing: when two things on your machine both want the memory, they now take turns instead of colliding.
Engines take turns with your memory
Every model gezel starts on your own hardware — a chat model, the image reader, image and video generation, transcription — is a separate program that wants a large, specific amount of memory, and until now each of them found out whether that memory existed by trying to take it. When two of them tried at once, one of them lost, usually loudly and usually in the middle of something. On a machine with a frontier-sized model already resident, an ordinary background job asking for a second one was enough.
Each of those programs now reserves its memory before it starts allocating, from a single ledger. If the room is there, it loads as before. If it isn't, it waits — and says so: the engine status reads Waiting for available memory rather than going quiet or failing. A wait gives up after five minutes with an error that tells you what wouldn't fit, and waiting never counts against the restarts gezel allows a crashed engine.
The ledger is shared by every gezel process on the machine, not just the one you are looking at. If you have the installed shared service running and also start a development copy, they book against the same budget instead of each believing the memory is free. Two accelerator rules ride along with it: the total and the graphics budget must both fit, and on machines where the processor and graphics share one pool, graphics commitments are capped at 75% of physical memory even if you set a larger overall budget.
Queueing is fair rather than first-come. A large request that keeps getting passed over takes precedence once four newer, smaller ones have gone ahead of it, so a big model can actually accumulate the room it needs instead of starving behind a stream of small ones. When a resident engine is standing between a waiting request and its memory, it stops accepting new work, finishes what it has, and unloads.
Two honest limits. This is cooperation, not a fence: other applications on your machine can still take memory without asking anyone, and gezel can only watch the pressure and react to it. And it works per machine account — two people logged into the same computer coordinate only if the shared service is installed.
If your installed shared service is older than the app you just updated, you now find out at startup, in a dialog offering to continue without it or to go and get the current installer — rather than discovering it when a chat turn fails.
llama.cpp v0.4, and the controls it brought
The main local engine moved from v0.3 to v0.4, which brings a set of loading choices that used to be one all-or-nothing checkbox. They are in Settings → llama.cpp, they all default to Auto, and they are all worth leaving alone unless you have a reason.
How the model file is read. Memory-mapped, read fully into memory, locked in memory, both, or direct I/O. This is a storage and platform question — a network drive, an unusual filesystem, a machine that pages badly — and it is now answerable without editing anything. Existing lock-in-memory settings carry over.
On-demand loading for very large tensors. Some of the newest models carry a single enormous table that most turns barely touch. Left on Auto, anything over 4 GiB is now loaded as it is used, which is what lets a model whose weights exceed your memory start at all.
Keeping the first layers in main memory. For models split across processor and graphics card, you can pin the dense part of the first few blocks rather than leaving it to the planner.
Speculative decoding. Where a model ships its own draft head — a small predictor that guesses several tokens so the big model can check them in one pass — gezel can use it. Auto turns it on only where it has been measured to pay.
Whether private reasoning is kept. A thinking model's internal working is discarded between turns by default. You can now ask for it to be retained and replayed instead, which costs room in the conversation and helps on long, multi-step work.
DwarfStar learns GLM 5.3, and can see
DwarfStar is the engine gezel uses for the very largest mixture-of-experts models — the ones that run at all only because it streams their expert weights off your SSD instead of holding them in memory. It now supports GLM 5.3 Flash, a 320-billion-parameter model with 18 billion active per token and a one-million-token context window, in a 91 GiB two-bit build. It is aimed at a 128 GB Mac or a DGX Spark-class machine; it is not a laptop model.
It is also the first DwarfStar model that can look at pictures. Its image encoder is a separate download that gezel fetches and verifies alongside the weights, counts in the memory reservation above, and hands to the engine — and images go straight to the model only when that exact matched encoder is loaded. A mismatched pair is worse than an honest text-only model, so gezel will not improvise one.
Also new in the catalog: Qwen 3.8 Flash Next, in a smaller and a higher-fidelity build. It is a preview of the architecture behind Qwen 4, and it is the model the on-demand tensor loading above was built for — a 27 GiB lookup table that can be paged in as needed rather than held resident the whole time. The lighter build is aimed at 64 GB of system memory alongside a large graphics card; the better one wants 96 GB.
What a giant model is actually worth
Two more measured rounds landed on the model scorecard, and one of them answers a question people keep asking: on a machine big enough to run a 284-billion-parameter model, should you?
Measured on a DGX Spark-class machine, DeepSeek V4 Flash at two bits was tested head to head against two ordinary mid-sized models — a 27B and a 35B — across the same four suites. On the basic suite the giant model came out marginally ahead: 8.0 against 7.8 and 7.7. On developer work it came out clearly behind: 5.9 against 6.9 and 6.1. On everyday productivity work it was behind as well: 6.6 against 7.2 and 7.0. And it produced words at 17 per second against 29 and 43.
That is one machine, one quantization and one harness, not a law of nature. But it is exactly what the scorecard exists for: the enormous model is the interesting one to own and the slower, weaker choice for most of what you would actually do with it. The other new round measures a Windows desktop on a Ryzen 9 7950X3D.
Catalogs built from a folder of Markdown
A knowledge catalog is a packaged body of reference material your crew can search — the format went open last release. Building one no longer means writing anything by hand: point gezel at a folder of Markdown and it reads the folder as a book.
Front matter supplies what it has — id, title, summary, aliases, listing order — and anything else you put there is carried along untouched. Missing a title, it takes the first heading, then the filename. Folders become the table of contents with their names tidied up, and a small sidecar file lets you rename, reorder or describe one. Relative links between pages become real cross-references, and images beside your Markdown become part of the catalog.
If your documentation tree already has an outline, gezel uses yours rather than inventing its own. GitBook's SUMMARY.md, an MkDocs nav, Jupyter Book's _toc.yml, and Hugo's section pages and weights are all understood, including their nesting and their ordering. A page the outline forgot still ships, in its folder, with a warning.
And catalogs can carry pictures now — images travel inside the catalog and appear in the reader, served from the catalog itself rather than fetched from wherever they used to live. The format is version 0.6; readers still open 0.5 catalogs.
Smaller things
Codex has permission levels you can set, the way the Claude CLI already did: Plan, Edit, Reviewed and Full, each with a sentence saying what it lets the agent do. Reviewed is the interesting one — it works like Edit, but anything that would reach outside the sandbox goes past an independent reviewer first.
Starting a fresh conversation is a labelled thing, both in the thread picker and on the button beside it, rather than something you inferred from an empty list.
Gezels have hair you can choose. Style, bangs and part, picked from tiles that show the actual figure instead of naming a shape you have to imagine.
Topics in the knowledge browser show how much is in them, counting the documents nested underneath rather than only the ones filed at that level.
The reasoning-effort row disappears for models that have no levels, instead of sitting there as an empty control that reads as broken.
A video model install stops freezing at 100%. The finished signal could be cut off before it reached the screen, leaving a full progress bar on a job that had already completed.
Craftbook checks find their source data. A check comparing a finished report against the data behind it used to fail when the report lived in the artifacts drawer and the data lived in the project files. It now looks in both. A craftbook is a saved recipe for a piece of work.
The document toolset moved to 2.6.1, which returns preview images inline, so a gezel reviewing a slide deck or a PDF can look at what it made rather than describing it from memory.
Catalog content moved to
@bendyline/gilde0.1.60, and the editor libraries to squisq 2.11.3.
For developers
The engine daemon and the product daemon are separate compositions now. The shared machine broker builds an engine context with no Store, no chat manager, no tasks, no terminals, no content index and no credential store — the narrow inference contract it holds cannot resolve a session, run a tool, or start background work. Adding a product endpoint no longer requires remembering to exclude it from the broker.
Memory admission has a documented contract: a loopback-only capacity endpoint carrying reservation ids, byte counts, priorities and process ids and nothing else, over a SQLite lease ledger that makes check-and-reserve atomic across processes and survives a coordinator restart. Broker discovery verifies the signed device identity and pins TLS.
llama.cpp and MLX share their local-turn policy — task classification, repair tool surfaces, retry allowances, history compaction at 70% pressure, and text salvage — with one contract suite run against both real provider loops. The chat manager shed roughly 2,100 lines into a shared local engine runtime along the way.
Four more copied areas got single owners: provider construction and retirement, the Node TLS transport, model inventory and install control in the interface, and document container I/O, each with a thin adapter per caller.
One daemon owns a gezel home, enforced by a single-instance lock taken before any config or store is opened, and config writes serialize per home across store instances. Patch only the fields you mean to change.
The scorecard is one file per sweep. Two branches measuring two different machines used to conflict on a 400 KB sorted array with no semantic disagreement in it at all; a sweep is now its own complete file that nothing else touches.
@bendyline/gezkreached 1.0.0, and the knowledge format moved to 0.6: documents file at the leaf of their topic path with readers rolling descendants up, ordinals order a topic, opaque producer metadata rides along, and image assets are declared, hashed and magic-byte checked.A visual regression harness snapshots the app's main surfaces at desktop, tablet and phone widths in both themes.
A document toolset eval suite that uses the real thing. The hermetic simulators stay for orchestration, but a separate suite installs the actual toolset and requires real conversions, previews and valid saved binary containers — a fake conversion cannot prove an integration.
Locally built llama.cpp binaries are checked against the checkout pin in development, so a stale build cannot quietly answer for a newer engine.
An investigation into a 96-token thinking cap that can end a model's reasoning mid-sentence is recorded under
docs/evals, along with an A/B harness for choosing budgets. Evidence landed; no budget change ships in this release.
Things to see and do after update
If you run models on your own hardware, open Settings → llama.cpp and read the new loading options — you probably want them all left on Auto, but the on-demand tensor setting is what makes the newest oversized models startable at all. And if you have ever wondered whether the biggest model your machine can hold is the one you should be using, the model scorecard now has a direct comparison.