Dauntless · Systems

Open-loop digest

September 17, 2026

37 items · 17.4 KB

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

Agentic Frameworks, Tooling, Skills

  • HarnessTax, https://harnesstax.github.io (HN, 144 pts, 13 h ago) — Quantifies how much the harness (prompt template, tool list, retry policy, eval gate) moves coding-agent scores, separating the harness signal from the model signal. Directly answers the "I added a skill and feel like it helped but can't isolate the delta" question that RoastMyHarness (9/13) attacks from the task side. Complementary: RoastMyHarness picks a task and diffs harnesses; HarnessTax picks a harness axis and measures its marginal contribution across tasks.

  • ProgramDistill: From Interactive Web Apps to Verifiable Reference-Guided SWE Tasks, https://huggingface.co/papers (Sep 17, Microsoft Research, 42 upvotes) — Converts an existing interactive web app into a set of verifiable SWE evaluation tasks by treating the app's DOM state transitions as ground-truth specs. If you want to auto-generate validation gates for your Godot content pipeline ("the generated level must satisfy these N state invariants"), this is the task-construction pattern. No arXiv ID or code link in the scrape.

  • Agora: Git as Shared Memory for Collective AutoResearch, https://huggingface.co/papers (Sep 17, NVIDIA, 32 upvotes) — Uses Git commits/branches as the persistent shared state for a multi-agent research loop: agents read the working tree, write findings as commits, and resolve conflicts through merge. The "Git is the memory bus" framing is a concrete, low-dependency pattern for your agent harness if you want multi-step research sessions to persist across Ollama restarts without a vector DB. No code link in scrape.

  • OpenSpec, https://openspec.dev (HN, 153 pts, 12 h ago) — Lightweight, configurable AI spec framework: define a contract (inputs, outputs, invariants, edge cases) in a structured format, then have an agent generate and validate code against it. If your educational-content pipeline currently validates "is this fact correct?" by eyeballing output, an OpenSpec-style contract ("output must contain exactly these 3 verified facts, reading level ≤ 8, no content outside {allowed_topics}") gives the LLM a machine-checkable target. HN thread for community signal; no repo link in scrape.

  • Bad Genius: Counterfactual-Guided Harness Evolution Beyond Task-Specific Shortcuts, https://arxiv.org/abs/2609.18366 (28 pp., 6 figs) — Evolves agent harnesses (prompt + tool config + retry logic) using counterfactual reasoning: instead of "does this harness work on task X?" it asks "would the agent have succeeded if it hadn't had tool Y?" This prevents the common failure where a harness looks good because the agent is shortcutting around a missing capability. Method-level contribution; no code link in the abstract.

Notable Research

  • VC-Attention: Value Smoothing and Softmax Casting for Low-bit Attention, https://huggingface.co/papers (Sep 17, Nunchux AI, 32 upvotes) — Two kernel-level tricks (smooth the value matrix before casting; cast the softmax output at a different precision than the QK product) that reduce attention-bitwidth without the accuracy cliff that naive INT8/INT4 attention hits. If you're pushing your 27B primary into FP8 or INT8 attention on the V620 to free VRAM for context, this is a more surgical fix than blanket cache quantisation. No arXiv ID in scrape.

  • Fathom: Per-Query Read Depth for Sparse Decoding over Offloaded KV Caches, https://huggingface.co/papers (Sep 17, 1 author) — Decides how many KV entries to read from offloaded (SSD/RAM) cache per query, rather than using a fixed page size. Complements the JustFit JIT-state-management paper (9/16) from the other direction: JustFit decides when to swap/recompute; Fathom decides how much to read on each access. Together they sketch a full hierarchy for 131K+ context on 32 GB. No code link.

  • The Other Half of the Memory Wall: Serving 35B MoEs from SSD with Trained Routing Prediction, https://huggingface.co/papers (Sep 17, Edge0, 1.86 k stars) — Trains a small routing-prediction model so that only the likely-active expert weights are paged from SSD per token, rather than pre-loading all 35 B. Paired with the Edge0-35B-A3B-preview model (see Models section), this is a runnable path to 35 B-class capability on 32 GB by keeping 3 B active in VRAM and SSD-streaming the rest. 1.86 k stars on the paper's linked model repo suggests a working artifact.

  • Breaking the 1.58-bit Barrier for Ternary LLMs, https://news.ycombinator.com (HN #19, 213 pts, 14 h ago; links to arxiv.org, direct paper ID not captured in scrape) — Pushes ternary (−1/0/+1) weight representation past the 1.58-bit effective-precision ceiling that has been the practical floor. If you can go from Q4_K_M (~4.5 bpw) to a stable ternary format, your 27 B primary drops from ~17 GB to ~8.5 GB of weights, roughly doubling headroom for context on 32 GB. HN discussion may link the paper; check comments.

  • REPAIR: Resolving Long-Tail Confusion in Scientific Retrievers via Fact-Verified Iterative Refinement, https://arxiv.org/abs/2609.18262 (EMNLP 2026 Main, 30 pp., 5 figs, 20 tables; code linked in abstract) — Iterative refinement loop where a retriever's candidate passages are checked against a fact-verification step before acceptance, specifically targeting the long-tail confusion mode (retriever picks a similar-but-wrong source). For your educational-content pipeline, this is the "the model pulled the wrong Wikipedia article for 'photosynthesis' and generated a confident wrong answer" failure, attacked at the retrieval layer. The code link is the actionable artifact.

Frontier Lab Updates

  • Claude Cowork + Claude chat merge (Anthropic, via Simon Willison, https://simonwillison.net/) — "Claude Cowork and chat are merging into one Claude… even after you've closed your laptop." Rolling out to Pro/Max on web/desktop/mobile. The operational note: background/async agent tasks (what Cowork was) are now a first-class surface in the main Claude app rather than a separate product. If you're using Claude for orchestration of your local pipeline, the API surface for background tasks may shift; watch for API changelog.

  • OpenAI solves a Millennium Prize Problem (via Simon Willison, https://simonwillison.net/) — OpenAI used an unreleased model to produce a resolution to one of the seven $1 M Clay Prize problems (post-May 2024). No model name, no public proof, no reproducible artifact in the scrape. Field signal that frontier capability is ahead of the public model ladder; no local action.

  • Nvidia announces native GPU programming in Rust, https://nvidia.com (HN #3, 745 pts, 14 h ago) — First-party Rust GPU programming support. Not directly useful on your AMD V620 (ROCm stack), but it signals the CUDA-for-AMD (ZLUDA, covered 9/14) gap may narrow as the ecosystem bifurcates. More relevant if you ever need to write a custom attention kernel and want a second GPU target.

  • Xiaomi Mimo 2.6 live post-training dashboard, https://xiaomi.com (HN #14, 459 pts, 15 h ago) — Public, real-time dashboard showing post-training (RLHF/GRPO) progress for Mimo 2.6: loss curves, reward signals, sample generations updating live. Interesting as a transparency pattern you could replicate for your own distillation/fine-tune runs (log reward curves, sample outputs, and let a dashboard page render them). Field news; no local model component.

Memory, Grounding & Factual Correctness

  • REPAIR (arXiv:2609.18262, EMNLP 2026 Main, code available) — See Notable Research above. The fact-verified iterative refinement is the directly actionable piece for reducing "confidently wrong fact in a kid's game" failures at the retrieval layer.

  • Confidence Comes from Experience: Experiential Confidence Estimation from Reasoning to Agents, https://huggingface.co/papers (Sep 17, Cambridge, 45 upvotes) — Proposes that an agent's confidence should be calibrated from accumulated task experience (how often similar queries produced correct outputs) rather than from a single-pass verbalised probability. For your educational-content pipeline: if the model has generated 200 "solar system" explanations and been fact-checked 200 times, the confidence prior for the 201st should reflect that track record, not a generic "I'm 95 % sure" token. No code link in scrape.

  • The Mirage of Calibrated Confidence: Trajectory-Independence of Verbalized Confidence in Vision-Language Models, https://arxiv.org/abs/2609.18453 (EMNLP 2026 Main) — Shows that a VLM's verbalised confidence ("I'm 90 % sure") is statistically independent of the reasoning trajectory that produced the answer. In other words: the confidence token is a near-random prior, not a readout of the computation. Practical implication: do not gate your educational-content validation on the model's stated confidence. Use the REPAIR-style external fact-check instead.

  • Suppressed, Not Erased: A Representational Trace of Edited Facts Survives Even Weight-Free Knowledge Editing, https://arxiv.org/abs/2609.18985 — Even after a knowledge-editing procedure (ROME, MEMIT-style) that claims to remove a fact, the representational trace persists in intermediate layers and can resurface under perturbation. For your pipeline: if you "fix" a wrong fact in a generated lesson by post-editing the text, the model's internal representation of the wrong fact is still there and can leak into the next generated sentence. Reinforces the need for retrieval-level correction (REPAIR) over output-level patching.

  • WFM: Wiki Foundation Model for Complex Agentic Reasoning, https://arxiv.org/abs/2609.18182 (8 authors) — Trains a model specifically on Wiki-scale structured knowledge for multi-step agentic reasoning (entity disambiguation, cross-reference, temporal consistency). If your educational pipeline needs the agent to reason over a local knowledge base (e.g., 200 vetted science facts for ages 6–8) rather than generate from parametric memory, this is the training-data pattern. No code link in abstract.

  • Time-Aligned Evolving Concept Graphs for Scientific Relation Forecasting, https://arxiv.org/abs/2609.18163 — Builds a structural (non-vector) concept graph over scientific relations with temporal alignment, used for relation forecasting. The "structural graph over domain knowledge" pattern is directly transferable to a curriculum-knowledge graph for your educational content: entities (concepts), edges (prerequisites, related-to), temporal axis (when a concept is introduced in the curriculum). No code link.

  • Cognitive Extensions for Dual-Process Language Agents: Memory and Self-Reflection in Interactive Environments, https://arxiv.org/abs/2609.19128 (2 authors, 13 pp.) — Frames agent memory as a dual-process system (System 1: fast parametric recall; System 2: slow reflective lookup) with explicit self-reflection triggers. 13 pages, compact. The self-reflection trigger design ("when should the agent stop trusting its first answer and re-derive?") is the missing logic in most naive RAG loops. No code link.

Games, Engines & 3D

  • Zing-0.5: Toward Playable Worlds with Real-Time Joint Action and Text Control, https://huggingface.co/papers (Sep 17, 16 authors, 24 upvotes) — A foundation model that jointly controls multiple agents in a 3D world in real time via both actions and natural-language instructions, targeting "playable worlds." 16 authors and the "playable" framing suggest a working demo rather than a paper-only result. If this ships a playable demo or open weights, it's a direct reference architecture for your LLM-driven game generation: the text-to-action interface is the same shape as "LLM generates a quest → Godot executes it." No direct code/demo link in scrape.

  • Compiled Agency: Frontier General-Purpose Coding Agents Build Winning Game Players from Bare Interaction — from Flappy Bird to StarCraft II and Civilization, https://arxiv.org/abs/2609.18996 (2 authors) — Takes frontier coding agents and gives them only the game's interaction interface (no source code, no docs); the agent must build a winning player by playing and reading the environment. Spans Flappy Bird → StarCraft II → Civilization. Validates the "LLM-as-game-AI-engineer" paradigm at the capability level you're targeting for procedural content generation: the model doesn't need the level editor, it needs the rules and the feedback loop. 2 authors, no code link in abstract; check for a repo post-acceptance.

  • MoQSplat: Adaptive Progressive Streaming of 3D Gaussian Splatting via MoQ, https://arxiv.org/abs/2609.18624 (IEEE MMSP 2026, 7 pp., code: https://github.com/emanuele-artioli/MoQSplat) — Adaptive streaming of 3DGS content: the player pulls only the splat detail it needs at its current viewpoint/zoom, via a Media-over-QUIC (MoQ) transport. If your Godot game pipeline is moving toward 3DGS for level geometry (cheaper than mesh for organic/voxel environments), this streaming layer is the "don't load the whole world at level start" piece. Runnable repo linked.

  • PhysStream: Streaming Physics-Grounded Video Generation with Structured Scene Memory and Fine-Grained Motion Control, https://arxiv.org/abs/2609.17521 (7 authors, cross-listed cs.CV/cs.AI/cs.GR) — Generates video with enforced physical consistency by maintaining a structured scene-memory (object states, collision constraints) across frames, rather than treating each frame independently. The "structured scene memory as a physics constraint set" pattern is the same shape as what you'd want for validating generated game levels: "object A cannot be inside object B, gravity is −9.8, the platform is at y=3." Not a game tool, but the constraint-propagation architecture transfers. No code link.

  • CADSplat: Sparse-View 3D Gaussian Splatting Aided by CAD Models for Robust, Photorealistic Digital-Twin Reconstruction, https://arxiv.org/abs/2609.18473 (3 authors) — Uses CAD model geometry as a structural prior to stabilise 3DGS reconstruction from very few views. Relevant if you're generating game assets where you have a rough CAD/mesh blockout and want to "photorealise" it with splatting rather than starting from scratch with text-to-3D. No code link.

Models to Download & Try

  • Edge0-35B-A3B-preview, https://huggingface.co/Edge0/Edge0-35B-A3B-preview (HF trending #1, 37.1 k stars, 3.26 k likes, updated ~7 h ago) — 35 B total MoE, 3 B activated per token. At Q4 the 3 B active + shared layers are ~2 GB in VRAM; the 35 B expert pool is SSD-streamed via the trained routing-prediction method (see Notable Research). On your 32 GB V620 this should run with the active slice in VRAM and ~10 GB headroom for 64K+ context. This is a 3× total-knowledge-base upgrade over your 27 B dense primary at comparable active-compute cost. "Preview" tag: expect rough edges in the routing-prediction model. Pull via Ollama if the GGUF is up; otherwise vLLM + llama.cpp with SSD offload.

  • muse-glimmer (Meta), https://ollama.com/library/muse-glimmer — 30 B dense, Apache 2.0, "built for always-on local agents… tuned for tool use, long tasks, and failure recovery." At Q4_K_M ≈ 19 GB weights, leaving ~13 GB for context on 32 GB — enough for 64–96K context with thinking. The "failure recovery" tuning is the differentiator vs. a generic 30 B instruct model: it's post-trained on agent-loop failure modes (tool call rejected, partial state, retry). Directly addresses the "my 27 B primary loses the thread after 5 tool calls" problem. Pullable from Ollama.

  • Laguna XS.2, https://ollama.com/library/laguna-xs.2 — 33 B total MoE, 3 B activated per token, "designed for agentic coding and long-horizon work on a local machine." Same MoE-on-32 GB profile as Edge0-35B-A3B. The "long-horizon" framing and Ollama-native availability make it the lowest-friction test of the MoE-local-agent pattern. Compare decode speed and tool-call reliability against your Qwen3.8 primary on your standard harness.

  • kimi-k2.7-code, https://ollama.com/library/kimi-k2.7-code — Moonshot AI's coding-focused agentic model, "built upon Kimi K2.6, with substantial improvements on real-world long-horizon coding tasks and roughly 30 % lower thinking-token usage." The 30 % thinking-token reduction is directly relevant: your Qwen3.8 runs with thinking enabled at 131 K context; a model that reaches similar coding quality with 30 % fewer thinking tokens frees ~30 K context budget or ~30 % more VRAM headroom. Size not specified in the Ollama listing; check the model card before pulling. Vendor-reported "30 %" — no independent reproduction in the scrape.

  • XHToken/Spark-X2.5-4B, https://huggingface.co/XHToken/Spark-X2.5-4B (HF trending, 28.3 k stars, 1.25 k likes, updated 2 d ago) — 4 B text-generation model, trending heavily. Small enough to run as a fast draft model for speculative decoding against your 27 B primary, or as a standalone lightweight agent for high-volume scheduled tasks. 28 k stars in 2 days suggests strong early community signal. No benchmark numbers in the scrape; check the model card.

Skipped as Already Covered

  • OpenAI GPT-Image multi-turn / 3 B images update — covered 9/13 (Simon Willison post).
  • GIMP MCP server (maorcc) — covered 9/16.
  • NUS "AI for Games in the Foundation Model Era" survey — covered 9/16.
  • Gemini 3.8 Live + Extended Thinking — covered 9/16.
  • Qwen3.8-27B base and GSQ-RCO-GGUF / unsloth GGUF variants — user's current primary, no new capability delta in scrape.
  • CUDA-for-AMD / ZLUDA ROCm bridge — covered 9/14.