Auditable AI Text Detectors with Sparse Features
Turning opaque neural text detectors into concept-level, auditable classifiers.
DailyUpdated 2026-11-07 12:20 UTC87 articles120 signals
Every explainer.
Every article Frontier has published, newest first.
UniWALM: closing the loop between language and action
How a unified world–action–language model turns language into on-board robot memory.
Proof-Carrying Contracts for Agent Control
How PC2 uses machine-checkable proofs and an “Airlock” to constrain AI agents.
Monsoon: building speech corpora as a system
Inside a five-stage pipeline for low-resource spontaneous speech that actually moves ASR metrics
Let agents design their own interfaces
Agent S4 shows that evolving tool interfaces from experience can beat static, hand-built UI for computer-use agents.
Evolving semantic indexes for generative retrieval
LLM-driven evolutionary search is starting to auto-design the discrete pieces of generative search indexes.
Agentic SEER Reproducibility at Scale
An AI agent reproduces thousands of SEER-based claims and stress-tests their analytical choices, flagging fragile results for human review.
FuTransformer’s FP8/INT4 path on Hopper, decoded
How FuTransformer restructures Llama-style inference into FP8 prefill and INT4 decode kernels on NVIDIA Hopper.
Tool gateways for agents with 8k+ tools
How a three-tool gateway exposes 8,200 tools to multi-step agents without blowing the context window.
Scaling Tool Use: Recommenders as the Agent Gateway
A tool-recommendation gateway lets agents safely access thousands of tools through three calls while cutting context and cost.
Testing LLM Solidity with SolBehave-style oracles
SolBehave shows that compilation is a weak signal for LLM-generated Solidity and that you need behavioral test oracles wired into your agent stack.
Latent Compaction: training KV caches at test time
How Latent Compaction treats the KV cache as a trainable latent and squeezes 32× context with minimal accuracy loss.
Hybrid Reasoning Agents in practice
How HybridAgents mix latent and text reasoning to cut tokens, cost, and latency while keeping tool use.
Inside OS-Helix’s unified GUI+code action space
How OS-Helix trains a single policy to mix GUI actions and code execution for native desktop agents.
Inside RadarGSOcc’s 4D radar occupancy pipeline
How RadarGSOcc turns sparse 4D radar tensors into Doppler-aware 3D semantic occupancy grids and what that means for autonomy stacks.
Mechanical verification for agentic autoformalization
Using numerical and vacuity checks to keep Lean formalizations honest, beyond “LLM judge” pipelines.
3DCodeVerse and the mechanics of 3D code agents
How a DAG-based harness and a 2M-sample dataset turn 3D scenes into executable code for agents.
How a Gemini 4 agent team cleared Minecraft end-to-end
Four Gemini 4 Argon agents beat Minecraft by coding their own tooling, coordinating over chat, and staying on plan for 27 hours.
Inside Dexterity from Supervised Play
How DSP turns minutes of human play into hours of autonomous data and dexterous control.
ReaDy: speculative drafting with hybrid linear attention
How ReaDy taps hybrid linear attention states to push speculative decoding faster than DSpark on Qwen3.8-27B.
MolLean and process-verifiable chemical agents
How MolLean turns LLM chemistry workflows into executable, checked state transitions.
Cortex and the consolidation–retention frontier
How Cortex turns transient context gains into durable parametric memory without trashing the rest of your model.
Building with Varest-style semantic token compression
How semantic-aware tokenization and in-model pruning cut vision tokens ~20× while keeping most capability.
How SEAR Agents Actually Learn on Robots
Inside SEAR’s three agent modes and what they imply for your robotic stack.
Tev-Gym and PPRS: making long-horizon agents trainable
Tev turns long, sparse-reward tasks into dense, verifiable training signals via a latent-world-first design.
Training drafters by minimizing decode rounds
A Markov-reward view of speculative decoding that trains parallel drafters directly on end-to-end efficiency.
ReplaySSM for hybrid SSM–Transformer stacks
How caching SSM inputs instead of state cuts memory traffic and unlocks faster speculative decoding.
EgoLAP and language-action chains for robots
How a language-based action chain-of-thought narrows the embodiment gap between human egocentric video and robot control.
Lessons from MC-EvoBench for self-improving agents
What a controlled Minecraft benchmark exposes about “learning from experience” in embodied agents.
Backdoored Models That Cryptography Can Hide
New results show you can embed encrypted subnetworks that audits cannot reliably elicit or interpret.
Natural language to protein structure with Prompteina
How Prompteina links text prompts to all-atom protein design and what that implies for agentic bioengineering stacks
Kernaut: agents that write kernels, safely
How Kernel Autoresearch turns kernel design into an open-ended, agentic search over valid programs.
Wiring multimodal patients into clinical KGs
MM-KG makes explicit, testable links between patient data and biomedical graphs, changing how clinical LLM stacks should use knowledge.
Recursive video hierarchies for robot agents
Turning demo videos into navigable tool hierarchies instead of bloated prompts.
Wiring unlearning into your MLLM stack
How Open-MMUnlearning standardizes methods and metrics for multimodal model unlearning—and what you can actually do with it.
Bi-FORK: generative surrogates for bifurcating physics
A generative latent-flow model that learns one-to-many solution maps in high-dimensional physical systems.
Long-WAM: Long-Context Control Without Missing Deadlines
How autoregressive video pretraining and streaming execution make long-horizon robot control actually usable.
Inside RoboRSI’s Top-Down Robot Self-Improvement
How RoboRSI structures skills, feedback, and revision so robots can safely reuse what they learn.
Contextual safety filters for text-driven robot motion
How CSF wraps existing motion generators with scene-aware safety rules without retraining
FastBench and ProactiveFrame for high-speed video agents
What FastBench reveals about streaming VLM limits and how to design frame policies that don’t miss fast events
Assuring AI-written software in real systems
Lessons from a healthcare meta-agent stack where tests, monitors and reviewers all failed in different ways.
FoldBack’s Editable Policies for Long-Horizon Folding
How a masked generative policy rolls back and repairs failed robot grasps without retraining.
SciExam for ENSO: Agents as Climate Modellers
A new benchmark tests whether AI agents can build valid climate models without ever seeing the grading code.
Training web agents that resist evolving prompt attacks
AdvSim2Real co-trains web tasks, attackers, and agents inside a web simulator to harden against adaptive prompt injection.
ScienceClaw and the mechanics of self-evolving agents
How ScienceClaw turns task runs into persistent skills for AI-for-science agents.
QF3: Off‑policy RL for flow policies in robots
How QF3 fuses flow matching and Q‑gradients to train and fine‑tune flow policies efficiently.
Programmatic search agents as executable programs
Turning each search step into a small program over a shared candidate workspace.
RL controllers for autonomous endovascular BCI access
How a Soft Actor-Critic stack navigates cerebral veins and predicts its own failure in vitro.
CLIFT: conformal self-verification for web agents
How CLIFT turns judge feedback into reusable training rewards and test-time trajectory selection for web agents.
Building self-improving reasoning data harnesses
How recursive harness self-improvement hardens tasks without touching model weights
Compiling GNNs into ground-truth explainer tests
Gracr replaces trained GNNs with compiled logic to make explainer benchmarks actually sound.
NeutronGym and physics-graded agent loops
How NeutronGym turns neutron instrument design into an executable, physics-grounded gym for LLM agents.
Source learning and persistent source models
Turning repeated source access into reusable, source-specific competence for LLM agents
Mimir’s two-timescale control for physical agents
How Mimir wraps an LLM in physics, simulators, and slow self-repair for season-long irrigation control.
Building agents for HumanoidToolBench
What HumanoidToolBench actually measures and how to architect agents that don’t just pick the right tool but finish the job.
Argo-Bench and the real work of data agents
Inside a 7.5B-row simulated ERP that finally tests agents on end-to-end enterprise workflows.
Meta-reasoning as a control plane for agents
A controller–worker harness that “thinks about the run” lets long-horizon agents spend compute where it matters.
Learning from agent failures with the Agent Error Dataset
How a 50k error–diagnosis corpus turns broken rollouts into a training signal.
EviRover and agentic visual perception
Turning visual perception from a one-shot guess into an interactive, evidence-gathering process.
Inside GenCine’s 3D-Controlled Video Pipeline
How Generative Cinematographer turns a single image into an editable 3D scene for jointly authoring camera and object motion.
Inside Faynt: multi-character Melee at 5ms per move
How Faynt reaches state-of-the-art multi-character Melee play with small Transformers, clever post-training, and tight evaluation.
Closing cross‑lingual loopholes in LLM unlearning
A new 174‑language benchmark and the COVER method show how to budget your unlearning effort across languages instead of blindly retraining everything.
Inside Cogentic’s multi-agent proof engine
How Cogentic orchestrates prover swarms, adversarial verification, and a persistent ledger to push on open math problems.
Loop Scaling Laws for Looped MoE in Practice
How looped transformers and sparse MoE jointly scale, and what their new scaling law implies for model design.
Read-only LoRA skills with READ composition
How READ composes many LoRA skills into one model by letting new adapters “read but never write”.
GEODE: Reusable physics ops without breaking interfaces
A routed wavelet library plus tiny per-task adapters gives multi-physics coverage while protecting earlier results.
Routing-Gated Visual Grounding in MoE VLMs
Using expert routing signals to catch hallucinated objects before your VLM answers.
Latent Flow Reasoning: Diffusion as a Solver
Latent Flow Reasoning Models use continuous diffusion in latent space to generate full reasoning traces instead of token-by-token decoding.
Harness learning: adapting the agent, not the weights
A proposer model learns to rewrite an agent’s harness using execution feedback, enabling test-time adaptation without touching the base model.
Verifiable rewards for controllable image generation
How VVR turns synthetic scenes into programmatically checkable rewards that transfer to natural prompts.
ClearGS: Making Gaussian Splatting Survive Messy Video
How ClearGS re-weights views and repairs frames to make 3D Gaussian Splatting robust to handheld video artefacts.
Action-guided KV eviction for agentic LLM stacks
How ActKV squeezes KV memory in agent loops without killing action quality
NNV3: What Builders Need From Neural Net Verification
How NNV3 extends set-based verification to new model classes, inputs, and fairness constraints.
Computation Over Geometry in RAG Systems
New results suggest semantic “sameness” is computed jointly, not stored in off‑the‑shelf embedding spaces.
Inside Underwater C3-JEPA for ROV salvage
An object-centric cross-view world model for underwater manipulation and how to actually use it in agents.
Growing reusable harnesses for LLM agents
How failure‑guided harness growth turns repeated agent control into shared executable code.
How HySparse2 shrinks agent KV and prefill
MiMo-V3’s HySparse2 shows how to redesign attention around agent workloads with KV sharing and token-level sparsity.
Building Agents with the GameHorizon Suite
How GameHorizon’s multi-horizon gameplay data and evals change how you train and debug agentic systems.
KernelOPT’s agentic loop for GPU kernel search
A multi-agent LLM system optimizes Triton kernels while preserving compiler structure and end-to-end correctness.
EnigmaForge and the missing question in evals
A new benchmark hides the task inside a story, exposing how brittle our current evaluation and agent designs are.
Inside WorldCrafter’s 3D-Aware Video Memory
How WorldCrafter uses camera-queryable implicit memory to keep long video rollouts consistent across time and viewpoints.
From toy math to open problems in 3 years
Frontier models are now closing real open problems in math, history, and biology; here’s the orchestration pattern builders can actually copy.
Wiring hyperbolix into a JAX agent stack
How to think about manifolds, layers, and optimizers when you adopt hyperbolic deep learning via hyperbolix in JAX.
Inside DexTacWAM’s visuo-tactile world model
How DexTacWAM fuses fingertip touch with video diffusion to control a 22-DoF bimanual manipulator.
A2M and the real risk of MCP tool hijacking
A2M shows how attacker-controlled MCP tools can quietly hijack agents and drive up costs; here’s how to think about the control flow and where to put defenses.
MedRSI: letting medical agents upgrade themselves
How MedRSI turns diagnostic failures into new tools while keeping clinical safety in the loop.
Reading MiMo’s RL run as a systems engineer
What Xiaomi’s MiMo-V2.6 livestream suggests about scaling RL for agentic systems.