The Base-Rate Correction

The test is unusually clean for this genre. Lesions came from MILK10k (ISIC, public since 2025), each photographed twice — a clinical close-up and a dermoscopic image. 200 lesions, every one histopathology-confirmed: 100 that must not be discharged (30 melanoma, 25 BCC, 25 SCC including Bowen’s, 20 actinic keratosis) and 100 that were safe to discharge (50 benign naevi, 50 seborrhoeic keratoses). Because every lesion was biopsied — including the benign ones — the set is harder than clinic: a mole that was cut out is a mole that worried a clinician. Both LLMs got both images, one prompt, default settings, six possible diagnoses plus “unsure”, and an explicit discharge question. Neither model refused a case.

Metric (n=200)	GPT-6 Astra	Claude Fable 5.1	Inception v3
Correct first choice	84 (42%)	85 (42%)	125 (62%)
Correct first or second	134	138	173
Melanoma as first choice (of 30)	8 (27%)	11 (37%)	13 (43%)
Naevi correct (of 50)	16 (32%)	33 (66%)	37 (74%)
Seborrhoeic keratosis (of 50)	13 (26%)	6 (12%)	26 (52%)
BCC (of 25)	25 (100%)	18 (72%)	24 (96%)
SCC (of 25)	12 (48%)	5 (20%)	16 (64%)
Actinic keratosis (of 20)	10 (50%)	12 (60%)	9 (45%)

The clinical sting is in the case that opens the post: a sub-0.8 mm invasive melanoma on the ear with very little pigment. Both LLMs called it a seborrhoeic keratosis and said the patient could be discharged. The CNN called melanoma. In a second example, GPT-6 Astra called a low-pigment invasive melanoma BCC with 95% confidence.

This is the most important table in today’s briefing, because it separates two different kinds of failure that are usually reported as one.

Model	Over-called diagnosis	Called	Actually present	Contained
GPT-6 Astra	BCC	75	25	14 of the 30 melanomas
Claude Fable 5.1	Actinic keratosis	53	20	not itemised in the post
Inception v3	Naevus / seborrhoeic keratosis	8 + 6	—	of its 17 melanoma misses

GPT-6 Astra’s BCC recall is 100% and its BCC precision is terrible, and those two facts are the same fact: it learned that a pigmented lesion worth photographing is usually a basal cell carcinoma and stopped discriminating. Claude Fable 5.1’s version of the same pathology is actinic keratosis, which at least errs toward “keep it”. The CNN’s errors went in the opposite direction — missed melanomas called naevus or SK — which is worse clinically but is a threshold artefact, not a prior collapse.

The CNN was an Inception v3 pretrained on everyday photographs, with all layers fine-tuned on 68,011 dermoscopic and clinical images from the ISIC Archive. The author states the architecture was deliberately not state of the art, trained for about twenty minutes on a single H100. Every image of a test lesion or its patient was removed from training and validation before fine-tuning and was not used for model selection or threshold setting — which is the only reason the number means anything. Scoring weighted the dermoscopic view. On ordinary archive images the CNN separated discharge from no-discharge lesions far better than on this hard set: AUC 0.96 versus 0.86 here. That gap is the honest measure of how much the biopsy-selected sample inflates difficulty, and it is the kind of disclosure a vendor benchmark never carries.

The sharpest framing came from jacquesm: LLMs are “the first application that can actually lay claim to being a universal computing aid… before you know it everything becomes a nail, even if for a particular problem there is a better solution — you can’t beat ‘nothing to invest, nothing to learn, get an answer in 10 seconds flat’.” jszymborski supplied the institutional version: “the reaction I get from colleagues is increasingly ‘why bother training new models when you can just ask an LLM?’ Doesn’t matter the domain or the task.” sungam made the fair counter-point that with tens of thousands of public training images “I was expecting the LLMs to perform a lot better” — and ehsankia resolved it: “an LLM with the right harness could fetch and use that CNN, or train its own CNN… the harness makes a huge difference.”

Michael Malis’s pgrust is a rewrite of Postgres, AI-assisted, and Luu opens by conceding the obvious: he would assume it was “vibeslop” too, because almost all of these rewrite projects are slop. The evidence that this one is not is a set of bugs found by differential testing against the real thing:

Defect class	Symptom
SP-GiST numerical bug	valid operations fail
Format cache bug	incorrect JSONPath results
pgcrypto ordering bug	later operations fail
Dictionary-loader memory safety	multiple; not officially classed as bugs
Money overflow	arithmetic on the money type

Luu’s verdict is deliberately narrow: “this isn’t to say that pgrust is bug free, but it does indicate that there’s a substantial amount of testing happening and, even if pgrust itself is never successful, just making the attempt will have improved Postgres in a durable way.”

Luu’s trust is not in the model. It is in a specific behavioural difference, quoted from Discord: “I would not recommend using it as your primary production database today. We are setting a production deployment for a company right now, but they are more tolerant to their production database going down than most of them. We’ll have good empirical evidence on how reliable pgrust is after they start running it.” And on performance: “the new query engine is very fast on some workloads, but it causes performance regressions on others… We’re trying to track down everything that’s either slower than Postgres or errors out.” Luu sets that against the industry’s baseline: MongoDB disputing correctness for years while Kyle Kingsbury repeatedly demonstrated real data corruption, and a founder who published a QPS number off by multiple orders of magnitude, refused to change the page because he planned to hit it, and years later cut it by one order of magnitude and still only hit it on contrived workloads.

Accusations of nefarious cheating in pgrust’s ClickHouse comparison appear false on Luu’s reading; the “premature submission” criticism is something Malis acknowledged. Luu’s prediction is nonetheless that the project will never recover its reputation, and he cites the mechanism by name: people repeat vibe-based incorrect claims indefinitely, with Ed Zitron and Ray Kurzweil’s prediction track records as examples of claims that survive contact with evidence because nobody bothers to check them.

mindcandy named the mood swing precisely: too much “I’ve been coding for decades and what I’ve always done has been reduced to telling AI to do it for me” and not enough “I worked hard for months with AI’s help to make something I would have never considered possible before… much easier to complain that you are bored than to step back up to high-effort with your new fancy tools.” echelon: “AI is my jet pack. I was a fantastic IC… I’m an even better AI-empowered engineer. The old era is dead.” Against that, bemtevi raised the defection problem: “why even produce something greater now when someone is just going to clone it with AI?… what differentiates software now will no longer be the care put into it but marketing and trends.” majormajor answered historically: “that happened at least 20 years ago.” And Arubis supplied the pragmatic middle: many people are “trying to ship something AI-assisted that’s sufficient to get to income security first, and who would use success there as a stepping stone.”

The default way to serve Qwen3.8-Flash-Next keeps all ~24,000 experts pinned in system RAM (~48–64 GB) and computes cache misses on the CPU. That is fine on a workstation and impossible on a laptop. Lean-QwenFlash inverts it, adapting an offload design from glm-flash-lite (which had been running GLM-5.3 at footprints “way below anything I’d seen at those speeds”) onto the lighter Flash-Next, on ExLlamaV3 at 3.05 bpw with a Q4 KV cache. Measured:

Rig	Context	Decode	Prefill	Peak VRAM
RTX 4090, 8 GB system RAM, 16 GB VRAM	8k	28–33 tok/s prose, 19–22 code	~1,080 tok/s	—
same	100k	20.8 tok/s	~1,536 tok/s	—
same	262k (full window)	20.0 tok/s	~1,627 tok/s	—
RTX 3080 Laptop, 16 GB VRAM, 32 GB RAM	100k	18–21 tok/s	650–700 tok/s	15.5 GB

Note what did not degrade: decode throughput is flat from 8k to 262k — 28–33 down to 20.0 — because the working set that matters is the active expert subset, not the context.

A second, independent datapoint on the same model quantised to IQ3_S running on Basalt: RTX 5080 16 GB, Core Ultra 9 285K, 62 GB DDR5-6800, 262k context, int8 KV. The workload matters more than the peak numbers — it is an actual opencode agent session: 103 requests, contexts up to 130k. Result:

Workload	PP avg	PP peak	TG avg	TG peak	VRAM / RAM
Agent coding session (103 req, <=130k ctx)	5,011	5,118	153.0	262	15.7 GB / 54.1 GB
Context sweep (fresh prompts 15k–207k)	5,475	5,662	154.9	186.6	15.7 GB / 54.1 GB

99.5% of prompt tokens came from the prompt cache; the two large uncached reads were 10.7k and 8k new tokens; median time to first token was 0.2 s. The honest weakness is disclosed in the same post: 5.2 GB of RAM left free is thin headroom.

A kernel change with no model change: fuse the FFN gate and up projections and the GLU activation into a single MMQ pass by laying out interleaved gate/up rows, so the two matmuls read one weight stream instead of two. Measured prefill gains on DGX Spark (GB10) and RTX 5090, llama-bench -p 16384 -b 2048 -ub 2048 -ctk f16 -r 5:

Model / quant (DGX Spark)	master	PR	delta
Qwen3.8-27B Q4_K_M	840.1	899.9	+7.1%
Qwen3.8-27B IQ4_XS	882.4	948.0	+7.4%
Qwen3.6-27B Q6_K	720.8	770.4	+6.9%
Llama-3.1-8B Q4_K_M	2,749.3	3,000.6	+9.1%
Llama-3.1-8B IQ4_XS	2,933.9	3,249.0	+10.7%

Gains of ~6–7% on the 27B models and ~9–11% on the 8B, consistently across five quantisation formats and two architectures.

P2P DMA between GPUs was disabled on the 3080 20 GB — a card that only ever shipped in the grey market. Unlocking it delivers the largest single gain in today’s set: +70% prompt processing in tensor-parallel mode. Test rig: dual RTX 3080 20 GB, both in PCIe 3.0 x16 slots, power-limited to 240 W, Threadripper 1920X on X399, Proxmox 9.2.21, kernel 6.14.11-9-pve, driver 615.71.09, vLLM 0.32.0 serving Qwen3.8-27B AWQ-INT4 with --tensor-parallel-size 2, FP8 KV cache, prefix caching, chunked prefill, FlashInfer, and MTP speculative decoding at 3 tokens.

The question is asked cleanly: does ISTA’s GSQ-RCO GGUF of DeepSeek-V4.1-Flash really deliver IQ2_XXS matching the base model? The poster’s own diagnosis is the reason the claim cannot be tested: “their benchmarks are saturated (90%+, and AIME25 is 100 for every version), so they probably can’t show the degradation, and I couldn’t find any KLD for GSQ-RCO models.” The researcher is reduced to asking the community for a KLD or a perplexity number, and asks what KLD one should even expect at ~2 bpw.

ANEMLL Forge 0.2.1 puts Qwen3.8-27B on the M6 Neural Engine at up to 192k context on a 32 GB M6 Mac Mini. Two changes carry it: an INT8 K/V cache (“half of FP16”) and a smaller speculative drafter that shares the target’s output head, saving 0.86 GB of ANE memory at unchanged speed. Decode is strongly content-dependent: JSON 35–62 tok/s, code 18–32, prose 10–17. Prefill 260 tok/s at short context, 62 tok/s at 192k; 128k–192k switches to a smaller prefill batch (32 vs 64 rows) to stay in budget. The practical numbers: first 192k compile takes ~2 hours on an M6 (one time, cached); 96k is the sweet spot — 123 tok/s prefill, ~27 tok/s decode, ~21.4 GB total; a 16k export is ~10 minutes from download to a running server.

Impeccable began as a fork of Anthropic’s frontend-design skill — “the first widely-used design skill for Claude” — and its stated premise is a training-data critique: “every model trained on the same SaaS templates… you get the same handful of tells on every project: Inter for everything, purple-to-blue gradients, cards nested in cards, gray text on colored backgrounds, the rounded-square icon tile above every heading.” The architecture: one setup flow (/impeccable init writes durable product truth to PRODUCT.md — audience, purpose, operating context, constraints, voice, evidence), 24 commands sharing a design vocabulary (polish, audit, critique, distill, animate, bolder, quieter), and 62 deterministic detector rules that the CLI and browser extension run with no LLM and no API key. Installed base: 87,536 stars, 5,230 forks, 39 open issues, Apache-2.0, created 2025-11-16.

Hallmark is explicit about the mechanism: it “holds a hard floor and then gets out of the way. It deals three themes from a catalog of forty-eight materials, builds the page around what the visitor came to do, and lints the result in a real browser.” The tells it names are a taxonomy of the genre: the eyebrow above every heading, tracked-capital labels, one coloured word in a headline, a page of empty frames or nothing but photographs, a hero that misses its screen, an email sign-up at the end of every page, a form that says thanks without sending anything. The gates are tiered, and the tiering is the design insight: Floor never ships (contrast, focus, reduced motion, invented facts, broken phone layout) — Reflex gates are the defaults a model falls into, and a build with a stated reason may overrule one on the record — Finish checks never block a ship. A fresh-context reviewer gets the last word. Installed base: 33,544 stars, 1,748 forks, 57 open issues, MIT, created 2026-04-27. v2 added 48 themes and “built from the job” layouts — a booking page books, a shop sells, a newsletter subscribes.

GitHub’s “stars today” is an encounter rate, not adoption, and comparing a 2024 repo to one created last April is meaningless in absolute terms. Normalising by age gives a different picture:

Repo	Stars	Created	Stars/mo	Open issues	Issues / 1k stars
debpalash/VoiceStudio	86,552	2026-04-09	~13,300	195	2.3
pbakaus/impeccable	87,536	2025-11-16	~7,750	39	0.45
Nutlope/hallmark	33,544	2026-04-27	~5,600	57	1.7
TauricResearch/TradingAgents	114,435	2024-12-28	~5,200	150	1.3
pollen-robotics/microduck	11,561	2026-07-29	~4,000	69	6.0
makecindy/cindy	4,760	2026-07-22	~1,540	1,911	401

The design skills have two orders of magnitude less issue debt per star than an agent runtime — not because they are better engineered, but because a linter has no runtime. Nothing can crash that never executes. Cindy, by contrast, carries 1,911 open issues on 4,760 stars.

ThinkRail is a rich interface around the pi coding agent, shipped as a JetBrains incubator project (Apache 2.0, 1.4k stars, 554 commits, 115 branches, 121 tags). Three design decisions carry the architecture. (1) Workspace isolation by git worktree — each workspace is its own worktree with its own branch and working directory, so agents run in parallel without touching your checkout; you merge good branches and delete the rest, and finished or dormant workspaces “settle” onto a per-project shelf when a PR merges or closes, or after a quiet week. (2) Specs as ground truth — a connected graph of SPEC.md files beside the code, which the agent reads, searches and maintains through dedicated spec_* tools, rendered read-only as a tree. (3) Cost as a first-class UI element — several concurrent sessions per workspace, each with its own model and live token/cost readout, steerable mid-turn, with each completed plan step individually committable and reviewable. Around that: a real Monaco workbench with splittable tabs, a Changed view and terminals scoped to the active workspace; anchored review comments on files and diffs that can be sent to chat as structured context; GitHub PR state in the topbar with one-click publish, push, or open, then CI checks, mark ready, hand failing checks to the agent, merge with the repo’s last-used method; MCP servers from mcp.json that ask before any non-read-only call and keep repo-defined servers off until approved.

Cindy’s pitch is hedge-everything: one agent that brings multiple harnesses, models and tools together, with the first supported harnesses being Claude Code and Codex and a native harness in progress. The load-bearing claim is continuity — models and harnesses mix freely and can switch mid-task while workspace, memory, skills and tools stay continuous, and a single task “can even be planned, executed in parallel”. It runs locally on your own machine, using your real files and logged-in apps. Repo facts: created 2026-07-22, TypeScript, Node 22.x, pnpm 10, 4,760 stars, 654 forks, 1,911 open issues, and a bilingual README (EN / 简体中文).

InsideOutSanta made the structural point: “now that agents are doing most of the work, and we want to give them as much freedom as possible to run code, take screenshots, click on things… it really doesn’t make much sense to have a setup where all of this happens on your local computer. IMO it makes more sense to have this hosted somewhere, and then have UIs that make this visible to you on your devices.” aliasxneo described the working version: agents “sit in their little world in my homelab and I control everything through networking and virtualization restrictions… they can spawn their own VMs (Ubuntu, Debian, Fedora, Arch, Windows, even macOS on an old mac mini), run their own browsers, access their own secrets. There’s no way I would go back to agentic development on my local machine.” Against that, simpaticoder supplied the discipline: “you only need an agent to click things long enough to build an API on top of the thing it’s clicking on. And running a full windowed virtual machine is expensive.” On tooling churn, dr_kiszonka reported “endless tinkering and fixing minor issues” with a comparable harness; aliasxneo answered that on an opinionated distribution “I’ve been using it without thinking much about it for 3 months… zero problems thus far.”

The highest-star repository on today’s chart is not new: TauricResearch/TradingAgents, a multi-agent LLM financial-trading framework with an arXiv paper (2412.20138), 114,435 stars, 22,121 forks, 150 open issues, Apache-2.0, and a last push on 16 October — nine days before it appeared on trending. The fork-to-star ratio, 0.19, is the highest in the set by a factor of two: people are not just starring it, they are cloning it to run.

The release claim, as posted: Nanbeige4.3-33B is “stronger than Qwen3.8-27B across a range of benchmarks”, and explicitly “lays the necessary foundation to power our upcoming small-model distillation pipeline (e.g., for Nanbeige4.3-3B)” — the 33B will be distilled into their 3B line, and possibly other sizes. Note the epistemic status precisely: this is a vendor claim relayed in a forum post, the benchmark suite is not enumerated in the post, no KLD or third-party replication is offered, and no card here rests on the comparison holding.

The post points at mradermacher’s model-request page on Hugging Face and draws the inference: “I’m sure the situation is the same for other quant producers. If you have anything you want to keep, it’s best to make a backup now. If you have the means to, please create torrents of them and share them here” — with three unofficial mirrors offered in the same post (llama.garden, pirateface.co/models, huggingbay.xyz/browse).

The post is short and the claim is specific: REA (Reserve Engineer Anything) — a project aimed at reverse-engineering smart TVs that spy on their owners — was blocked by Claude one day later, with a link to the maintainer’s X post. The submitter’s line: “Time for the pebbles to own the weights.” Labelled precisely: this is a title-level claim with a one-line body and an outbound link. This briefing has not independently verified the block, its stated policy rationale, or whether an appeal was filed.

A practitioner’s cost-benefit, in their own numbers: Kimi K3 is “realistically very hard to run locally, even when quantized, and even if managing to run it, it’s slow, due to the 104 active layers it needs to go through to make a single token.” Against that, DeepSeek-V4.1-Flash (1017) is “quite close at a much smaller footprint and much faster”, and the poster’s read of the published Kimi K3.1 Pro results is that “they don’t look like substantial improvement… maybe just stick to 4.1 Flash (1017) and ignore Kimi K3 Pro open weight that will be released on November 4th”. They add the qualifier that quantising Kimi will degrade it relative to a high-quant DeepSeek.

Richard Borcherds has moved his UC Berkeley mathematics homework to completion-only grading: hand it in, get credit. His reasoning is an evidence argument, not a capability one — he observed many students using AI to “consistently earn top scores”, concluded there is “no point” in paying readers to grade for correctness because AI use is now “unavoidable”, and concedes the replacement is “not a very good system” for which he has no alternative. The institutional context matters: Berkeley’s Academic Senate asks faculty to put an AI statement in the syllabus, policy is at faculty discretion, and the campus tried Turnitin and Rumi and judged them “not adequate enough to be standardized” campus-wide. His larger claim is the part worth quoting in full: “if AI continues to improve at present rate, then, in a few years, there’ll be nothing human mathematicians can do that AI can’t do better”; he no longer knows whether to encourage students into the department, and compares the field’s inertia to physical paper journals, which have kept publishing despite being “utterly pointless” for two decades.

jruohonen proposed the structural fix: “In-class exams, either written or oral. If you don’t do homework, it is only on you. And with paper and pen.” ballmerpoint supplied the objection that kills ungraded homework in practice: “the issue with this policy is hyperbolic discounting — students are fine choosing not to do homework when the consequences are still in the future, but less so when they become present. Then they lash out at the instructor, even if it’s really their fault.” imafish then closed the loop with a design that survives both: “homework assignments ungraded but mandatory. Then an in-class oral exam on a random subject drawn at exam entry. Works great in my country. At the end of the day, the responsibility is on the student to study.” dlx noted Berkeley historically ran essentially this way — homework worth “next to nothing”, the grade on midterms and finals — and JumpCrisscross gave the employer’s view: value in “a degree that does nothing but weed out these people.”

A local outlet, Double Sided Media, filed a records request in August 2026 covering potential misconduct by one officer, Justin Peckels, between 2018 and 2026. The city’s estimate: $2,484,599.04 for “at least” 44,816 hours of staff time. A second request, for former officer Eric Klinko, was quoted at $195,869.52 — nearly $2.7 million combined. The demand letter is explicit about the sequencing: “Once the City receives payment of $2,484,599.04 staff will continue processing your request. If the actual cost of processing your request exceeds the amount you have paid the City, you will be required to pay the difference before the City will provide the records.” The justification is the interesting part: Eugene claimed it could not narrow the set of custodians whose records it must search, and therefore had to search all records of all city employees, past and present — on the theory that a former parks-and-recreation employee’s files might contain responsive police-misconduct information and must be reviewed one by one. Standard practice is to search the custodians most likely to hold responsive records, not every groundskeeper on the payroll.

The report’s decisive detail is a direct contradiction. Eugene’s police department signed a two-year, $342,000 contract for nearly 60 AI-powered Flock automated licence plate readers; the project was secretive enough that the ACLU of Oregon had to sue the city to find out how the cameras were used. Yet, in the author’s phrasing, “that technological sophistication disappears as soon as a journalist requests public records about the department’s internal accountability process.” The piece also documents this as a pattern rather than an outlier, with a table of exorbitant fee precedents going back to 2015 and the Department of Defense.

Bogomil Shopov’s call for the FOSDEM 2027 Digital Dissident devroom states a thesis that is directly useful to anyone designing resilient systems: people under authoritarian regimes never rely on a single tool, and their safety depends on an end-to-end chain that must hold at every link — (1) reaching the network at all, (2) communicating without leaking metadata, (3) collecting, verifying and storing evidence safely, (4) publishing or leaking it without exposing the author, (5) doing all of it on devices and infrastructure that are themselves a risk. The organising principle: “the weakest link decides the outcome.” The gap the devroom exists to fill is explicitly the seam: “a circumvention transport that is fingerprinted, or a messenger whose push notifications tie your identity to a Google or Apple account. Nobody currently owns that cross-project view.” The threat list is current and specific: national allow-lists and whitelist-only shutdowns, TLS and QUIC fingerprinting, deep packet inspection with active probing, per-protocol throttling, mobile internet shutdowns, app-store removal of circumvention tools, mandatory state messengers and “sovereign internet” routing.

cyanydeez moved the argument from censorship to discovery: “even if your internet is free, how are you going to find it through the slop brigades generating and consuming the same load-bearing crap?… how will you afford it when everyone puts up pay gates?” sssSilver posed the paradox sharply: “if crap is indistinguishable from substance, is it truly crap? If it is distinguishable, can’t the machines do the distinguishing?” QuantumNomad_ answered from evidence: “No — just like they are not able to reliably tell if a piece of text was LLM written… The crap is very very distinguishable. But there is so much of it we have to wade through.” And pixl97 supplied the governing law: Brandolini’s — “the amount of energy needed to refute bullshit is an order of magnitude bigger than that needed to produce it.”

The claim is extraordinary and unusually specific: standard implementations of softmax, log-softmax and cross-entropy have two numerical bugs. Softmax Collapse — “rounds the target logit’s gradient to zero if that one logit is much larger than the others, resulting in gradients that no longer sum to zero.” Softmax Cancellation — “occurs when student logits are close to teacher logits, and produces non-zero gradients even when the student and teacher logits are equal”, i.e. the distillation loss reports a gradient where the loss is at its minimum. The proposed implementations fix both, and the reported consequences are a list of long-standing mysteries resolved at once: it eliminates the previously-observed “Slingshot” phenomenon, speeds up grokking with weight decay, prevents accuracy collapse without weight decay, stops student networks drifting away from the teacher during distillation, and shows that after memorisation logit growth is bounded by an equilibrium between weight decay and Adam’s epsilon.

The framing is a concrete cost disclosure that model cards rarely give: DeepSeek-V4.1-Flash allocates 196 billion parameters to its Engram n-gram memory — learned representations of short token sequences (pairs, triples) retrieved during processing. The paper asks whether that cost can be cut without losing the gain, storing n-gram embeddings at low precision and systematically sweeping quantisation methods and bit allocations across tables. Result, across nanochat-, Llama- and GPT-2-family models trained from scratch: four-bit tables save approximately 75% of table memory while preserving more than 99% of the validation-loss improvement from adding the tables at all.

The setup is precisely the one every AI-deployment team faces and almost none formalise. A system emits a decision plus a confidence score, and the score need not come from the same model — “one agent may propose a decision, while a separate verifier agent evaluates it and outputs a correctness or safety score.” On that basis you choose accept automatically or consult an expert, who reviews and either accepts or corrects. The paper formulates it as an online constrained optimisation problem: minimise the frequency of expert auditing while guaranteeing that the fraction of AI errors that go unaudited stays below a user-defined threshold.

The failure it isolates is the one that defeats every content-based guardrail. “When a tool response omits a safety-relevant fact, an agent may carry out a prohibited action even though the user request is benign and every returned statement is true.” EpiSEM-Bench is an executable benchmark of 300 matched unsafe/safe task pairs across six domains, built by systematically suppressing critical facts to measure unsafe execution under critical evidence omission, and it reports the minimum observed failure cardinality — including failures with full evidence and cases with no observed failure after exhaustive testing. An independent audit tool tests whether agents seek the missing fact and then withhold the prohibited action while still completing the permitted part of the task.

The problem statement is the sharpest critique of chain-of-thought published this week: “there is no guarantee these steps causally drive the final answer… dense attention allows each reasoning step to attend to the full context, enabling the model to derive answers through direct lookup while generating plausible-sounding but post-hoc justifications.” CausalCoT decomposes the problem into a directed acyclic graph of atomic sub-questions and evaluates each node in an isolated context containing only its direct causal parents. The Markovian structure “removes attention pathways to non-parent content, making downstream predictions sensitive to local reasoning rather than global context leakage”. Across reasoning benchmarks it “preserves” performance — the abstract’s own hedged wording.

Looped architectures “scale quality while keeping parameter count fixed by repeatedly passing activations through the same block of layers”, but at inference each recurrence generates independent KV caches, so memory grows linearly with loop count. Prior work found that sometimes the final recurrence’s KV cache can be shared with earlier ones without quality loss — a property the authors name KV-shareability — but the mechanism was unexplained and “even identically trained looped architectures” did not consistently exhibit it. Their contribution is a two-stage method: in stage one, stochastic depth during pre-training induces contractive residual dynamics that drive shareability into the model rather than hoping it emerges.

The scenario is one page: the agent decides a customer is owed a refund, calls POST /refunds, the payment service processes it and writes to its ledger, then the network hiccups and the agent times out. From the agent’s view it failed; from the service’s view it succeeded. The agent retries and the customer is refunded twice. Kyrkos’s thesis: “the model reasoned perfectly… the failure happened after the reasoning was over.” The five failure modes: (1) treating a timeout as a “no” — which merges three distinct situations, only two of which are safe to retry blindly, because “the request reached it, succeeded, and the response was lost” is not; (2) no idempotency key — and the key must be generated by the application, before the first attempt, and reused, because “if the model generates it, or if it’s regenerated per attempt, it protects nothing”; (3) state that lives only in the context window; (4) no “outcome unknown” state — the four required states are submitted, confirmed, failed, unknown, and “unknown is the one that matters. It’s the state that should block automatic retries and trigger reconciliation instead”; (5) no reconciliation path.

The arithmetic is small and devastating. A hard support ticket pulls a 50k-token context and emits ~1k tokens. One attempt is ~51k tokens. With retries: 3 and the task still failing, you pay 4 attempts: 51k × 4 ~ 204k tokens for a task budgeted at 51k — a 4× tax. It is worse than 4× on average because “failing tasks are the expensive ones (long context, heavy tool chains, messy inputs)… retries concentrate exactly where cost is highest.” And it fires precisely when the model is slow or down, i.e. at peak load. The reason the bill stays invisible: dashboards report average cost per successful request, so a task that fails three times and then succeeds appears as one success with a latency blip, not as 4× cost. The proposed fix is routing rather than retrying — “you don’t make retries cheaper by retrying harder” — advancing the task to the next equivalent model while the handoff context travels with the task and is paid once.

The most rigorous claim in the Dev.to set, and it has zero reactions. Fine-tuning Gemma 4 E2B on its own answers sampled under a 64-token cap — with no cap at inference — halves tokens per correct answer on all 1,319 GSM8K test problems, at a cost of 12 to 33 fewer right answers across four training runs, and “matches the accuracy” of the uncapped baseline in at least some runs. The mechanism named is llama.cpp’s “thinking cap”, which “trades accuracy for tokens”, and the fine-tune teaches the model to reproduce its own truncated behaviour by default.

The post opens on the demo-to-production gap in RAG: a retrieval demo over a thousand PDFs looks flawless, and at scale “a correct answer and a confident lie look identical”. The proposed discipline is claim-level verification — decompose the generated answer into individual claims and verify each against retrieved evidence, rather than scoring the answer as a whole. At 15M documents the design pressure is entirely on evidence retrieval per claim, which is the same bottleneck the arXiv breast-lesion RAG harness in yesterday’s issue measured from the other side: retrieval scores are partly a function of annotation coverage.

Hacker News — Firebase API, top 12 stories by score, fetched at 21:01 UTC. Top item 710 points / 653 comments. The fetch payload returned zero comment bodies for every story (a known regression in the fetcher), so all comment threads were re-pulled through the Algolia item API, written to disk and parsed from file: 12 threads, 128 quotes over 120 characters held at tree depth <= 3. Every item?id= in this document was taken programmatically from the payload and cross-checked against it in the audit. GitHub Trending — daily chart scraped, 6 repositories with READMEs. “Stars today” is GitHub’s 24-hour encounter figure; to make comparison possible at all, every repo was additionally resolved through the GitHub REST API for true star count, fork count, open-issue count, licence, and creation date, and normalised to stars per month since creation (section 04). This is a measurement addition this briefing has not made before, and it changes the ranking: the highest “stars today” repo is not the fastest-growing repo. Reddit — the JSON API returned HTTP 403 Blocked on all three subreddits. The Atom ladder was walked: r/LocalLLaMA succeeded on the first rung (top/.rss?t=day&limit=15) with 15 entries and full self-post bodies. r/MachineLearning and r/singularity returned zero bytes on all six rungs and were not retried further, per the rate-limit behaviour documented on this endpoint. No card in this briefing rests on either of those two subreddits. Dev.to — API, tags ai/machinelearning/llm, deduplicated; 18 articles reviewed, 4 used, two of them fetched in full. arXiv — API, cat:cs.AI OR cs.LG OR cs.CL over https, sorted by submission date, 25 entries. The listing has not rolled since Thursday 22 October 2026 — the newest paper in the whole result set is dated 2026-10-22, which is what a weekend looks like on arXiv. Yesterday’s issue used the top 14 of that batch. This issue therefore uses only six papers from the same batch that yesterday’s briefing did not cover, and states the provenance on every one. Nothing here is recycled; nothing here is presented as newer than 22 October. Web extraction — primary sources pulled directly for six items: the Lynch Lab post, Dan Luu’s essay, the ThinkRail repository, the FOSDEM CFP, the Daily Californian report, and The Intercept report. Nothing behind a paywall was used.

(1) Dolly Parton’s Imagination Library — 198 points, warmly discussed, and excluded on the unification test: it is a good story about a good programme and it carries no evidence for this issue’s thesis. It would need its own thesis to appear, which is the definition of a card that should be cut. (2) The Dreamhost password-reset incident — 79 points. The thread’s best inference, from duskwuff, is that the exposure began with connectivity issues in a File Manager built on Monsta FTP, a commercial PHP application, and that FTP credentials may have been exfiltrated — which would explain the email-password reset. This is inference, not disclosure, and Dreamhost has published no root cause. Recorded here as an open item, not a finding. (3) “Eunice is almost here” — 26 points. A literary item whose thread is a genuinely interesting argument about how well Gibson and Stross predicted agent-mediated life; adjacent to the thesis, not evidence for it. (4) The US power grid piece and VCF Southwest — 20 and 34 points, no bearing. (5) “Why I Am a Programmer” — 26 points; the single substantive comment (RomanPushkin) is a good line and not a card. (6) The REA blocking claim is used in section 06 but only at title level, with the limitation stated in the card itself — the maintainer’s X post was not independently verified. (7) The Dev.to “93% confident is a string” post was excluded because yesterday’s issue covered it in full. It remains the best short statement of the calibration problem and it is not re-run here.

Within 7 days — an independent replication or refutation of the softmax/cross-entropy bug fix in a mainstream framework. If PyTorch or JAX ships it as a default, every historical distillation result is up for re-reading; if nobody does, it is a paper about a bug that does not bite. Within 7 days — whether the Lynch Lab protocol gets re-run with few-shot exemplars. This is the single experiment that decides whether section 01 is about priors or about prompting, and it is cheap. 4 November 2026 — Kimi K3 Pro open weights. Measure active layers per token and tokens/second on a 24 GB card, not the benchmark table. That is the number that decides whether it is deployable. Ongoing — mradermacher’s model-request page and quant availability. A confirmed removal establishes that the quantisation layer has an availability risk that model licenses do not cover. Within 14 days — the cindy issue-close rate. If open issues pass 2,500 against ~5,000 stars, the project is in triage debt and should be excluded from production evaluation on operational grounds alone. Within 30 days — a public KLD or perplexity table for a 2-bit GSQ-RCO quant. Until one exists, no 2-bit parity claim should enter any procurement document. Ongoing — whether Eugene, Oregon produces the records, narrows the custodians, or is litigated. The outcome sets the practical price of public-record opacity in the US for the next several years.