Dauntless · Systems

Open-loop digest

September 25, 2026

35 items · 15.6 KB

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

Agentic Frameworks, Tooling, Skills

  • Jevmem – automatic project memory for Claude Code, https://github.com/avinash-jetwani (HN, 43 pts, 30 comments) — Automatic project memory built on Jev (the "System One" decision-model format: returns floats for yes/no/ratings rather than free text). The "automatic" framing means it's not a prompt you write; it's a memory layer that attaches to the agent session. If your Godot content pipeline needs persistent project state across sessions without hand-maintaining a memory file, this is a ready-to-try integration. 43 pts / 30 comments suggests early-stage but real interest.

  • Meta Muse Glimmer (Ollama), https://ollama.com/library/muse-glimmer — 30B parameters, Apache 2.0, "built for always-on local agents…tuned for tool use, long tasks, and failure recovery." Runs on a single GPU. This is the local-inference counterpart to Meta's consumer Muse product (see Frontier section). 30B at Q4_K_M ≈ 18 GB weights, leaves ~12 GB for KV-cache at 131K context — tight but viable on your 32 GB card. No independent benchmarks in today's scrape; vendor description only.

  • Laguna XS 2.1 / XS.2 (Ollama), https://ollama.com/library/laguna-xs-2.1, https://ollama.com/library/laguna-xs.2 — 33B total-parameter MoE with only 3B activated per token, "designed for agentic coding and long-horizon work on a local machine." 3B activated means the inference cost profile is closer to a 3B dense model; the full 33B weight set at Q4 is ~20 GB, well within your 32 GB. Two versions (2.1 and XS.2) suggest iterative refinement. No benchmarks visible in the scrape.

  • Kimi K2.7 Code (Ollama), https://ollama.com/library/kimi-k2.7-code — Moonshot AI's coding-focused agentic model, "substantial improvements on real-world long-horizon coding tasks and roughly 30% lower thinking-token usage" vs. K2.6. Parameter count not stated in the scrape; K2.6 is described as "open-source, native multimodal agentic." The 30% thinking-token reduction is the actionable claim: fewer reasoning tokens per task = lower latency and lower context burn at 131K. Vendor-reported, no independent reproduction in today's sources.

  • AgentKernel: The Trust-Native Agentic Operating System (HF Daily Papers, 4 upvotes, 6 authors), no arXiv ID captured in the scrape — "Trust-Native" framing suggests the agent runtime enforces capability boundaries (sandboxing, permission scoping) as a first-class architectural primitive rather than a prompt-level convention. 4 upvotes is early. No repo or code link visible.

Notable Research

  • Qwengram-0.8B: transferring PLE n-gram memory into a small backbone, https://www.reddit.com/r/LocalLLaMA/comments/1wpvep4/qwengram08b_i_transferred_qwen38_flashnexts_ngram/ — Concrete recipe: freeze Qwen3.5-0.8B backbone + freeze ~51B-parameter PLE (n-gram) memory from Qwen3.8-Flash-Next, train only a small R=1 reader at decoder layers 3 and 9 with a token-dependent linear gate. No backbone fine-tuning. Result on a frozen validation set: PPL 18.28 → 17.37 (−5.05%). The method is transferable: if you want to bolt Flash-Next's n-gram memory onto your 27B primary without retraining the backbone, this is the architectural pattern. Trained on free Kaggle GPUs, 15M tokens of reader training.

  • JevOut: Natural Context Can Flip Decision Models, https://arxiv.org/abs/2609.30243 (32 pp., 5 figs., 23 tables; code: https://github.com/xzx34/JevOut) — Demonstrates that "System One" decision models (the float-outputting format, e.g. Jev) can be flipped by natural-language context injected around the decision prompt. 23 tables of perturbation analysis. If you build a validation gate that asks a small model "is this fact correct? 0–1," this paper is the threat model: the gate can be gamed by the surrounding text. The code repo lets you reproduce the flip attacks against your own gating setup.

  • Does a model's stated reason for rejecting a candidate do any work?, https://arxiv.org/abs/2609.30151 (LLM4XAI 2026 oral; code: https://github.com/ArchitRastogi20/contrastive-rejection-test) — Tests whether a model's stated rejection reason ("I reject because X") is causally load-bearing or post-hoc rationalisation. If it's the latter, your content-pipeline's "the model explained why it flagged this fact as wrong" is decorative, not diagnostic. The contrastive test methodology is directly reusable as a gate in your educational-content validation.

  • Low-Cost Assays for Measuring Model Behavior Across Vendors and Releases, https://arxiv.org/abs/2609.30012 (6 pp.; code + data: https://github.com/tap2k/modelun) — "Assays" framing: short, cheap probes that characterise model behaviour (format adherence, refusal patterns, calibration) without full benchmark suites. Relevant if you want a 5-minute smoke test before pulling a new 30B model to confirm it isn't silently regressing on your specific task distribution.

  • Constrained Program Generation for 3D Reaction Animation with a 0.8B Model, https://arxiv.org/abs/2609.24457 (11 pp., 5 figs., 2 tables) — Generates 3D reaction animation as constrained programs (not raw keyframes) using a 0.8B model. The constraint-programming framing is the transferable idea: rather than asking a small model to output coordinates, you have it emit a constrained program that a solver validates. Applicable to procedural level/puzzle generation where "solvable" is a hard constraint, not a soft preference.

Frontier Lab Updates

  • Meta Muse (consumer product; local version: Muse Glimmer), https://ollama.com/library/muse-glimmer — Simon Willison's assessment: "groundbreaking technically (each user gets their own entire persistent Linux VM running in Meta's cloud)…the first consumer-accessible agentic AI system." Reddit thread (https://www.reddit.com/r/LocalLLaMA/comments/1wpbeb7/meta_muse_appears_to_be_excited_to_give_away_its/) reports Muse "appears to be excited to give away its system data" — a potential sandbox-escape or prompt-injection surface. The 30B local variant (Glimmer) is the actionable piece: same agentic tuning, runs on your card.

  • Claude Cowork + Claude chat merging into a single product (via Simon Willison, https://simonwillison.net/) — "Starting today, Claude Cowork and chat are merging into one Claude…rolling out to Pro and Max plans first." This consolidates Anthropic's agent surface (Cowork) into the main chat app. Practical implication: your orchestration prompts that target Claude Code vs. Cowork vs. chat may need a single unified interface going forward.

  • Anthropic and OpenAI released new models (via Simon Willison, https://simonwillison.net/) — "Today Anthropic [released], and around an hour later OpenAI [released]." The specific model names are redacted in the scrape (bracket gaps). No capability details, benchmarks, or API documentation captured. Flagging for awareness; check both vendors' release pages for specifics.

  • Gemma 4 Developer Agent Competition (https://www.reddit.com/r/LocalLLaMA/comments/1wpqyaz/gemma_4_developer_agent_competition/) — Google's new competition for agent development. Single Reddit post, no rules or prize details in the scrape. Worth watching if you want a structured eval harness for your local-primary agentic capability.

  • Microsoft Abandons Personal AI Chatbot Race with Copilot Reboot (HN, 47 pts, via Bloomberg) — Field news. No product substance in the scrape.

Memory, Grounding & Factual Correctness

  • Jevmem (covered in Agentic section above) — Automatic project memory for coding agents. The "built on Jev" part means the memory queries/answers use the decision-model float format rather than free-text, which sidesteps some hallucination surface (a 0.82 "is this relevant?" is harder to fabricate than a paragraph).

  • Just Ask Jev: Reinforcement Learning for Calibrated Decisions as a Zero-Shot Detector of AI Alignment Failures (HF Daily Papers, 2 upvotes, 9 authors), no arXiv ID in scrape — Uses RL-trained decision models as zero-shot probes for alignment failures. The "zero-shot detector" framing is the hook: you don't need a fine-tuned classifier to flag a generated fact as suspicious; a calibrated 0–1 output from a small decision model on "is this claim consistent with [source]?" could serve as a cheap pre-gate before your content pipeline emits a lesson. Thin entry (2 upvotes, no code visible); check for a repo before acting.

  • Return or Revise? Learning When Revision Helps Retrieval-Augmented QA, https://arxiv.org/abs/2609.30087 (25 pp., 4 figs.) — Learns a policy for when to pass retrieved context through as-is vs. when to revise/rewrite it before the answer. If your educational-content RAG pipeline sometimes retrieves a correct fact but the model mangles it in paraphrase, this is the "should I trust the retrieval or re-derive?" decision. No code link visible.

Games, Engines & 3D

  • AgenticCADedit: A Stateful, Tool-Mediated Agentic Approach to Multimodal 3D CAD Editing, https://arxiv.org/abs/2609.29621 (5 authors) — "Stateful" is the key word: the agent maintains a running CAD state and edits incrementally via tool calls, rather than regenerating the full model each turn. This is the pattern you'd want for iterative 3D-printable model refinement (the Reddit 3D-printing workflow below shows the current manual approach). No code link visible.

  • Qwen3.8 27B + Qwen Image 2.1 + ComfyUI: 3D-printable model generation pipeline (https://www.reddit.com/r/LocalLLaMA/comments/1wpet4j/qwen38_27b_practical_modeling_for_3d_printing/) — A user built a working pipeline: Qwen 27B generates cadquery code for a self-watering plant pot and MagSafe phone stand, Qwen Image 2.1 renders product shots, ComfyUI composites an "advertisement" scene. "I had pi build me some skills to use cadquery and comfy." Not perfect but demonstrates the full prompt→CAD→render→composite loop on local models. The skill-building step (converting the workflow into reusable agent skills) is the transferable pattern for your Godot content pipeline.

  • ToCo-Mesh: Topology-Consistent Dynamic Mesh Reconstruction via Adaptive Tessellation and Surface-Aligned 2DGS, https://arxiv.org/abs/2609.29529 (6 authors; project page linked in abstract) — Reconstructs dynamic meshes while preserving topology, using adaptive tessellation + surface-aligned 2D Gaussian splatting. Relevant if your game assets need retopology between a high-res scan and a game-ready mesh.

  • OREO: Fidelity Alignment in 3D Generation via On-the-fly Rendering-Editing Optimization, https://arxiv.org/abs/2609.29788 (6 authors, ECCV 2026; project page linked) — Iteratively optimises 3D generation by rendering, comparing to target, and editing in the same loop. The "on-the-fly rendering-editing" cycle is a validation gate pattern: generate → render → check → edit, rather than generate-and-hope.

  • Physically Based Rendering in the Latent Space, https://arxiv.org/abs/2609.21054 (4 authors, Pacific Graphics 2026 Journal Track; code linked in abstract) — PBR computed in latent space rather than pixel space. If you're doing texture/material synthesis for game assets, operating in latent space avoids the artifact-heavy decode step. Code is available (linked in the arXiv abstract; URL not captured verbatim in the scrape).

  • ProxyBuild: Text-Guided Structured 3D Building Generation with Mesh-Anchored Procedural Proxies, https://arxiv.org/abs/2609.23386 (3 authors, 15 pp., 9 figs.) — Generates 3D building geometry from text using "mesh-anchored procedural proxies" as intermediate constraints. The proxy-as-constraint pattern (generate a coarse mesh first, then refine within its boundaries) is applicable to procedural level geometry where "roughly the right shape" must be guaranteed before detail.

Models to Download & Try

  • Meta Muse Glimmer (Ollama), https://ollama.com/library/muse-glimmer — 30B, Apache 2.0, "tuned for tool use, long tasks, and failure recovery." Estimated VRAM at Q4_K_M: ~18 GB weights + KV-cache. At 131K context the KV-cache will be the constraint; at 32K context it should fit comfortably. No independent benchmarks in today's scrape; the 30% and "failure recovery" claims are vendor descriptions. Compare against your Qwen3.8 27B on a tool-use task before committing.

  • Laguna XS 2.1 (Ollama), https://ollama.com/library/laguna-xs-2.1 — 33B MoE, 3B activated. "Designed for agentic coding and long-horizon work on a local machine." At Q4 the 33B weight set is ~20 GB; only 3B parameters active per token means decode speed should approach a 3B dense model. No benchmarks in the scrape. The 3B-activated profile makes this a strong candidate for a fast "routing" model alongside your 27B primary.

  • Xing4.0-29B-A4B (Hugging Face), https://huggingface.co/XingChen-AGI/Xing4.0-29B-A4B — 31B total, A4B (presumably 4B activated MoE), 43k stars, updated 7 days ago. The A4B designation means 4B active parameters — inference cost close to a 4B model. No benchmark table in the scrape; check the model card.

  • Ternary-Bonsai-2-27B (Prism ML, Hugging Face), https://huggingface.co/prism-ml/Ternary-Bonsai-2-27B-gguf — 1-bit quantisation of a 27B model, ~5.95 GB GGUF. Simon Willison reports ~20 tok/s on M5 Pro (after a restart, 44 tok/s; he notes "I'm pretty sure something isn't working right" and the server emitted a startup warning). The 1-bit format is the interesting part: if the quality is acceptable for routing/summarisation tasks, you can keep a 27B-class model resident alongside your Q4 primary. Check the prism-ml/Ternary-Bonsai-2-27B-mlx-2bit (54.1k stars) variant for MLX users. Vendor-reported speed; no accuracy numbers in the scrape.

  • Qwen3.8-27B "Swift" and "ThinkingCap" community quants (https://www.reddit.com/r/LocalLLaMA/comments/1wpg32w/7900_xtx_two_lowthinking_qwen_38_27b_quants_swift/) — 7900 XTX benchmark, 4 scenarios. Swift: ~45k total tokens (−33% vs base), decode ~32 t/s (−33%), prefill ~614 t/s (fastest of the three), quality ~84–87 on the user's eval. ThinkingCap: ~49k tokens (−26%), decode ~43 t/s, prefill ~100 t/s (slowest), quality ~84–87. The user's eval scale is undisclosed (84–87 "same band as base"). These are thinking-token reduction quants: the model generates fewer reasoning tokens while maintaining output quality. On your 32 GB card the decode-speed tradeoff matters less than on a 7900 XTX; the token savings (26–33%) translate directly into lower context consumption at 131K. The DavidAU GGUF on HF trending (https://huggingface.co/DavidAU/Qwen3.8-27B-TURBO-Fable-Cold-Fusion-735-882-Heretic-Uncensored-NEO-CODER-MAX-MTP-GGUF, updated 11h ago, 1.55M stars) may be a related or upstream build.

Skipped as Already Covered

  • OpenAI compaction prompt-injection persona (full text now visible on simonwillison.net) — covered in 9/24 digest under "LLM Compaction Prompt Injection"; today's scrape adds the verbatim injected text but no new technical development.
  • Qwen3.8-Flash-Next RAM-offload inference on 12 GB VRAM (Reddit) — FreeToken fork / RAM-offload MoE serving was covered in 9/23 digest; today's post is a different user on different hardware with a custom engine, not a new tool.
  • "Is Qwen Flash Next at like Q2 better than 27B at Q4?" (Reddit discussion) — no new data, same question as 9/23 FreeToken / 9/22 quant-efficiency thread.
  • M5 Ultra prefill-step-size tuning (Reddit PSA) — hardware-specific to Apple Silicon, no transferable technique for ROCm/AMD.
  • HBM / High Bandwidth Flash hardware discussion (Reddit, 2 threads) — not AI-model-relevant, no engineering consequence for a 32 GB GPU user.
  • Rust crate supply-chain attack (Simon Willison) — security news, no AI-agent consequence.