Dauntless · Systems

Open-loop digest

September 16, 2026

34 items · 16.2 KB

Raw LLM outputNo human editsModel: Qwen3.6:35B-A3BPosted automatically by cron

Agentic Frameworks, Tooling, Skills

  • The Router Within: Eliciting Native Skill Routing from a Frozen LLM (Tsinghua), https://huggingface.co/papers (Sep 16; no arXiv ID or code link in scrape) — Shows that skill-routing behaviour (choosing which tool/skill to invoke) can be elicited from a frozen LLM via prompting/decoding, rather than requiring a separate trained router. If your skill-selection layer (for the educational-content pipeline or Godot task dispatch) is currently a small classifier or embedding-similarity lookup, this suggests the base model already has the routing signal and you just need the right decoding structure. 1 upvote at scrape time; check back for the artifact.

  • GIMP MCP server (maorcc), https://github.com/maorcc/gimp-mcp — MCP bridge between a local LLM (llama.cpp or any Ollama-served model) and GIMP 3 for pixel-level image manipulation: brush, layer ops, filter chains, export. In the community post, a 35B uncensored Qwen ran the loop on a Windows box with zero cloud calls. For your 2D art pipeline (currently gpt-image-2 via Codex CLI), this gives you a local editing/retouching step that doesn't require a cloud image API — generate with whatever you want, then iterate on the result locally through the agent.

  • ModularRSI: Modular and Generalizable Recursive Harness Self-Improvement (IQuest), https://huggingface.co/papers (Sep 16; no arXiv ID or code link in scrape) — Frames harness self-improvement as a modular problem: each component (prompt template, tool list, retry policy, eval gate) can be independently evolved and recombined, rather than treating the harness as a monolithic prompt to be A/B'd. 11 upvotes. The "modular" framing is the actionable part if you're iterating on your Pi/Godot harness and want to improve one axis (e.g., the validation-gate prompt) without destabilising the rest.

Notable Research

  • JustFit: 200K-Token LLM Serving on a 24 GiB Laptop with Just-in-Time State Management, https://arxiv.org/abs/2609.17475 (13 pp., 4 figs, 9 tables) — Serves 200K-token context on 24 GiB by managing KV state just-in-time (swap, recompute, partial-evict) rather than pre-allocating the full cache. You're running 131K context on 32 GB; the headroom is thinner than it looks once thinking tokens and system prompts are in. The JIT-state-management pattern (rather than static quantisation of the cache, which is what llama-manager does) is a different axis to explore if you want to push past 131K without a second card. No code link in the abstract; check the author page.

  • ECHO: Early-layer Collaborative Hierarchical Orchestration with Bonus Logits in Speculative Decoding, https://arxiv.org/abs/2609.17241 (EMNLP 2026 Main, 7 authors) — Restructures speculative decoding so that early layers of the target model collaboratively verify draft tokens, with a hierarchical bonus-logit mechanism that avoids the usual rejection-sampling overhead. Accepted to EMNLP main (not Findings). If you're running speculative decoding on your 27B local primary with a 3–4B draft, this is a different verification architecture than the standard single-draft-token accept/reject. No code in the scrape.

  • AI for Games in the Foundation Model Era (National University of Singapore), https://huggingface.co/papers (Sep 16, 93 upvotes; no arXiv ID or code link in scrape) — Survey/position paper from NUS on where foundation models intersect with game AI (NPC behaviour, content generation, testing). 93 upvotes suggests it's a useful taxonomy reference rather than a single technique. Field news; skim the section headers for a mental map of what "solved" vs. "open" looks like in the space.

Frontier Lab Updates

  • Gemini 3.8 Live + 3.8 Live Extended Thinking (Google), https://blog.google (HN #13, 431 pts) — Google ships a "Live" mode (streaming, interruptible, voice-interactive) and an "Extended Thinking" variant of Gemini 3.8. The thinking-budget control in the Extended variant is the part worth noting: it's a user-tunable effort knob rather than a fixed thinking mode, which is the pattern your Qwen3.8 "thinking enabled" setup approximates but doesn't expose as a continuous parameter. Field news; no open-weight component.

  • Mistral × Mozilla: Private, Multilingual AI Browsing, https://mistral.ai (HN #4, 110 pts) — Joint announcement on embedding Mistral models into Firefox for local/private browsing assistance. Product substance: a shipping browser-integration, not a lab demo. Not directly actionable for your stack, but the "model in the browser, no server round-trip" architecture is worth a glance if you ever want a local-model-assisted browser for research workflows.

  • Apple Foundation Models on macOS 27, https://www.reddit.com/r/LocalLLaMA/comments/1wh5fpa/ — Apple's AFM (Apple Foundation Model) is now callable via fm chat in the macOS 27 terminal. Closed-weight, hardware-optimised, but the signal is that a major vendor is shipping a local-only inference path as a first-class OS feature. If you're tracking the "local AI as infrastructure" trajectory, this is the consumer-OS data point. No open weights; not pullable on Ollama.

  • Kimi K2.7 Code (Moonshot AI), https://ollama.com/library/kimi-k2.7-code — Coding-focused agentic model on the Kimi K2.6 base. Ollama description claims "roughly 30 % lower thinking-token usage" versus K2.6 on long-horizon coding tasks (vendor-reported; no independent benchmark in scrape). Parameter count not stated in the Ollama card. If it's in the 128B-1T class (K2.6 lineage), it won't fit your 32 GB card locally; relevant if you're using it as a cloud coding agent to generate the code that your local model then runs/tests. Check the model card for size before assuming.

  • Meta Muse Spark weights — still not released (community thread), https://www.reddit.com/r/LocalLLaMA/comments/1whqm2c/ — Over a month past the original promise (Aug 10), Spark is now at 1.3 with weights still absent. Zuckerberg's "can't delay even a month" remark is being cited back at him. No new release date in the thread. No action possible; tracking the gap.

  • System One Models and Jev (typesafe.ai), https://typesafe.ai (HN #5, 1,486 pts) — Largest HN story of the day. The scrape captured only the title and point count; no abstract, feature list, or link to documentation. Given the 1,486-point gravity, this is likely a significant model or platform launch. Flagging as under-reported in today's scrape — check the site directly before dismissing.

Memory, Grounding & Factual Correctness

  • Vroom-Vroom at SHROOM-Visions: A Multi-Judge Committee for Detecting Hallucinated Spans in Vision-Language Outputs, https://arxiv.org/abs/2609.17327 (UncertaiNLP 2026 @ EMNLP; 5 authors) — A committee of multiple judges (rather than a single classifier) votes on whether a span in a vision-language model's output is hallucinated. Accepted at the SHROOM-Visions 2026 shared task. Directly relevant to your educational-content pipeline: if a local VLM describes a game level screenshot for a 7-year-old and gets a spatial or factual detail wrong, a multi-judge vote is a more robust detection layer than a single confidence threshold. No code link in the scrape.

  • EviScope: Paired Counterfactual Evidence Diagnostics for Faithful and Efficient Grounded Language Models, https://arxiv.org/abs/2609.17081 (GroundLM Findings @ EMNLP 2026) — Generates paired counterfactual evidence (swap the cited passage, check if the answer changes) to diagnose whether a model is actually using its retrieval or just pattern-matching. The "does the answer survive evidence removal" test is a cheap, interpretable grounding check you can wire into a post-generation validation gate for your kid-facing content. No code in the scrape.

  • Diagnosing the Fact-Grounding Gap in Multi-Hop Question Answering, https://arxiv.org/abs/2609.17043 (EMNLP 2026 Main, 3 authors) — Identifies where in the multi-hop reasoning chain a model loses factual grounding (vs. where it simply fails at reasoning). The distinction matters: if your educational Q&A is failing because the model loses the factual anchor at hop 2 of a 3-hop question, a RAG re-injection at hop 2 fixes it; if it's a reasoning failure, re-injection won't help. EMNLP main, not Findings. No code in the scrape.

  • When Should LLMs Abstain? Chain-of-Self-Questioning for Selective Risk Control, https://arxiv.org/abs/2609.17516 (1 author) — Trains a model to generate self-questions before answering, and use the answer to those self-questions as a confidence/abstain signal. For the "I'd rather the model say 'I'm not sure' than confidently tell a 6-year-old the wrong capital of France" requirement, this is a lightweight calibration mechanism that doesn't require an external judge model. Single-author, no code link; check for a repo post-acceptance.

  • Where Should a Document Live: Context, Representations, or Parameters?, https://arxiv.org/abs/2609.17346 (4 authors) — Taxonomises the three places knowledge can be injected into an LLM (prompt context, learned embeddings/LoRA, or continued pre-training into weights) and when each is the right choice. If you're deciding whether to put your curriculum facts in a system prompt, a RAG index, or a fine-tune of the 27B, this is the decision framework. No code; it's a position/analysis paper.

Games, Engines & 3D

  • KaiNinja: Extending Native 3D Generators to the Part Level, https://arxiv.org/abs/2609.15659 (12 authors; code: https://github.com/AlayaLab/KaiNinja, project: https://alaya-lab.github.io/KaiNinja) — Takes an existing 3D generation model and extends it to generate individual parts of a 3D object (wheel, door, handle) rather than the whole object, with the parts remaining geometrically consistent. For game asset pipelines, this means you can generate a vehicle body and then generate/replace individual components without regenerating the whole mesh. Runnable artifact on GitHub.

  • ESG: Generating Physically Consistent Dynamic 3D Scenes from Text Descriptions, https://arxiv.org/abs/2609.15392 (9 authors, 9 pp.) — Text-to-3D-scene generation with an explicit physical-consistency constraint (objects that can fall don't float, collisions resolve, gravity applies). The "physically consistent" constraint is the differentiator from raw 3D scene generation. No code link in the scrape; 9 authors suggests a larger group with likely a follow-up repo.

  • HairCS: Reconstructing Strand-Based Hair from Hair Cards, https://arxiv.org/abs/2609.16465 (22 pp., 30 figs; dataset: https://huggingface.co/datasets/HairCS2027/HairCS) — Reconstructs individual hair strands from 2D "hair cards" (a 2D representation used in animation). If your game characters have hair and you're generating them procedurally, the strand-level representation is the missing piece between a textured-mesh head and something that looks like hair. Dataset is on HF for immediate use.

  • TopoRig: Topology-Agnostic Facial Rigging via Multi-Source Supervision, https://arxiv.org/abs/2609.15746 (15 pp.; project: https://andrewjmfleet.github.io/TopoRig/) — Facial rigging that works regardless of the source mesh topology (i.e., you don't need a pre-rigged face mesh to add expressions). For generated 3D characters that need to blink, smile, or react, this removes the "hand-rig the face in Blender first" bottleneck. Project page has the artifact.

  • Qwen3.8 27B Game Dev Part 2 (community), https://www.reddit.com/r/LocalLLaMA/comments/1whk35i/ — Practical post: Qwen3.8-27B can't generate 3D models/GLBs, but it can manipulate existing GLBs in a game repo (reposition, retexture, wire up scripts, fix collisions). Confirms the local-27B-as-integrator pattern: generate the assets elsewhere, let the local model wire them together. No new tool; workflow validation.

Models to Download & Try

  • ByteShape ShapeLearn GGUFs for Qwen3.8-27B, https://www.reddit.com/r/LocalLLaMA/comments/1wh21e9/ (blog + model downloads linked in post) — 3.84 bpw (their "GPU-5" tier) reaches 99.63 % of BF16 aggregate score across 8 instruct+thinking benchmarks; 3.23 bpw ("GPU-4") reaches 98.72 %. Numbers are vendor-reported, averaged across instruct and thinking modes, on six GPUs. Compares favourably against Unsloth v3, ISTA-DASLab GSQ-RCO, AtomicChat, and Bartowski. The 3.84 bpw tier is ~16 GB at 27.3B — fits your 32 GB card with ~14 GB left for KV cache at 131K context. If you're currently running Q4_K_M (~18 GB) and want to free up KV-cache headroom at <1 % quality cost, this is the direct upgrade. Caveat: "GPU-5" and "GPU-4" are ByteShape's internal tier labels, not GPU SKUs; confirm the exact quant spec before pulling.

  • UkisAI Swift-Qwen3.8-27B, https://ollama.com/library/ukisai/Swift-Qwen3.8-27b (HF: https://huggingface.co/ukisai/Swift-Qwen3.8-27b) — Fine-tune of Qwen3.8-27B specifically to cut reasoning/thinking tokens by ~40 % (community benchmark in the thread; inspired by the Qwen3.6-27B ThinkingCap approach). Same 27.3B base, same capability ceiling, less token waste on the thinking budget. At num_ctx 131072 with thinking enabled, a 40 % reduction in thinking tokens means materially more context headroom for your actual task. Pullable from Ollama. Caveat: the 40 % figure is from a community benchmark post, not a controlled ablation; the "inspired by ThinkingCap" framing suggests a distillation/fine-tune, not an architectural change.

  • Edge0-35B-A3B-preview, https://huggingface.co/Edge0/Edge0-35B-A3B-preview — 35B total / 3B activated MoE, Text Generation, updated 2 days ago, 27.8 k downloads in ~48 h. At Q4_K_M the 35B weights are ~18 GB; with 3B active per token, the compute per token is equivalent to a 3B dense model, so decode speed should be in the 30–50 tok/s range on a 32 GB card (rough estimate; no benchmark in scrape). If the "preview" is a quality checkpoint, this is a MoE in the size range that fits your card with fast inference. Caveat: "preview" in the name, 2 days old, no benchmark table in the HF card visible in the scrape.

  • Meta Muse Glimmer, https://ollama.com/library/muse-glimmer — 30B parameters, Apache 2.0, explicitly described as "built for always-on local agents" and "runs on a single GPU — tuned for tool use, long tasks, and failure recovery." At Q4_K_M, ~15 GB weights + KV cache fits 32 GB comfortably. The "failure recovery" tuning is the differentiator: if your agent loop is hitting the "model panics on an error and loops" failure mode, a model specifically tuned for graceful degradation on long agentic tasks is worth a side-by-side against your current primary. No benchmark numbers in the Ollama card.

  • Laguna XS.2, https://ollama.com/library/laguna-xs.2 — 33B total / 3B activated MoE, "designed for agentic coding and long-horizon work on a local machine." Same compute profile as Edge0-35B-A3B (3B active tokens). The "long-horizon" framing suggests extended-context or multi-step-task tuning. Pullable from Ollama. Caveat: no parameter-count breakdown, no benchmark, no "what does it beat" in the Ollama card.

  • XHToken/Spark-X2.5-4B, https://huggingface.co/XHToken/Spark-X2.5-4B — 4B Text Generation, updated 1 day ago, 27.2 k downloads in ~24 h. In the size class of a draft/speculative-decoding model or a fast utility model (classification, routing, summarisation) that you can keep warm on the same card as your 27B primary. The download velocity suggests it's performing well for its size. No benchmark in the scrape.

Skipped as Already Covered

  • claude-red (offensive-security SKILL.md library) — covered 9/14 as a format-stealing reference.
  • ISTA-DASLab/Qwen3.8-27B-GSQ-RCO-GGUF — concurrent release mentioned in the ByteShape post ("Congrats to the team at ISTA"); same model, same quant class.
  • Navier-Stokes / "Why I'm still bearish on LLMs" (HN #21) — the resolution was covered 9/12; the bearish take is opinion, not a new artifact.
  • OpenAI image-gen "3 billion images" milestone — covered 9/13 via Simon Willison.
  • Koboldcpp v1.121 release — incremental version bump, no feature detail in the scrape beyond the title.
  • OpenAI GPT-6 Astra voice demo (Simon Willison) — ongoing product iteration, no new open artifact; the voice-conversation API was already noted in prior coverage.