Artificial Intelligence News

Liquid AI released LFM2.5-8B-A1B today. It's an on-device Mixture-of-Experts model that activates just 1.5B of 8.3B parameters per token. Here's what's actually interesting for anyone building local agents: 1. It's reasoning-only nowUnlike October's LFM2-8B-A1B, this version produces an explicit chain of thought before answering. The logic: in an MoE, a small active parameter count makes each reasoning token cheap. 2. The hallucination jump is the real story→ Non-Hallucination Rate: 7.46 → 63.47 → IFEval: 79.44 → 91.84 → MATH500: 74.80 → 88.76 → Tau² Telecom: 13.60 → 88.07 A targeted avg@k RL reward trains the model to abstain on questions beyond its knowledge. 3. It runs on hardware you already own→ 253 tok/s on an M5 Max, under 6 GB → ~30 tok/s on a phone → 18.5K tok/s and over 1.6B tokens/day on a single H100 4. Tool calling is the pointThe LocalCowork demo runs 67 tools across 13 MCP servers on one laptop. No cloud, no API keys, no data leaving the machine. Day-one support for llama.cpp, MLX, vLLM, and SGLang. Open weights, with base and post-trained checkpoints. Full analysis: https://lnkd.in/gXK5FN_Y Technical details: https://lnkd.in/gp3M7wJj Model weights: https://lnkd.in/gpgqeFcB Liquid AI Maxime Labonne

NVIDIA Releases Polar, a Token-Faithful Rollout Framework for GRPO Training Across Codex, Claude Code, and Qwen Code Most RL systems require you to rewrite your agent harness to fit the training infrastructure. Polar flips that. It treats the harness as a black box and intercepts at the one boundary every LLM agent shares: the model API call. Here's what's actually interesting: 𝟭. The proxy design Polar places a provider-compatible proxy between the harness and the inference server. It accepts Anthropic Messages, OpenAI Chat Completions, OpenAI Responses, and Google generateContent — no harness code changes needed. The only configuration change is pointing the model base URL at the gateway. 𝟮. Token-faithful trajectory reconstruction Two strategies: per_request (every model call = one trace) and prefix_merging (reconstructs append-only conversation chains). The ablation is clear: → Trainer updates: 1,185 (per_request) vs. 218 (prefix_merging) → Wall-clock time: 189.5 min vs. 35.2 min → 5.39× speedup → Rollout GPU utilization: 20.4% vs. 87.7% 𝟯. SWE-Bench Verified results (Qwen3.5-4B, GRPO) → Codex: 3.8% → 26.4% (+22.6 pts) → Claude Code: 29.8% → 34.6% (+4.8 pts) → Qwen Code: 34.6% → 35.2% (+0.6 pts) → Pi: 34.2% → 40.4% (+6.2 pts) The Codex gain is the largest because Codex presents an unfamiliar action protocol and patch-submission style to a Qwen model not originally trained on it. Polar attaches the reward to the actual sampled tokens flowing through that execution path. 𝟰. Offline SFT use case Polar also works as a distributed data generation service. Using Qwen3.5-122B-A10B on 8×H100, NVIDIA generated 504 accepted SFT trajectories from 1,638 SWE-Gym attempts (30.8% acceptance) at ~64 GPU-hours. Released on HuggingFace under Apache-2.0. Full analysis: https://lnkd.in/diXqSSs7 Paper: https://lnkd.in/deCmewva Repo: https://lnkd.in/gEDpMJSH NVIDIA NVIDIA AI Binfeng Xu Hao Zhang Shaokun Zhang Songyang Han Mingjie Liu Jian Hu Shizhe Diao Zhenghui Jin Yunheng(Jackie) Zou Yunheng(Jackie) Zou Jan Kautz Yi Dong

Perplexity just open-sourced an internal security tool they've been running in production. It's called 'Bumblebee'. Here's what's actually interesting: 1. It solves a specific blind spot SBOMs cover build artifacts. EDR covers running processes. Neither tells you what's installed on a developer's laptop right now. Bumblebee does exactly that — and nothing more. 2. The read-only design is the key decision npm packages can carry postinstall scripts that execute automatically on install. Most recent supply-chain worms spread that way. A scanner that invokes npm to check exposure has already triggered the attack. Bumblebee reads metadata directly — lockfiles, manifests, extension manifests — and never runs any code. 3. Four surfaces in one scan → Language package managers: npm, pnpm, Yarn, Bun, PyPI, Go modules, RubyGems, Composer → AI agent configs: MCP JSON host files including claude_desktop_config.json and cline_mcp_settings.json → Editor extensions: VS Code, Cursor, Windsurf, VSCodium → Browser extensions: Chrome, Edge, Brave, Arc, Comet, Firefox 4. The internal workflow is worth noting Perplexity Computer drafts a catalog entry when a threat signal lands → human reviews and merges the PR → Bumblebee runs on endpoints → findings go to the security team. Human in the loop before anything hits machines. 5. Technical details → Written in Go 1.25+, zero non-stdlib dependencies → Single static binary, three scan profiles: baseline, project, deep → Outputs NDJSON records with confidence levels (high / medium / low) → Apache 2.0, current release v0.1.1 Full analysis: https://lnkd.in/gf6xXrBY Repo: https://lnkd.in/g4EcxbF2 Technical details: https://lnkd.in/gp6icukB. Perplexity

Most sparse attention methods make a quiet assumption: that you can ship a custom kernel for selection and deal with the inference consequences later. Nous Research's new paper just explained that assumption is optional. They released Lighthouse Attention — a selection-based hierarchical attention for long-context pretraining that pools Q, K, and V symmetrically across a multi-level pyramid, places selection entirely outside the attention kernel, and runs stock FlashAttention on a small dense sub-sequence. No custom sparse kernel. No auxiliary losses. No learnable scorer. No straight-through estimator. Here's what's actually interesting: → 21× faster forward pass and 17.3× faster forward+backward vs. cuDNN SDPA at 512K context on a single B200 → 1.40–1.69× end-to-end pretraining wall-clock speedup at 98K context at matched or lower final training loss → Brief dense-SDPA resumption after Lighthouse training recovers a full-attention model that beats dense-from-scratch (loss 0.6980 vs. 0.7237 baseline, same ~50.3B token budget) → Scales to 1M-token training across 32 Blackwell GPUs under standard ring attention — no sparse-aware collectives needed Train with hierarchical selection to move fast, then recover the dense model you actually need at inference. Analysis: https://lnkd.in/g9-n4xas Paper: https://lnkd.in/g2t9x3du Technical details: https://lnkd.in/gEYeMhSV GitHub Repo: https://lnkd.in/g87ykMXY Nous Research

Most LLM pre-training efficiency work either changes the tokenizer, the architecture, or the inference behavior. Nous Research just showed you don't have to touch any of them. They released Token Superposition Training (TST) — a two-phase modification to the standard pre-training loop that averages s contiguous token embeddings into a single latent s-token in Phase 1, trains with a multi-hot cross-entropy loss against the next bag of tokens, then reverts to standard next-token prediction in Phase 2 from the same checkpoint, with the TST code fully removed. Here's what's actually interesting: → Each TST step is kept equal-FLOPs to baseline by increasing data sequence length by s× — not the batch size → 3B dense: loss 2.676 in 247 B200-hrs vs 443 B200-hrs for baseline at matched loss (~1.8x faster) → 10B-A1B MoE: 4,768 B200-hrs vs 12,311 B200-hrs at matched loss (~2.5x faster) → Optimal range: bag size s ∈ [3–8] at 270M, s ∈ [6–10] at 600M, s = 16 at 10B; step ratio r ∈ [0.2, 0.4] → Re-initializing the embedding or LM head at the phase boundary breaks it entirely — loss went from 2.676 to 2.938, worse than the 2.808 baseline Full analysis: https://lnkd.in/gMv6_SJK Paper: https://lnkd.in/gV_sbPdn Project page: https://lnkd.in/gE8c8iAp Nous Research

Why are we still running 7B–27B autoregressive decoder models for what is fundamentally a text classification problem? Fastino Labs Open-Sources GLiGuard: A 300M Parameter Safety Moderation Model That Matches or Exceeds Accuracy of Models 23–90x Its Size It is a 300M parameter safety moderation model that runs 16x faster than the current generation of guardrail models. Here's what's actually is interesting to learn: 1. It's an encoder, not a decoder Most guardrail models (LlamaGuard4, WildGuard, ShieldGemma) generate safety verdicts autoregressively — one token at a time. That's slow by design. GLiGuard reframes the whole thing as a text classification problem. One forward pass. Done. 2. Four moderation tasks. Zero added latency. It evaluates all four simultaneously in a single pass: → Safety classification (safe / unsafe) → Jailbreak strategy detection (11 strategies) → Harm category detection (14 categories) → Refusal detection (compliance / refusal) More safety dimensions = no extra compute. That's the architectural win. 3. The benchmark numbers are hard to ignore → 87.7 avg F1 on prompt classification — within 1.7 points of the best model (PolyGuard-Qwen at 89.4) → 82.7 avg F1 on response classification — second only to Qwen3Guard-8B (84.1) → 26ms latency vs. 426ms for ShieldGemma-27B at sequence length 64 → 133 samples/sec throughput vs. 8.2 at batch size 4 → Outperforms LlamaGuard4-12B, ShieldGemma-27B, and NemoGuard-8B — all 23–90x larger 4. It runs on a single GPU At 0.3B parameters, individual developers and smaller teams can deploy and fine-tune it without heavy infrastructure. Full analysis: https://lnkd.in/gUGrgbSg Paper: https://lnkd.in/gqeb8XBA Model weights on HF: https://lnkd.in/gd3mFBiA GitHub Repo: https://lnkd.in/grNhQV6y Technical details: https://lnkd.in/g98nFXgy Fastino Labs Urchade Zaratiana Mary Newhauser George Hurn-Maloney Ash Lewis