本日は特に大きな出来事なし

a quiet day.

AI News for 4/11/2026-4/13/2026. We checked 12 subreddits, 544 Twitters and no further Discords. AINews' website lets you search all past issues. As a reminder, AINews is now a section of Latent Space. You can opt in/out of email frequencies!

AI Twitter Recap

Agent Harnesses, Coding Workflows, and the Shift from Single-Model to System Design

• Harness engineering is now a first-class discipline: A recurring theme across AI Engineer Europe takeaways, Vtrivedy’s framing of harness primitives, and multiple agent-builder posts is that useful agents are not “just models.” Filesystems, bash, compaction, memory, permissions, retries, evals, and subagents are increasingly treated as core product surface. This is echoed by Andrew Ng, who argues the bottleneck is shifting from implementation to deciding what to build, and by Steve Yegge, who claims enterprise adoption is still far behind frontier practice despite broad tool access.

• OpenAI’s Codex usage patterns suggest agentic coding is broadening beyond SWE: OpenAI shared a practical catalog of Codex workflows—understanding large codebases, PR review, Figma-to-code, bug triage, dataset analysis, CLI tools, onboarding, and even slide generation—via @gabrielchua. In the field, users report the same “agents as glue” pattern: e.g. giffmana using Codex to patch Java/Qt binaries on Linux for a niche Wayland/HIDPI issue, while others remain skeptical that current models yet outperform direct human implementation for trusted production work, as in Rhys Sullivan’s critique.

• Tooling is converging on multi-agent orchestration, observability, and remote control: GitHub shipped Copilot remote control from web/mobile, with follow-up from @tiagonbotelho. Cursor added split agents plus search/perf improvements. LangChain emphasized guardrails via middleware and filesystem permissions, while deepagents’ mental model reduces subagents to structured tool/function calls as described by @ElliotHyun. The common pattern: agent products are maturing by exposing control planes, not by claiming fully autonomous reliability.

Hermes Agent’s Dashboard Release, OpenClaw Competition, and Open Agent Stacks

• Hermes is consolidating momentum as the most discussed open harness of the day: The headline release is Hermes Agent v0.9.0 with a local web dashboard, fast mode, backup/import, stronger security hardening, and broader channel support; see @Teknium and the official @NousResearch announcement. Community reaction frames the dashboard as the feature that could take Hermes beyond power users, including Shaun Furman’s “openclaw moment” claim.

• OpenClaw is still shipping, but comparison discourse is tilting toward Hermes on UX and efficiency: OpenClaw posted a substantial update—memory imports, “Memory Palace,” richer chat UI, plugin setup guidance, better video generation, and more integrations—via @TheTuringPost. But several users explicitly report preferring Hermes over OpenClaw for speed, architecture, or token efficiency, including dabit3, robinebers, and ZainanZhou’s harness-level explanation that better preselection/context shaping may be reducing token burn.

• The open ecosystem around agent stacks is thickening: Open Agents was open-sourced as a cloud coding agent stack; bromann contrasted it with DeepAgent as a lower-level runtime with pluggable model providers, sandboxes, middleware, and tracing. Hermes itself is accumulating community skills, tutorials, multi-agent recipes, and integrations—from Chinese tutorial roundups to practical “team of 4 agents” guidance from @coreyganim. The notable technical pattern is persistent role separation plus isolated memory, rather than naive “one agent does everything.”

Cybersecurity, Model Capability Escalation, and the Mythos Shockwave

• Claude Mythos Preview dominated the cyber-security conversation: The UK AI Security Institute reported that Mythos is the first model to complete an AISI cyber range end-to-end, with follow-on commentary from ekinomicss noting success on a 32-step corporate network attack simulation. Additional reactions emphasized both capability and efficiency, e.g. scaling01 claiming Mythos reaches Opus-level performance at roughly 40% of the tokens after long runs.

• The security implication is not just benchmark progress, but operational usefulness: emollick called the concern warranted; ananayarora pointed to Marcus Hutchins’ reaction as especially meaningful. The emerging point is that “vulnerability research model” is no longer speculative marketing language; labs and external evaluators are now describing end-to-end exploit workflows completed on independent ranges.

• Defensive tooling is maturing in parallel, but the asymmetry is obvious: The Turing Post’s roundup highlighted 10 open AI security projects, including NVIDIA NeMo Guardrails, garak, Promptfoo, LLM Guard, ShieldGemma 2, and CyberSecEval 3. At the same time, builders are revisiting assumptions that agents can safely replace mature dependencies: dbreunig argues the token math changes once you price in hardening and security review, making well-maintained OSS libraries comparatively more attractive again.

Inference, Retrieval, OCR, and Systems Performance

• Document/OCR evaluation got a serious new benchmark: LlamaIndex released ParseBench, an open benchmark/dataset for document parsing focused on agent-relevant semantic correctness rather than exact-match text similarity. It includes roughly 2,000 human-verified enterprise pages and 167,000+ evaluation rules across tables, charts, content faithfulness, semantic formatting, and visual grounding. One notable result: no parser dominates every axis, but LlamaParse reportedly leads overall at 84.9%.

• Hugging Face showed OCR at industrial scale can be cheap and reliable with open models: @ClementDelangue reported OCR’ing 27,000 arXiv papers into Markdown using an open 5B model, 16 parallel HF Jobs on L40S, for about $850 in ~29 hours, now powering “Chat with your paper.” The follow-up identified the model as Chandra-OCR-2.

• Retrieval and transport-layer optimizations continue to matter: LightOn shipped ColGrep 1.2.0 with BM25 trigrams for hybrid multi-vector retrieval and relative paths to save tokens, positioning it as an easy agent-search upgrade. On the systems side, Lewis Tunstall and colleagues highlighted a non-obvious on-policy distillation bottleneck: vLLM transmitting logprobs as JSON over the wire. Switching to binary NumPy arrays yielded a 1.4x speedup, a useful reminder that infra wins often sit outside kernels and model code.

• Compression and speculative decoding remain high-leverage deployment levers: Red Hat AI showed a Gemma 4 31B quantized deployment on vLLM with nearly 2x tokens/sec, half the memory, and 99%+ accuracy retained. On speculative decoding, posts covered DFlash adapters for Kimi/Qwen-family local speedups, Baseten’s EAGLE-3 production advice, and new research such as DDTree, which drafts a tree in one block-diffusion pass to verify multiple continuations jointly.

Research Directions: Memory, Verification, RL, and Model Architecture

• Long-context memory research is pushing beyond vanilla KV cache scaling: behrouz_ali outlined “Memory Caching,” a family of architectures that compress context into a slowly growing recurrent memory, aiming for effective memory growth closer to attention but inference cost closer to RNNs. Sparse Selective Caching is positioned as the most practical variant. Related commentary from askalphaxiv frames it as an interpolation between standard recurrence and full quadratic attention.

• Verifier-style test-time methods are becoming a serious agent benchmark strategy: Azali Amirhossein et al. introduced LLM-as-a-Verifier, scoring candidate pairs by asking the model to rank outputs and then using rank-token logprobs to estimate expected quality. The pitch is that winner-selection, not candidate generation, is often the test-time scaling bottleneck; a single verification pass can outperform more cumbersome reranking setups on agentic benchmarks.

• Reasoning discovery remains a weak point, which some see as good news for oversight: Laura Ruis reported that LLMs struggle to discover latent planning strategies even when the strategy is trivial once taught, with scaling up to GPT-5.4 yielding only modest gains. Separately, Wen Sun argued RL-based prompt optimization can generalize from as few as 2 examples where zeroth-order methods overfit. The combined takeaway: there is still substantial room in training objectives and test-time scaffolding before “reasoning” becomes robustly self-bootstrapping.

Top Tweets (by engagement)

• Codex use cases at OpenAI: @gabrielchua shared a broad, practical inventory of internal Codex workflows, spanning code understanding, app building, ops automation, and non-engineering tasks.

• AISI cyber eval of Claude Mythos Preview: @AISecurityInst reported the first end-to-end completion of its cyber range by a model, making this one of the most technically consequential posts in the set.

• Hermes Agent dashboard release: @NousResearch announced the local dashboard and related v0.9.0 features, catalyzing a wave of user comparisons with OpenClaw and Claude Code.

• OpenAI’s “compute-powered economy” memo: @gdb outlined OpenAI’s thesis that software engineering is the leading edge of a broader transition toward compute-mediated work and intent-driven tooling.

• Hugging Face’s large-scale open OCR deployment: @ClementDelangue demonstrated low-cost, fault-tolerant OCR of 27k papers into Markdown using open models and HF Jobs.

AI Reddit Recap

/r/LocalLlama + /r/localLLM Recap

1. Gemma 4 Model Developments and Benchmarks

• Best Local LLMs - Apr 2026 (Activity: 440): The post discusses the latest advancements in local Large Language Models (LLMs) as of April 2026, highlighting the release of Qwen3.5, Gemma4, and GLM-5.1, which claims state-of-the-art (SOTA) performance. The Minimax-M2.7 model is noted for its accessibility, and PrismML Bonsai introduces effective 1-bit models. The thread encourages users to share their experiences with these models, focusing on open weights models and detailing their setups, usage, and tools. The post also categorizes models by VRAM requirements, ranging from 'Unlimited' (>128GB) to 'S' (<8GB). One comment suggests further breaking down categories for models requiring more than 128GB VRAM, indicating a need for more granularity in classifying high-resource models.

A user suggests breaking down categories for models with memory greater than 128 GB, emphasizing the need for more granular classification without relying on labels like 'S' or 'M'. This implies a demand for detailed performance metrics and benchmarks for high-memory models, which could be crucial for applications requiring extensive data processing or complex computations.

• The discussion includes a focus on specialized local LLMs tailored for specific domains such as medical, legal, accounting, and mathematics. This highlights the importance of domain-specific optimizations and the potential for these models to outperform general-purpose LLMs in niche areas by leveraging specialized training data and architectures.

• There is a mention of agentic coding and tool use, which suggests an interest in models that can autonomously interact with tools or APIs to perform tasks. This points to a trend towards developing LLMs with capabilities for dynamic task execution and integration with external systems, enhancing their utility in practical applications.

• Audio processing landed in llama-server with Gemma-4 (Activity: 494): llama.cpp (llama-server) has integrated audio processing capabilities, specifically supporting Speech-to-Text (STT) with the Gemma-4 E2A and E4A models. This update allows native audio support, eliminating the need for separate pipelines like Whisper. However, users report issues with longer audio transcriptions, such as errors in llama-context.cpp and looping sentences. The recommended setup involves using E4B as Q8_XL quant with BF16 mmproj, as other configurations degrade performance. For optimal transcription results, specific templates should be followed, emphasizing precise formatting and number representation. Some users express skepticism about its performance compared to Whisper, while others note that despite the integration, the system struggles with longer audio segments, suggesting that Voxtral performs better in these cases.

Chromix_ highlights several technical issues with the current implementation of audio processing in llama-server, particularly when handling audio longer than 5 minutes. They note that using E4B as Q8_XL quant with BF16 mmproj is recommended, as other formats degrade performance. However, they encounter errors such as llama-context.cpp:1601 and issues with transcription quality, including looping sentences and early termination. They suggest using specific templates for transcription and translation to improve results.

• GroundbreakingMall54 points out the significance of native audio support in llama.cpp, which eliminates the need for a separate Whisper pipeline. This integration is seen as a major improvement for users who previously had to manage multiple systems for audio processing.

• ML-Future shares their experience testing the audio processing feature in Spanish, noting that while it is not perfect, it is quite accurate and performs better than Whisper. This suggests that the new feature may offer improved transcription quality in certain languages compared to existing solutions.

Speculative Decoding works great for Gemma 4 31B with E2B draft (+29% avg, +50% on code) (Activity: 527): The post discusses the implementation of speculative decoding with the Gemma 4 31B model using Gemma 4 E2B (4.65B) as a draft model, achieving significant performance improvements. The setup involved an RTX 5090 GPU and a llama.cpp fork with TurboQuant KV cache, configured with a 128K context and specific draft parameters (--draft-max 8 --draft-min 1). Benchmarks showed a +29% average speedup, with +50% on code generation tasks, attributed to the compatibility of vocabularies between models, avoiding token translation overhead. A critical issue was identified with the add_bos_token metadata mismatch in early GGUF versions, which was resolved by re-downloading updated models. The post also highlights the importance of sett