Skills compress. Facts don't.

Three tags, a new port, and MoE that no longer has to fit

718 pull requests merged between midday 6 September and 10 October, from build b10822 to b11540 — about 150 a week, faster than the summer's pace. Three versions were tagged in the window: v0.4.1 on 14 September notes, v0.5.0 on the 23rd notes and v0.6.0 on 5 October notes, so none of them is "the release" — and several of the changes below merged after v0.6.0 and exist only in nightly builds. Grouped by what changes for someone running the thing.

A MoE bigger than your VRAM gets a cache

The change most likely to alter what people see is a GPU-side LRU cache for mixture-of-experts weights that live in system RAM #29887. Until now, a MoE too large for the card ran its offloaded experts from host memory on every token. The new --moe-cache-mib N flag keeps recently used experts on the GPU and uploads only the misses; it engages only for small batches, so it is a decode feature, and the author suggests sizing it at about 10% of total expert size. Multi-GPU support followed a day later #30112.

The reported numbers are on Qwen3.8-Flash-Next at Q4_0 (93.7 GiB, of which 65.4 GiB is experts) on a 16-core EPYC over PCIe 4.0, decode against the existing --fit path:

One machine, one model, one author, so the magnitudes are claims. The detail that should be on every summary of this and usually will not be: in the multi-GPU table, prompt processing drops to 0.91× and 0.73× of the baseline. It is opt-in, it is per GPU, and it is not in any tagged release yet. If you run a big MoE on one consumer card for chat, it is worth trying on a nightly; if you batch long prompts across two cards, measure before you keep it.

The same problem was attacked downstream, and drew more attention than anything in the main repository: Strata, an MIT-licensed one-click installer and engine for Windows and Linux that "uses parts of llama.cpp / ggml", runs Qwen3.8-Flash-Next on a gaming PC with a 12 GB card and 32–64 GB of RAM, behind an OpenAI- and Anthropic-compatible API on localhost. Its author reports 94 t/s decode and 2,650 t/s prompt processing at 32K on an RTX 5070 with the Q2_0 quant, and 53 t/s at IQ3_S repo. It passed 20,000 GitHub stars in two weeks. Read §2's quantization audits beside the Q2 numbers: they found models above about 3B mostly robust at Q2 where small ones were not, though the largest they tested was 14B, but "validation must be per artifact".

Speculative decoding grows up: correct above zero, and fast on a Mac

Two changes turn speculative decoding from a datacentre trick into something a laptop owner should switch on. First, on Apple GPUs without the tensor API — M1 through M4 — the 2–16-row matrix multiplies that verification needs were running on mat-vec kernels whose cost grew with every row. The author states plainly that on an M3 Ultra, DFlash2 decoding of Qwen3.8-27B was therefore slower than plain decoding on master. A few-row MMA kernel fixes it #29869, extended to the remaining quant types two days later #30065. Reported on an M3 Ultra with a Q4_0 target and a Q8_0 drafter: code at temperature 0 from 30.2 to 110.0 t/s, prose from 16.8 to 62.6, against 32.1 for serial decoding, which is unchanged. If you tried DFlash on an M-series Mac this summer and concluded it did not help, you were right, and you should try again.

Second, speculative sampling is now correct at temperature. Model-based drafters used to offer only their top token, and the target accepted it only on an exact match, so acceptance collapsed as temperature rose. The standard rejection-sampling construction is now available behind --spec-draft-sampling probabilistic #27694, keeping the output distribution exact. Gains rise with temperature — a Llama-3.1-8B target with a 3B draft goes from +0.07% at T=0.2 to +16.6% at T=0.9 on an RTX 5090 — and some configurations regress slightly at low temperature, which is why the default stays greedy. It applies to simple drafts and MTP; the author reports DFlash does not benefit. It also shipped a bug: n-gram drafts near the end of a reply were fully rejected at T > 0 until #29924 two days later.

New architectures, and one that was quietly broken

GLM-5.3-Flash landed on 30 September #27773, described by the author as a 320B text-and-vision hybrid of 34 KDA linear-attention layers and 11 DSA layers, reusing the KDA and hyper-connection code from earlier models; MTP followed a week later #29928. Qwen3.8-Flash-Next, whose support issue 04 reported arriving, turned out to be "broken on current master" in the words of the PR that fixed it on 1 October #29751. The same day it gained MTP drafting, reported at an overall 1.55× decode on a DGX Spark, ranging from 1.43× to 1.67× by prompt category #29761. If you formed an opinion of that model in llama.cpp in September, form it again.

Smaller, but it touches every hybrid model people run: Gated DeltaNet's q/k normalisation differed slightly from the reference implementations, affecting the Qwen3.5 and 3.8 hybrids, Kimi-Linear and Kimi-K3, among others #28068. The measured KL divergence change is tiny; it is the kind of fix you get for free by updating.

The genuinely new thing is a model class: JEV-style decision models, which answer typed questions with a probability per option instead of generating text (§3 has the story of TypeSafe's Jev and its open imitators). The runtime adopted Jev's own wire format, a /v1/systemone server endpoint, with Laya, Julia-1, lev, Kev and OpenJev supported from the first PR, whose author calls the open ones "fancy wrappers around traditional embedding models" #29818. They were followed within nine days by Cloudflare's Clef #29831, Perplexity's pplx-decider #30044 and Liquid AI's d1 models #30110, among ten PRs. Ten PRs in nine days is a category forming, not a one-off. Also merged: a ternary 20B-A1B MoE, Maple, CPU-only for now #27000, and a looped model, HRM-Text #27625 — worth noting given how much of §2 is about looped models.

Long context, on every backend

Sparse flash attention, which issue 04 covered landing for CUDA and Metal, spread across the window to Vulkan #28105, SYCL #28796 (off by default, behind GGML_SYCL_SPARSE_FA=1), CUDA for Qwen3.8-Flash-Next #28770 and Vulkan with a quantized KV cache #29639. The shape issue 04 described has not changed: reported gains are 1.08× prefill at 10K and 1.26× at 100K on Qwen3.8-Flash-Next, and nothing at chat depth. One thing to know if you run DeepSeek-V4: #28770 switched its sparse path off because of a batch-dependent gate, and prefill was turned back on two days later #29298.

Dense long-context prefill got faster in three places. Metal's tensor API now drives flash attention on the M5, reported at 174 to 253 t/s for pp512 at 32K depth on an M5 Pro, with decode unchanged #29570. CUDA's two-stage FA kernels now schedule whole tiles, from +1.4% to +33.5% on 64K-token prefill on a DGX Spark and at most +4.8% on an RTX 5090 #29435. And ROCm on RDNA4 went from 164 to 399 t/s at 150K depth on Qwen3.5-27B, partly by fixing a bug that kept the head-size-256 kernels from being selected at all #28102.

Elsewhere, in one line each: CPU prefill on k-quants got a tiled VNNI kernel, reported at 3.8–7.0× — a GEMM microbenchmark, not end-to-end throughput #27851; AMD RDNA3 and 4 got int8 matrix-core matmuls under Vulkan, 1.25× on Llama-3-8B prefill on Strix Halo #27952; gpt-oss decode roughly doubled on Intel Arc Pro under SYCL on Windows, in the window's last build #29809; direct-IO loading stopped holding each tensor twice, halving peak RSS on a DGX Spark #29749; and Qualcomm's Hexagon NPU backend is now a steady track, with 44 PRs in the window and Snapdragon builds in the releases #29007.

Three changes that will break a working setup

The server's default port is now 9931, not 8080 #30159, from build b11521 on 9 October. Docker images keep 8080 inside the container. Anything with localhost:8080 hard-coded that updates a native build needs --port 8080. The deprecated --mmap, --mlock and --direct-io flags are gone, replaced by --load-mode #28334, so old launch scripts fail to parse from v0.4.1 on. And sessions saved by older builds no longer load after a session-format bump that ships in v0.6.0 #28498.

On the server side, the useful additions: context checkpoints now survive slot save and restore, so restoring a slot on a hybrid or sliding-window model no longer reprocesses the whole prompt #26004; --host accepts a list of addresses and Unix sockets #28690; causal-LLM rerankers no longer fail on documents longer than the physical batch #28876; and the web UI became a model manager that downloads, loads, unloads and deletes models #29583.

Skills compress; facts don't

Five weeks of arXiv, swept by week so no part of the window was truncated, plus Hugging Face's daily papers — 1,084 of them in window. Two literatures that do not cite each other converged on the same asymmetry. Distillation moves how a model uses what it knows, not what it knows. Aggressive quantization keeps the fluency and loses the facts first. And in both, the standard guard metric measures the part that survives.

On-policy distillation reorganises; it does not add

Issue 04 asked whether OPD's teacher was doing anything at all. This window answered from four independent directions, with four different methods, and the answers agree.

The cleanest is a controlled synthetic study that varies the teacher's extra facts and extra compositional skill separately. Across four models from three families, reverse-KL OPD transfers the skill to unseen reasoning structures but "transfers minimal factual knowledge"; switching to forward KL restores factual transfer, and the same asymmetry shows up on real factual QA and competition maths 2610.09639. A mechanistic study with sparse crosscoders reaches the same place from inside the network: OPD "neither creates features nor passes on the teacher's own", leaving the firing rates of over 98% of the student's frequently used features within 20% 2609.35210. Framing the teacher as an implicit reward model, a third paper finds OPD "improves performance without expanding the student's capabilities" — it makes correct responses easier to sample, and when the implicit reward is misaligned, it rewards overlong, repetitive rollouts 2610.03185. And a fourth traces OPD plateaus with large teachers to a vanishing learning signal: relative parameter change of 0.025–0.098% and layer-wise similarity above 0.98, against far larger loss reductions when the teacher is the student's own RL-trained successor 2610.11247.

The recipe papers line up behind it. A ±1 reward on tokens where the teacher's probability is above or below the student's "reproduces almost the same training mode as OPD with reverse KL" 2609.33791. A systematic study finds the rollout policy — the thing that puts the "on-policy" in OPD — "does not necessarily play a central role"; KL direction and learning rate do, and on-policy's advantage "does not reliably persist after subsequent RLVR" 2609.35259. Scaling laws for same-family OPD find peak score improves with teacher size "only up to roughly the student's scale", that "at a matched gold score smaller teachers transfer better", and that in every weak-to-strong pair observed the student beat its teacher 2609.32722. Multi-teacher OPD does not beat a student taught by the best single specialist, because instruction-following feedback is spread wider and dominates the updates 2609.35347.

None of that makes OPD useless; it makes it a different tool. If a model is reorganising skills it already has, cheap OPD is the right OPD, and three papers made it much cheaper: supervising 0.1–1% of tokens matches full OPD 2609.24432; restricting cross-tokenizer OPD to a student-chosen top-16 slice of the shared vocabulary matches the full version 2610.08448; and SparseOPD cuts backward memory by 70.5% at 99% gradient cosine similarity 2609.34386. Two failure modes with fixes are worth knowing if you run it: students and teachers can put their stop probability on different EOS tokens even with identical declared stop sets, which inflates length until equivalent EOS tokens are treated as one stop action 2609.20511; and the pointwise clipping adopted from the original on-policy self-distillation recipe can push token probabilities away from the teacher, producing repetitions that persist to the end of the response 2609.38995.

The most-upvoted paper of the theme points the other way, and it is worth reading for that: RIDE treats the RL teacher's change from its pre-RL checkpoint as a direction in hidden-state space and extrapolates beyond the teacher along it, approaching or exceeding the RL teacher on all four pairs tested 2609.36484. Note what it extrapolates: the RL residual, a skill. It is consistent with the rest of the section, not a counterexample.

Quantization: the damage is somewhere the guard metric does not look

Issue 04 ended with the third consecutive week in which 4-bit passed the standard check and failed a behavioural one. This window produced a cluster of audits that measured exactly that, several of them on llama.cpp's own formats.

Saying, Not Knowing audits 27 GGUF artifacts from 13 families, 0.35B to 14B, down the published ladder to Q2_K, on 429 rare English words, asking two questions: can the model still use the word, and can it still define it? In every sub-2B artifact at Q2, definitions fall 20–67% below the artifact's own baseline, typically several times the loss in usage. Parameter count predicts the damage (Spearman ρ = 0.72); tokenizer vocabulary does not (ρ = 0.12). WikiText-2 perplexity cannot tell the cases apart: two artifacts with near-identical Q2 perplexity penalties, 44.7% and 47.6%, lose 3.6% and 43.6% of their definitions respectively. The reassuring half: Q4_K_M "remains lexically clean at ≥1B" 2610.04403.

The same shape at other scales and on other behaviours. Ternary models trained from scratch retain as little as 6% of an identically trained fp16 model's factual capacity while perplexity rises only 1.4–1.6× — at 50M parameters and below, so a mechanism, not a verdict on BitNet-class models 2609.32902. Measuring full-vocabulary divergence rather than accuracy, a 120-run matrix finds accuracy "unstable, non-monotonic" under progressive llama.cpp quantization, and mixed-precision Q4_K generally closer to BF16 than uniform Q4_0 at similar size 2609.07664. On agentic tool use, three Polish models all fall off a cliff between 3 and 2 bits — 0.716 to 0.045 for the 11B — but fail in different ways: the pruned 7B fails long, the 11B confabulates a final answer at step one 2609.32042.

Three findings about the tools of quantization, rather than its results. Lower reconstruction loss can degrade a model on the same calibration data it was minimised on 2610.11226. A mixed-precision study found one run that improved a block's own objective 4.6× while perplexity rose 32×, and a rule based on which matrix a weight sits in beat every sensitivity estimate they computed — 96.4% of weights at 4.5 bits per parameter within 4.4% of full-precision perplexity on Mistral-7B 2609.34866. That echoes issue 04's finding that intuitive theories of where quantization damage lives predict nothing. And the most hands-on result of the window: the documented export pipelines for BitNet, Falcon-E and BitCPM cast latents to bf16 before ternarising, bf16 rounding lands values exactly on the threshold, and ties-to-even maps them to zero. At fine-tuned endpoints this lowers greedy GSM8K strict accuracy from 58.79% to 0.78% for Falcon-E-1B — the export silently reverts the fine-tune 2610.07853.

Quantization you can use

The window also produced quantization work aimed straight at the runtime in §1. Disaggregated Quantization, from IST Austria, starts from the observation that prefill is compute-bound and rewards low-precision arithmetic while decode is memory-bound and rewards compact weights, and uses different formats for each. With released 1-bit Qwen3.8-27B GGUF decoders, training an NVFP4 prefiller improves accuracy by 32.5 points on MMLU-Pro without touching the decode checkpoint, and streaming prefill weights from SSD gives a reported 1.78× time-to-first-token speedup at 8K in llama.cpp 2609.26333. QATFactory is an open framework for quantization-aware training and distillation that exports directly to llama.cpp's Q4_K and to vLLM without a second lossy conversion; on Qwen3.5-9B its QAD reaches 68.9% average accuracy under NVFP4 against 65.4% for the best post-training method 2609.39223. Tetra serves Leech-lattice codebooks at about 2.7 bits per parameter and, at 4B, scores 23.6 points above llama.cpp's IQ2_XXS on its benchmark 2609.35465. And issue 04's Minima quantized hybrid models' Gated DeltaNet weights; STEPQuant quantizes their recurrent state, which becomes the memory bottleneck under concurrent serving, closely matching FP32-state accuracy at a nominal 6-bit budget and cutting total serving memory by up to 68.7% in SGLang 2609.38169.

Looped models become an efficiency axis

Models that run the same block several times per token — looped, or recurrent-depth, models — went from about 1.5 to 9.3 papers per thousand cs.CL and cs.LG submissions across the window, and were still rising in the last week. The papers have moved from whether looping works to how to serve it. A scaling law that jointly models recurrence and sparsity finds a looped MoE matching a roughly 2× larger non-looped one on reasoning at matched training compute 2609.40316. Letting only the first loop write a KV cache, with later loops reading it, improves perplexity while using 76–79% less context memory at 150M–1B 2610.02383. Shallow loops can draft for deeper ones, a training-free self-speculation reported at 2.42× on Ouro-2.6B and 3.54× on Huginn-3.5B 2609.23033. And the intuition that rounding error accumulates loop after loop "holds only for loops that never settle" 2609.39277.

The paper that connects it to the rest of this section: a controlled study finds recurrence can improve reasoning beyond the training horizon while degrading knowledge 2609.36636. It is one paper, and the weakest leg of this issue's thesis — but it is the same asymmetry a third time.

Serving: two audits and a 35B MoE in 3 GiB

The other audit is for anyone running a model with chunked KV compression: compressing fixed windows into fewer entries gives every token a new coordinate, its phase relative to the window boundary, and long-context retrieval in large open-weight models can differ by up to 40 points across phases — "high average accuracy can coexist with systematic positional failures" 2609.36322. In a similar spirit, a methods paper argues that current evaluations of KV-cache reuse for RAG systematically inflate how well it works 2609.31415.

Edge0 is the most-starred brief-relevant repository of the window, at over 4,000: a per-layer predictor guesses the next layer's routing one token ahead, and that guess is the routing, so the experts staged from SSD are exactly the experts used. On a single 24 GB machine it serves a 35B MoE at 20 tok/s inside 3 GiB of peak active memory, "within a few points" of its fp16 teacher 2609.18063. It changes the routing and needs a recovery adapter, so it is not a drop-in for an existing GGUF — read it beside §1's expert cache, which solves the same problem without retraining. Two drafting results close the section: DLoop keeps drafting while the drafter is confident instead of verifying after every block, reported at 5–41% more wall-clock speedup across EAGLE-3, DFlash, DSpark and MTP modules 2610.07659 — the direct sequel to issue 04's stranded speed-up; and AgSpec drafts from the session and workspace in coding-agent pipelines, reported at up to 4.37× at batch size 1 2610.01108.

A new model class, two price points, and fewer knobs

Technical news from the large labs, every date read off the lab's own post or changelog entry. Five weeks held a new class of model from a startup, three new Claude models, three GPT-6 variants, a Grok, a Mistral flagship, a near-frontier coding model built on an open base, and an announced Gemini 4. Grouped by what changes for someone building on them, not by company.

JEV, and a model class that formed in three weeks

The most consequential launch of the window did not come from a large lab. On 15 September TypeSafe came out of stealth with Jev, the first of what it calls "System One" models: "unstructured state in, typed probabilistic decisions out". You send a state and a schema of typed questions — a choice, a yes or no, a score — and get back a value for each with "calibrated probabilities and confidence scores", in one pass and without generating text. TypeSafe prices input at $0.042 per million tokens with output "FREE (too cheap to meter)", and reports 70–500 ms end-to-end. It is hosted only, in waitlisted early access, and the launch post gives speed and cost multiples but no numeric accuracy benchmarks post. A note on the date: TypeSafe's post currently carries a 9 October timestamp, but coverage dated 16 September reports the company exiting stealth "on Tuesday", the 15th VKTR, 16 Sep, and the open models below cite Jev from 18 September on. Both dates fall in this window.

What happened next is the story. Three days after the launch, Laya shipped: a 421M ModernBERT-large encoder with a decision head that exposes "the same POST /v1/systemone request and response shape as TypeSafe Jev" model card. Five days after, OpenJev, a 27B open-weight model that states it is not affiliated with TypeSafe but follows the hosted Jev API, reports itself "within 2 points of the hosted Jev API" on 10,000 text questions, 84.0% against 85.4%, under a non-commercial licence model card. By the end of September there were JEV-style adapters on Qwen backbones (Kev, lev), a 144M multilingual one (Julia-1), a 0.9B one whose card says "clients written for Jev or Kev work unchanged" model card, and AutoTrust's JEV-27B-VL, a vision decision model on Qwen3.8-27B that its card reports ranked first of 20 on the vision board of a community-run Jev Decision Index model card. Cloudflare, Perplexity, InternLM and Liquid AI followed with their own (§4).

The runtimes converged on Jev's wire format rather than inventing one. llama.cpp's /v1/systemone endpoint, merged on 2 October, "follows the System One format introduced with TypeSafe's Jev model, so existing clients only need a new base URL" post, 2 Oct (§1). OpenAI's Decisions API, in beta from 6 October on GPT-6 Luna, takes text and images and returns typed answers, claimed at ten times faster than its Responses API changelog, 6 Oct. A startup's hosted model, more than a dozen open decision models, an open runtime and a large lab's API, all inside 21 days, is the clearest sign of the window that this is a component people will build with: classification, routing, moderation and agent next-action choices as one forward pass with a probability per option, instead of generating text and parsing it. Two cautions. A calibrated, schema-valid answer can still be confidently wrong; type safety removes parsing failures, not errors. And the evidence is young — the accuracy comparisons are the open models' own, mostly against Jev, on boards their authors or the community run.

The frontier converges on two prices

The mid tier now has a going rate. Claude Sonnet 5.5 launched on 28 September at $2 per million input tokens and $10 per million output post, 28 Sep, the same price as OpenAI's GPT-6 Sol on 22 September and GPT-6.1 Sol on the 29th, both with a 1.05M-token context changelog, 22 & 29 Sep, and the same as the introductory price Google announced for Gemini 4 Argon (below). Grok 4.7, on 21 September, undercuts on output at $2 and $6 with a 500K context post, 21 Sep. The small tier converged too: Claude Haiku 5.5 on 7 October and GPT-6 Luna on 22 September are both $0.10 in and $0.50 out, Haiku for prompts up to 100K tokens post, 7 Oct. And Claude Opus 5.5, on 22 September, came in cheaper than its predecessor at $4 and $20, with a 1M context by default post, 22 Sep. On the consumer side, OpenAI began rolling GPT-6 out to everyone in ChatGPT on 7 October, with an "Intelligent UI" that answers with visuals and interactive elements post, 7 Oct.

Vendor benchmarks for all of these are on their posts, and most are on each vendor's own evaluation suite; one detail is worth repeating because it is unusual: Anthropic reports Sonnet 5.5 above Opus 5.5 on Terminal-Bench 4.0, 70.6% against 66.4%. For anyone choosing a default model, the practical reading is that a $2/$10 model is now where the frontier is priced, and anything above it has to justify itself on your workload.

An open base, post-trained to near the frontier

Cognition's SWE-2, released on 10 September in Devin's desktop app and CLI, is post-trained from Kimi K3, an open-weight model. Cognition reports it within one point of Claude Fable 5.1 on FrontierCode 1.1 Main, 50.0% against 50.9%, at 64% lower cost, and ahead of it on DeepSWE 1.1, 73.0% against 67.4%. Its own table also shows the limit: 27.3% on Terminal-Bench 4 against Fable's 55.8% post, 10 Sep. There is no API and no statement about weights. What matters for this publication is the recipe: a company without a frontier pretraining run took an open base close to the frontier on the benchmarks it targeted, and the spread across benchmarks says exactly how close. The post's date prints as "09.10.26", month first; it was discussed on 10 September.

Fewer knobs, again

Issue 04 noted that GPT-6 Astra would not accept a temperature. That is now the direction of travel across vendors, and every instance is a breaking change for someone. Opus 5.5 returns a 400 if you try to disable thinking; Sonnet 5.5 replaces "disabled" with a new between_tools mode; Haiku 5.5 rejects temperature, top_p, top_k, thinking budgets and assistant prefill outright release notes; and GPT-6.1 Sol has no none reasoning effort model page. If your code sets sampling parameters on every call, a model upgrade is now a code change. The stated reasons vary; the effect is the same: the hosted frontier is becoming a component whose decoding you do not control, which is one more argument for keeping a local model where you need that control.

The gated tier became the normal shape

Issue 04 named "a public model plus a gated sibling for security work" on two instances and declined to call it a trend. Five weeks later it is how the labs ship. Anthropic restructured its Cyber Verification Program into three tiers on 6 October and reports, on its own scenario benchmark, that Opus 5.5 was blocked on every task without enrolment post, 6 Oct; it added a Life Sciences Verification Program on 17 September post, 17 Sep, and its three 5.5 models route higher-risk cyber and biology requests to an older model unless the account is enrolled. Google's Gemini 4 Argon goes to vetted cyber defenders first, and to them without cyber guardrails post, 30 Sep. OpenAI's life-sciences model is trusted-access only changelog, 8 Sep, and Grok 4.7's red-team capabilities are invite-only. Two practical consequences: the same model ID can now answer differently depending on what programme your organisation is in, and Anthropic resumed billing on 24 September for some safeguard refusals that produce no output release notes.

The labs ship agent runtimes

OpenAI's Agents API entered public beta on 10 September, with OpenAI handling session orchestration, compaction and recovery in hosted or bring-your-own sandboxes, and gained computer use on the 29th, the same day GPT-6.1 Sol shipped multi-agent delegation inside a single Responses request changelog. Anthropic shipped compaction on demand (14 September), tools that can be added mid-conversation without invalidating the prompt cache (22 September) and dynamic multi-agent workflows for Managed Agents (9 October); the line worth noting for anyone worried about prompt injection is from 7 October, when Managed Agents' web_fetch started refusing URLs not already present in the session release notes. OpenAI also put agents in front of consumers: Dots, launched on 29 September, are proactive assistants in ChatGPT that keep working across projects and tasks post, 29 Sep. Z.ai open-sourced ZCode, its coding workbench — desktop app, browser interface and terminal agent, with the agent runtime in the repository — under Apache 2.0 on 20 September, and it passed 7,000 stars repo. Google replaced its Antigravity agent on 17 September with a changed built-in tool schema — renamed tools and parameters, breaking for anyone parsing tool calls — and shut the old version down on 5 October changelog, 17 Sep. The item most relevant to this publication: the Antigravity SDK now runs against local models, Gemma 4 on LiteRT or any OpenAI-compatible server, which includes llama-server post, 23 Sep.

Announced, not shipped

Gemini 4 Argon was announced on 30 September with introductory pricing of $2 and $10 and a 1M output-token limit, but as a staged release: defenders first, then the paid API, then wider. At compile time it has no published model ID and no entry in the Gemini API changelog, so treat it as announced, not available post, 30 Sep. Mistral Large 4, a MoE of about 1T total and 52B active parameters with a 1M context, entered public preview on 6 October, and Mistral promises open weights "by the end of the month", licence unstated post, 6 Oct. If they ship, they go in a future releases table; until then they are a promise.

Research, and the rest

Three research items with wet-lab or official-grader validation, which is rarer than it should be. Anthropic ran about 950 Claude agents for 21 hours over a sequence database and found a reverse transcriptase with an accessory gene and a CRISPR-like repeat array, then expressed and characterised it; its function is unknown, and the post says so post, 23 Sep. Google DeepMind published AlphaGenome Atlas, precomputed predictions for about nine billion single-letter variants of the human genome, free for non-commercial use post, 8 Sep, and SynthID Bio, watermarks for protein sequences and structures that survived wet-lab testing without hurting binding post, 30 Sep. OpenAI published new results on open problems in mathematics from an internal frontier model, with the Lean formalizations of the proofs released on GitHub — the formal proofs are the part anyone can check post, 6 Oct. NVIDIA reports Nemotron systems at gold-medal level on IOI 2026, in an unofficial live run, and IMO 2026, graded by official graders post, 7 Oct.

For practitioners, Hugging Face's most useful post of the window: Transformers can now run llama.cpp's Q4_K_M, Q5_K_M and Q6_K quants packed on Apple silicon through ggml's Metal kernels, for Qwen3.5-family models on the main branch only, with throughput shown "close to llama.cpp" in charts that are not like-for-like post, 22 Sep. The GGUF formats are becoming a lingua franca beyond the runtime that defined them.

Meta published nothing on its AI blog for the third issue running; its newest post is still from 27 July. Qwen shipped only image models, and Microsoft no new Phi.

Weights that shipped

Open weights only; specifications and figures are as stated on the model cards, and benchmark numbers are the vendors'. Dates are the Hugging Face repository's creation date; where the vendor's own public date differs — repositories are often created privately first — both are given. The last column is the question this publication cares about: does it run on upstream llama.cpp today.

Of fourteen rows, eight run on stock llama.cpp today — three because they reuse an architecture it already knew, five because support landed after release, the decision models among them. The three most interesting releases — DeepSeek-V4.1-Flash, Ternary Bonsai 2 and Kolibri-1 — all need a fork, a patch or an open PR. Left out deliberately: Qwen3.8, GLM-5.3 and Kimi-K3 are still trending but shipped before the window; large post-trains of existing open bases, such as Nex-N2.5 and Intern-S2, are real releases but outside a brief about what runs locally; and Qwen-Image-2.1 is outside the LLM remit.

What I would actually do

Sorted by readiness, not by how interesting the thing is.