Daily AI Digest — 2026-09-09
arXiv Highlights
Eliciting Weak-to-Strong Generalization with On-Policy Reverse Distillation
Problem
Weak-to-strong (W2S) generalization asks whether a stronger student can exceed a weaker teacher used as its supervisor. This matters practically: as base models grow, redoing frontier post-training from scratch for each new generation, or consolidating specialist teachers across domains, is expensive. Standard distillation treats teacher outputs as the fitting target, which imposes the teacher’s capacity ceiling. RLVR (RL with verifiable rewards) avoids this ceiling but is sample-inefficient. The question is how to use a weak teacher’s post-training signal to accelerate verifier-driven RL on the student without inheriting its cap.
Method
On-Policy Reverse Distillation (OPRD) keeps the standard RLVR loop for the student but rescales the token-level policy gradient using the teacher’s policy shift evaluated on student rollouts. Let \pi_\theta be the student, sampling y \sim \pi_\theta(\cdot\mid x) at prefixes s_t=(x, y_{<t}). With advantage A_t and logits \mathbf{z}_t, the RLVR token gradient is
\mathbf{g}_t := A_t \nabla_{\mathbf{z}_t}\log \pi_\theta(y_t\mid s_t).
The teacher enters through its logit shift relative to its own reference (pre-RL) policy, evaluated at the student’s prefix:
\bm{\Delta}_t := \mathcal{C}\!\left(\mathbf{z}_T(s_t) - \mathbf{z}_T^{\mathrm{ref}}(s_t)\right),
where \mathcal{C} is mean-centering. \bm{\Delta}_t is the direction in logit space that the teacher’s post-training moved along. OPRD amplifies the component of \mathbf{g}_t aligned with \bm{\Delta}_t — i.e., updates that both the verifier supports and the teacher already learned to favor get boosted; components orthogonal to \bm{\Delta}_t are untouched.
Two properties follow:
- Because the rescaling multiplies only advantage-weighted terms, stationary points of the RLVR objective are preserved — verifier-zero directions stay zero, so the student’s asymptote is set by the verifier and the student’s policy class, not by the teacher.
- Everything is on-policy: the teacher is queried only on student-generated prefixes, avoiding the train–inference mismatch of SFT on teacher trajectories.
The teacher is fixed after being post-trained with GRPO; the student runs GRPO-style RLVR with the OPRD-rescaled gradient.
Results
The experiments use Qwen3 4B and 8B (base and instruct) with DAPO-Math-17K for math and four Reasoning Gym tasks (Knights & Knaves, Quantum Lock, String Manipulation, Countdown). Teachers are GRPO-post-trained and frozen. The main 4B-base → 8B-base comparison averaged over AIME’24, K&K, and String Manipulation:
- Teacher (4B post-GRPO): 44.00
- Initial 8B-base student: 13.21
- Student + GRPO (no teacher): 45.44
- OPD (standard on-policy distillation): 45.67
- W2SR-P (SFT on verified teacher trajectories): 48.64
- S2L-PO (mixed off-policy explorer rollouts): 54.21
- OPSD (teacher trajectories as privileged context): 21.69
- Direct-OPD: 37.81
- W2S-OPD: 49.22
- OPRD: 60.81
OPRD beats the strongest baseline (S2L-PO) by 6.60 points on average and wins every individual task in this slice. Notably, straight GRPO (45.44) already matches or exceeds most distillation baselines that consume off-policy teacher data — consistent with the Gudibande et al. observation that imitating teacher outputs does not transfer underlying capabilities. OPRD’s advantage over pure GRPO (+15.4 points) comes from using the teacher purely as a direction, not a target.
The ablation over teacher-checkpoint quality (GRPO steps 15/60/105/150) shows the student’s OPRD curve rises with teacher strength but the student eventually exceeds even the strongest teacher checkpoint, empirically corroborating the stationary-point argument: teacher quality controls acceleration, not the ceiling.
A response-style analysis in the paper’s Section 4 shows OPRD students end up stylistically closer to pure-RLVR models than to their teachers, suggesting the teacher shift acts as a curriculum signal rather than an imitation target.
Limitations and open questions
- All experiments are within the Qwen3 family; the reference-policy alignment \mathbf{z}_T^{\mathrm{ref}}(s_t) presupposes a shared or comparable tokenizer/embedding geometry between teacher and student. Cross-family transfer (e.g., Llama teacher → Qwen student) is untested and non-trivial because \bm{\Delta}_t would live in a different logit space.
- The mechanism requires access to both the teacher and its pre-RL reference; this is easy for in-house successive generations but blocks use of API-only teachers.
- Only verifiable-reward domains (math, symbolic reasoning) are evaluated. Whether the “amplify the aligned verifier direction” recipe survives noisy or learned reward models is open.
- The paper does not, in the excerpts, quantify wall-clock or FLOP overhead from the extra teacher and reference forward passes per token, which is meaningful at 8B scale.
- Multi-teacher consolidation results are claimed but not detailed in the sections provided; how \bm{\Delta}_t’s from conflicting specialists should be combined (sum, project, gate) is a design question.
Why this matters
OPRD reframes weak-teacher supervision as a gradient preconditioner rather than a distillation target: the teacher’s post-training vector in logit space accelerates the student’s own verifier-driven RL without capping it. This is a clean way to amortize post-training across model generations and domains — exactly the regime where redoing RLVR from scratch is becoming the dominant cost.
Source: https://arxiv.org/abs/2609.08798
DriveZero: End-to-End Driving Beyond Human Demonstrations
Problem
End-to-end driving policies trained by imitation learning inherit the behavioral coverage of their demonstration logs. Rare corner cases, recovery from off-distribution states, and behaviors not present in expert trajectories are all systematically underlearned. DriveZero attempts to break this ceiling by decoupling the two problems that imitation conflates: perceiving the world (a representation problem, best solved with large-scale visual pretraining) and acting in it (an interaction problem, best solved with closed-loop RL). Each is pretrained under its own regime and then reunified into a camera-only planner via distillation.
DriveRL: privileged closed-loop RL from scratch
DriveRL trains a privileged teacher from random initialization — no imitation warm-start — using PPO on a mixed-agent simulator built from nuPlan logs. At each step t the policy consumes structured observations O_t: five frames of the ego and up to 96 traffic participants sampled at 5 Hz, plus up to 256 local vector-map tokens with attached traffic-light states. Navigation intent is expressed as two goal anchors G_t in the ego frame; at deployment the near/far anchors are placed along the current route with look-ahead distances scaling with speed, and recomputed every step. The same permutation-invariant two-point representation is used at train and test.
Actions are continuous: longitudinal jerk \in [-8, 5]\ \mathrm{m/s^3} and tire steering-angle rate \in [-0.8, 0.8]\ \mathrm{rad/s}, with acceleration capped at 4\ \mathrm{m/s^2} and steering angle at \pi/3. The policy outputs a Beta distribution over the normalized support (0,1)^2; training samples, evaluation uses the analytic mode. The architecture is compact: 256-dim tokens, 4 heads, 2 ego-to-agent and 1 ego-to-map cross-attention layers.
The mixed-agent simulator is the key infrastructure piece. Each background actor is driven by log-replay, a rule-based IDM controller, or a learned policy, and up to 196,608 worlds run in parallel across 96 GPUs. Training uses 2,048 worlds per rank, 110-step rollouts at 5 Hz over a 1:1 log-replay/IDM scene mixture, 4 PPO epochs per update with \gamma=0.99, for 2,400 updates (~21 h wall-clock). Reward combines hard events (safety violations, goal arrival) with soft driving-quality terms. Logs seed scenes and goals only; all training experience comes from on-policy interaction.
At inference, the learned critic V enables value-guided test-time action search: sample several action candidates, roll each out for a short horizon, score with the sum of short-horizon rewards plus the terminal critic value, and conditionally override the policy’s default action when a candidate materially improves the estimated return.
DriveVFM: multi-teacher visual distillation
DriveVFM consolidates four frozen foundation models — DINOv3, SigLIP2, SAM, and Depth Anything V2 — into a single image backbone via feature distillation from raw images alone. No task-specific labels are used. The point is representational: a single forward pass yielding features that capture semantic identity (SigLIP2), dense self-supervised structure (DINOv3), segmentation-quality boundaries (SAM), and metric depth (Depth Anything V2).
The visualization shows DriveVFM producing tighter separation between drivable ground and long-tail obstacles (boxed regions) than DINOv3 features alone — the multi-teacher combination retains DINOv3’s spatial coherence while adding depth/semantic discriminability useful for planning.
DriveZero: unifying via trajectory distillation
The camera-only student uses DriveVFM features and a command-conditioned Transformer planner that emits multiple 20-step trajectory proposals. The teacher rolls a 20-step reference trajectory from privileged state. Supervision is winner-takes-all (WTA): only the student proposal closest to the teacher trajectory receives the regression gradient, letting the student maintain a multimodal proposal distribution rather than collapsing to a mean. Additional signals include proposal scoring (the teacher’s critic ranks student proposals, transferring value information into a discrete scoring head) and goal-conditioned augmentation that varies the two-point goal to broaden behavioral coverage.
Results
DriveRL is evaluated in closed loop on nuPlan; DriveZero is evaluated as a camera-only planner on NAVSIMv1, NAVSIMv2, and HUGSIM under each benchmark’s standard sensor protocol. The provided sections list the evaluation matrix but do not include the numerical tables here; the training-side numbers that are stated concretely are: 922,703 nuPlan trainval scenes at 10 Hz with 41 history / 200 future frames, 5 Hz effective training rate, 196,608 parallel worlds, 96 GPUs, 21 h to convergence.
Limitations and open questions
The teacher operates on privileged structured state (perfect tracks, HD map, traffic-light phases); the student must recover comparable behavior from camera pixels alone, and the sim-to-real gap in this distillation step is the natural failure mode — WTA regression to a teacher trajectory does not correct perception errors that make the teacher’s decision infeasible. The mixed-agent simulator uses log-replay or IDM for background actors; neither reacts realistically to strongly counterfactual ego behavior, so the RL policy may exploit passive reactive traffic. Reward shaping combines hard safety events with soft quality terms, and the report does not detail how the resulting policy trades comfort against progress at the boundary. Finally, DriveVFM is evaluated only through downstream planning, so it is unclear how much of the improvement is representational versus attributable to distillation regularization.
Why this matters
If closed-loop RL can produce a driving teacher that outperforms the behavioral envelope of human logs, and that teacher can be distilled into a camera-only student via WTA trajectory supervision on frozen VFM features, then imitation of human trajectories is no longer the ceiling for end-to-end driving. The architecture — RL on privileged state, distillation to sensors — mirrors what has worked in robotics and games, and this is a serious attempt to make it work at nuPlan/NAVSIM scale.
Source: https://arxiv.org/abs/2609.06055
BeaconKV: Key-Value Cache Compression Guided by Beacon Queries for Efficient Large Reasoning Model Inference
Problem
Large Reasoning Models (LRMs) produce Chain-of-Thought traces that inflate the KV cache linearly in sequence length, quickly exceeding GPU memory for traces of tens of thousands of tokens. Existing eviction schemes (SnapKV, RPC, R-KV) estimate token importance from a window of the most recent queries Q_{\text{obs}} (typically the last 16–32 tokens), implicitly assuming recent queries are a reliable proxy for future attention. The authors show this assumption breaks in long-horizon reasoning because of what they call Thought Revisiting Tokens (TRT): decoding steps whose queries jump back to distant early context (problem statement, plan, constraints) rather than the local neighborhood.
Observation: TRT and its geometric structure
The authors classify queries as either local (attending predominantly to nearby keys) or global (attending to keys far from the current position). Figure 1(a) shows a representative head where most queries in a 1066–1092 window attend to keys within 900–1092, but tokens 1068 and 1090 redirect their attention to keys around positions 100–450. Figure 1(b) plots the distribution of attention distances — the position gap between a query and its top-K attended keys — and shows a clear bimodal separation between local (concentrated near zero) and global (broad, long-range) queries.
Crucially, TRT is not confined to a single layer or head. Figure 3 counts global-query occurrences across all layers/heads over output positions 512–639 on AIME24 sample-0 with R1-Distill-Qwen-7B, revealing global queries scattered throughout the network.
The key enabling insight is geometric: while global queries appear at unpredictable times, the queries that trigger TRT cluster into a small number of similarity groups in the pre-RoPE query space. Figure 4(a) shows cosine similarities between queries in a decoding interval, and Figure 4(b) shows a PCA projection where low-average-similarity (global) queries fall into a handful of tight clusters. This means a small set of representative “beacon” queries can approximate the full set of future global attention patterns.
Method: BeaconKV
BeaconKV is training-free. It performs periodic eviction: whenever the cache reaches a budget B_{\text{KV}}^{\max}, tokens are scored and evicted down to B_{\text{KV}}^{\min} = \tfrac{7}{8}B_{\text{KV}}^{\max}, i.e., \tfrac{1}{8}B_{\text{KV}}^{\max} worth of output tokens are dropped per compaction.
The novelty is the observation set. Standard methods form Q_{\text{obs}} from only the last \sim 32 queries; BeaconKV augments this with beacon queries: a compact set of representatives clustered from historical queries in the pre-RoPE space. Importance scores for cached KV pairs are then computed against the union Q_{\text{obs}} = Q_{\text{recent}} \cup Q_{\text{beacon}}. Because beacons summarize the geometry of past global queries, KV pairs likely to be revisited by future TRT decoding steps (e.g., tokens encoding the initial plan) receive high scores and survive eviction, even when no recent query is currently attending to them.
Concretely, the recent-query budget is fixed at 16 tokens; the beacon-query budget varies between 16 and 32 tokens. The overhead of maintaining beacons is bounded because clustering compresses the query history rather than storing it.
Results
Evaluation covers four LRMs (R1-Distill-Qwen-7B, R1-Distill-Llama-8B, Qwen3-4B, Qwen3-14B) on AIME24 (avg pass@1 over 8 runs), MATH-500, LiveCodeBench, and GPQA-Diamond (avg over 4 runs), with generation capped at 32,768 tokens, p=0.95, temperature 0.6. Baselines are SnapKV, RPC, and R-KV, all under the same B_{\text{KV}}^{\max} eviction schedule.
The paper reports BeaconKV “generally outperforms” the baselines across models and benchmarks (the abstract is truncated in the provided text before specific numbers). The mechanistic claim — that expanding Q_{\text{obs}} with beacons preserves reasoning-critical early tokens — is directly supported by the earlier analysis showing that recent-only observation windows systematically miss the KV positions that TRT will revisit. On the systems side, the impact statement notes reduced peak GPU memory and improved throughput, though exact ratios are not included in the provided sections.
Limitations and open questions
- The clustering of global queries is demonstrated on a specific head (layer 18, head 16) of R1-Distill-Qwen-7B; the extent to which the cluster count and stability generalize across all heads and other model families is characterized qualitatively (Figure 3) but not with cluster-quality metrics.
- Beacon selection operates in the pre-RoPE space; interaction with RoPE-based position encodings when beacons are re-used at future decoding steps is a non-trivial design choice whose sensitivity is not analyzed here.
- Evaluation is confined to open-source LRMs on reasoning benchmarks with a 32,768-token cap. Behavior on much longer traces, agentic workloads, or non-reasoning long-context generation (retrieval-augmented QA, code repositories) is untested.
- The compaction schedule (\tfrac{1}{8} evicted at each trigger) is fixed; adaptivity to reasoning phase (planning vs. execution vs. verification) is not explored.
Why this matters
BeaconKV reframes KV eviction as a query-distribution modeling problem: instead of assuming recent queries predict future attention, it estimates the geometry of future queries from clusters in past query space. This is a principled fix for a failure mode — long-range revisits to plans and constraints — that becomes dominant precisely when reasoning traces get long enough to matter for cost.
Source: https://arxiv.org/abs/2609.04971
Kalman Delta Networks: Uncertainty-aware Associative Memory
Problem
Linear-attention variants (DeltaNet, Gated DeltaNet, KDA) maintain a fixed-size recurrent memory \boldsymbol{S}_t \in \mathbb{R}^{d_k \times d_v} implementing the associative map \mathcal{M}_t(\boldsymbol{k}) = \boldsymbol{S}_t^\intercal \boldsymbol{k}. At each token the model must decide how strongly to overwrite existing key–value bindings, but it does so from the current embedding alone, without any representation of how confident the memory is about the value it already stores at nearby keys. This is the wrong inductive bias: a strong, redundant write should be discounted when the memory is already well-informed there, and a novel write should be amplified when uncertainty is high. Delta-style updates use a token-wise scalar as a surrogate, but they never track accumulated evidence.
Method
KDN reformulates the recurrent memory as a linear–Gaussian state-space model on the latent map \widetilde{\boldsymbol{S}}_t:
\widetilde{\boldsymbol{S}}_t = \boldsymbol{D}_t \widetilde{\boldsymbol{S}}_{t-1} + \boldsymbol{W}_t,\quad \boldsymbol{W}_t \sim \mathcal{N}_{\mathrm{col}}(0, \boldsymbol{\Omega}_t),\qquad \boldsymbol{v}_t = \widetilde{\boldsymbol{S}}_t^\intercal \boldsymbol{k}_t + \boldsymbol{e}_t,\ \boldsymbol{e}_t \sim \mathcal{N}(0, r_t \boldsymbol{I}_{d_v}).
DeltaNet corresponds to \boldsymbol{D}_t = \boldsymbol{I}, Gated DeltaNet to \boldsymbol{D}_t = \alpha_t \boldsymbol{I}, KDA to \boldsymbol{D}_t = \operatorname{diag}(\boldsymbol{\alpha}_t), all with no covariance tracking. The Kalman filter is optimal for this model: it propagates both the mean \widehat{\boldsymbol{S}}_t and a d_k \times d_k predictive covariance \widehat{\boldsymbol{P}}_t, then applies a residual write with gain
\boldsymbol{\kappa}_t = \frac{\widehat{\boldsymbol{P}}_t \boldsymbol{k}_t}{r_t + \boldsymbol{k}_t^\intercal \widehat{\boldsymbol{P}}_t \boldsymbol{k}_t}.
The obstacle is that the exact posterior \boldsymbol{P}_t^\star = (\widehat{\boldsymbol{P}}_t^{-1} + \boldsymbol{k}_t \boldsymbol{k}_t^\intercal / r_t)^{-1} follows a Riccati recursion that is state-dependent, dense, and incompatible with the associative-scan form \boldsymbol{S}_t = \boldsymbol{A}_t \boldsymbol{S}_{t-1} + \boldsymbol{b}_t needed for GPU-parallel training. The paper introduces two scan-compatible approximations.
Diagonal KDN. Restrict \boldsymbol{P}_t, \boldsymbol{D}_t, \boldsymbol{\Omega}_t to positive diagonals. Prediction preserves the diagonal family:
\widehat{\boldsymbol{p}}_t = \boldsymbol{\alpha}_t^2 \odot \boldsymbol{p}_{t-1} + \boldsymbol{\omega}_t,\qquad \boldsymbol{\kappa}_t = \frac{\widehat{\boldsymbol{p}}_t \odot \boldsymbol{k}_t}{r_t + \sum_i \widehat{p}_{t,i} k_{t,i}^2}.
The rank-one update destroys diagonality, so after each token the exact posterior (\boldsymbol{S}_t^\star, \boldsymbol{P}_t^\star) is projected back onto the diagonal Gaussian family by minimizing reverse KL. The projection preserves the mean and gives a closed-form Möbius map on the uncertainty, so an associative scan runs at logarithmic parallel depth with O(d_k) auxiliary state per head.
Isotropic KDN. Collapse \boldsymbol{P}_t = p_t \boldsymbol{I} so a single uncertainty scalar per head suffices; the recurrence is again a Möbius map with O(1) auxiliary state.
Both variants recover Delta-style updates as the degenerate case where predictive covariance is replaced by a token-wise isotropic surrogate and no covariance is carried forward. Crucially, the write strength on each key channel is no longer just a function of the current token: it is modulated by \widehat{\boldsymbol{p}}_t, which tracks how much evidence has previously constrained that direction of key space.
Results
Models are pretrained on FineWeb-Edu at two matched scales: 750M/50B tokens and 1.3B/100B tokens, following the GDN-2 controlled protocol with backbone, optimizer, and data held fixed across mixers. Evaluation covers perplexity (WikiText, LAMBADA), zero-shot commonsense (LAMBADA, PIQA, HellaSwag, WinoGrande, ARC-Easy, ARC-Challenge), synthetic long-context retrieval (RULER single- and multi-key NIAH), and cloze-format real-world retrieval (SWDE, SQuAD, FDA, TriviaQA, NQ, DROP) as in JRT.
The abstract reports that “KDN variants consistently improve perplexity and mean downstream accuracy over state-of-the-art linear-attention models” across both scales. The provided sections do not enumerate numeric deltas, so the specific magnitudes on WikiText/LAMBADA perplexity and the RULER/JRT retrieval gains cannot be quoted here without access to the results tables; the comparison baselines are DeltaNet, Gated DeltaNet, KDA, and GDN-2.
Limitations and open questions
The two approximations sit at opposite ends of a spectrum, and neither tracks the dense \boldsymbol{P}_t^\star that the framework identifies as optimal; the reverse-KL projection preserves the mean but discards cross-channel uncertainty structure that is exactly what carries evidence about correlated keys. The observation-noise scalar r_t and process-noise diagonal \boldsymbol{\omega}_t are learned per token, and the paper’s framing does not resolve how well these amortized noise predictions approximate a truly Bayesian treatment. Whether the gains persist at larger scales or under long-horizon training, and whether structured (e.g., low-rank plus diagonal) covariance approximations can be made scan-compatible, are natural next questions. The isotropic head loses per-channel evidence tracking entirely, so its contribution likely comes more from principled gain scheduling than from directional uncertainty.
Why this matters
Recurrent linear-attention memories have converged on ad hoc write-strength heuristics; the KDN construction shows that DeltaNet, Gated DeltaNet, and KDA are all fixed-gain degenerations of a single Kalman recursion, and that the missing ingredient — a covariance carried alongside the memory — can be reintroduced without breaking the associative-scan property that makes these models trainable at scale.
Source: https://arxiv.org/abs/2609.07816
NeoHorse-1: Towards Recursive Self-Improvement via Agentic Post-Training with Routing Harness
Problem
Recursive self-improvement (RSI) is usually discussed as an abstract loop — a system that measures its own capability and turns that measurement into training signal. NeoHorse-1 makes the loop concrete by proposing that the deployment routing harness itself is the sensor: every user turn produces (i) a predicted capability demand, (ii) a chosen service tier from a heterogeneous model pool, and (iii) the resulting interaction trajectory. Those records are converted into training examples through a structured admission pipeline, then fed back through supervised fine-tuning (SFT) and on-policy distillation curricula whose mixture is re-weighted based on evaluation feedback. The claim is that this closes an evaluation–selection–update loop at the data-mixture level, giving agentic post-training a mechanically defined analogue of self-improvement.
Data pipeline
Post-training data is organized at three granularities: the trajectory (full harness execution, including tool calls, observations, recovery attempts, terminal outcome), the user turn (from a user request up to the next user request; the basic serialized unit for SFT), and the subscene (a run of adjacent turns sharing a local goal; the semantic unit).
Within a turn record, the current request and the interleaved reasoning / tool-call / observation stream are all retained, so the reasoning–action–feedback chain is preserved for supervision. Earlier turns are kept as context but their reasoning traces are dropped — a compromise similar to the DeepSeek-R1 and Qwen recipes for multi-turn reasoning data. Each record retains links to its parent trajectory and subscene so that quality, semantic, routing, and outcome signals can be joined at the correct granularity.
Admission runs in three stages: structural validation, a six-dimensional semantic evaluation, and subscene-level labeling. Scale is 10^{5}–10^{6} harness-generated trajectories, augmented with public instruction, reasoning, tool-use, code, agent-interaction, and preference data. The training manifest records N_{\mathrm{traj}} and N_{\mathrm{tok}} after unified serialization, deduplication, and tokenizer freezing.
Agentic SFT and routing-guided distillation
Supervision follows the interleaved thinking pattern. A user turn may contain several assistant responses interspersed with tool results; the model is trained on the retained assistant target spans concatenated into a single sequence, conditioned on the visible history. Tool results and harness-injected messages never open a new turn, which keeps the loss aligned only with the policy’s own outputs.
Routing metadata (predicted capability demand and selected service tier) is not just a filter — it structures training. SFT runs as a three-stage curriculum ordered by these routing signals, and the same progression is extended to routing-guided on-policy distillation, where a teacher supervises student-generated responses within each curriculum stage. Capability-guided allocation then reads evaluation results per capability axis and reshapes the next round’s training mixture, so under-performing capabilities receive more of the next mixture. This is the mechanical form of the RSI loop the paper argues for: evaluation → capability selection → mixture update → retrain.
Results
NeoHorse-1 is released at 4B and 9B scales, evaluated on eleven benchmarks in three groups:
- Agentic (end-to-end): QwenClawBench, WorkBuddy Bench, PinchBench, VitaBench.
- Agentic (tool use / multi-turn): BFCL V4, \tau^{2}-Bench (Airline, Retail, Telecom).
- Coding: HumanEval, LiveCodeBench v6.
- Instruction following: IFEval, IFBench.
The paper reports consistent gains from agentic post-training at fixed model scale and additional improvement from 9B over 4B across the three categories. A striking qualitative demonstration comes from a 26-click Go-board replay: after identical harness-driven UI interaction, the base Qwen3.5-9B leaves the board empty, while NeoHorse-1-9B correctly renders an ongoing mid-game position with 13 black and 13 white stones. This isolates the contribution of agentic supervision to constraint tracking and execution verification rather than reasoning in isolation.
Ablations on trajectory source and supervision scale characterize how the composition and quantity of harness-generated interaction data relate to downstream performance, though exact scaling coefficients are not reported in the excerpts above.
Limitations and open questions
Several claims deserve scrutiny. First, the “recursive” loop is closed at the mixture-allocation level, not at the parameter-update level as in a true self-play or self-distillation fixed point — whether repeated iterations continue to yield gains, or saturate after one or two rounds, is not established in the excerpts. Second, the six-dimensional semantic evaluation and capability-guided allocator are themselves models; the pipeline inherits whatever biases they carry into the mixture. Third, dropping earlier-turn reasoning from context may bound the horizon over which the model can learn multi-step recovery, especially in long trajectories. Fourth, comparisons against strong agentic baselines at matched compute are not detailed in the provided sections, so relative gains against, e.g., Qwen3-tuned agent variants are not quantified here. Finally, harness-generated trajectories are on-distribution to the routing decisions the harness already makes — a distribution-shift concern if the router itself is updated.
Why this matters
If the routing harness can serve as both a deployment mechanism and a self-supervised capability probe, then post-training for agents becomes a closed-loop data problem rather than a static-corpus problem. That reframing — capability evaluation directly parameterizing the next training mixture — is a concrete, auditable version of the RSI story that has otherwise been mostly conceptual.
Source: https://arxiv.org/abs/2609.08183
AuK Technical Report: An Open-Source Foundational Model for Speech Generation and Editing
Problem
Existing open speech models specialize: zero-shot TTS, instructed TTS, denoising/separation, content editing, and paralinguistic/acoustic editing are typically distinct systems with incompatible interfaces. AuK unifies these under a single conditioning protocol — natural-language instruction plus optional audio context — and trains one model to cover all of them. The stated scope is five task families: speech generation, content editing, paralinguistic editing, acoustic editing, and enhancement/separation.
Data
The pre-training corpus is roughly 3.03 \times 10^9 instruction–audio instances totaling 1.95 \times 10^6 hours of effective supervision, organized by the five capability families above.
For zero-shot TTS the authors explicitly drop the reference-transcript requirement: for a speaker with n utterances, all \binom{n}{2} unordered pairs are enumerated and each utterance serves in turn as prompt and as target, producing n(n-1) bidirectional instances. Only the prompt waveform and target text are given; the prompt transcript is never exposed. This removes the ASR dependency at inference and lets the model clone from arbitrary crops. The corpus is cleaned with source separation, MOS filtering, speaker verification, and multi-ASR cross-validation.
Architecture
AuK has three modules:
- A multimodal LLM that consumes the instruction (and audio, when present) and produces a semantic condition. Rather than taking the last hidden state, the semantic condition is a learnable weighted sum over the LLM’s layer-wise hidden states.
- A VAE jointly trained on speech, general audio, and music, producing acoustic latents. The encoder operates on 24 kHz mono, six downsampling blocks with strides (2,2,2,3,4,5), channel widths 12{\to}24{\to}48{\to}96{\to}192{\to}384{\to}768, kernel size twice the stride, residual units with dilations (1,2,4,8,16,32), giving a total downsampling factor of 480 and a 50 Hz latent frame rate with a 64-dim posterior. A four-layer coupling normalizing flow \mathcal{F} regularizes \mathbf{z}_p = \mathcal{F}(\mathbf{z}) during VAE training only. The BigVGAN-style decoder uses transposed strides (5,4,3,2,2,2) with AMP modules and SnakeBeta activations, and is causal after a 3-frame look-ahead.
- A FLUX-style hybrid rectified-flow Transformer: M dual-stream MMDiT blocks with joint attention over semantic and acoustic tokens while keeping stream-specific residuals, followed by N single-stream DiT blocks operating on the concatenated sequence.
Two conditioning regimes are handled uniformly. With reference audio (zero-shot TTS, content editing, enhancement, separation), the same waveform is sent to the MLLM audio encoder and to the VAE encoder; the reference latents are concatenated along the sequence axis with noisy target latents. Without reference audio (instruct TTS), the acoustic stream is just the noisy target. In both cases the transformer predicts the denoised latent, which the VAE decodes.
Training and acceleration
Pre-training is staged: generation-only warm-up, then joint generation–editing. Post-training splits by task: human-feedback preference optimization for open-ended editing, and reward-based RL for speech generation.
AuK-Flash is a four-step, CFG-free student distilled from the post-trained teacher. Stage 1 is consistency initialization: for neighboring timesteps t < t', the teacher takes one CFG-guided velocity step to move \mathbf{z}_t to \mathbf{z}_{t'}, and the student is trained so its predicted endpoints \hat{\mathbf{z}}_1(\mathbf{z}_t) and \hat{\mathbf{z}}_1(\mathbf{z}_{t'}) agree, with stop-gradient on the latter. The authors report that at matched update counts, consistency initialization beats ODE regression (CausVid) and MeanFlow. Stage 2 is task-routed Decoupled DMD to preserve separation ability under distribution matching. A separate Prompt Enhancer front-end handles free-form queries: it runs ASR on any input audio, uses an LLM to identify task and arguments, quantizes continuous descriptions of rate/loudness/pitch to supported bins, and renders a canonical instruction template; canonical instructions can bypass PE.
Results
On Seed-TTS-Eval (en/zh/zh-hard/avg), AuK reaches WER 1.02/1.02/5.91/2.65 vs Qwen3-TTS 1.23/1.22/6.76/3.07 and Seed-TTS 2.25/1.12/7.59/3.65; AuK-Flash is 1.03/1.10/6.43/2.85. SIM: AuK 0.788/0.814/0.782/0.795 beats Seed-TTS 0.762/0.796/0.776/0.778. On InstructTTSEval DSD-ZH/EN, AuK is 83.37/81.60 (best on ZH); Qwen3-TTS-VD leads EN at 82.40, tied by AuK-Flash.
On MMAE-Speech, AuK gets IFR/CR/EMR 48.23/88.11/12.44 vs Step-Audio-EditX 43.52/77.27/4.69; AuK-Flash is 46.62/86.41/13.85 (best EMR). On SpeechEditBench (Content/Emotion/Prosody/Paralinguistic/Acoustic accuracy), AuK is 91.83/9.94/71.33/38.50/37.07 vs Ming-UniAudio 76.46/3.43/26.50/11.25/25.85 and Step-Audio-EditX 16.50/7.71/20.13/31.25/22.89 — a large gap on content, prosody, and acoustic editing though emotion accuracy remains low in absolute terms. On Ming-Freeform-Audio-Edit semantic editing, AuK cuts full-set WER to 3.09/3.96 (ZH/EN) from Ming-UniAudio’s 10.46/14.28, with SIM around 0.88.
For enhancement/separation: on DNS Challenge, AuK reaches dWER 2.66 with SIM 0.99 vs RE-USE 3.31/0.98; on CHiME-4, WER 7.98 vs RE-USE 10.71; on Libri2Mix, WER 9.12 with SIM 0.96, competitive with MossFormer2-SS (9.34/0.96) despite being a general-purpose model.
Limitations and open questions
Emotion editing accuracy on SpeechEditBench is only 9.94 for AuK and 6.29 for AuK-Flash — well below content and prosody, and the failure mode is not analyzed. Paralinguistic accuracy at 38.50 is similarly modest. On Libri2Mix the specialist MossFormer2-SS still edges AuK on WER (9.34 vs 9.12 is a wash, but Flash regresses to 10.07). The report does not quantify how much RLHF vs SFT contributes on each family, nor whether the transcript-free zero-shot recipe hurts short-prompt cloning relative to transcript-conditioned baselines. Compute budgets, VAE reconstruction numbers, and full ablations are deferred to the appendix.
Why this matters
A single rectified-flow backbone with MLLM semantic conditioning and a jointly trained speech/audio/music VAE now matches or beats specialist systems across TTS, editing, enhancement, and separation, with a four-step CFG-free distilled variant that mostly holds the line. If the weights are released as claimed, this collapses several previously separate open-source stacks into one.
Source: https://arxiv.org/abs/2609.08936
OpenWAM: An Open, Modular Exploration Towards Systematic World-Action Model Pretraining
Problem
World-Action Models (WAMs) attempt to reuse the visual world knowledge accumulated by large video-generative priors and re-purpose it for embodied control. The recipe is appealing: a video diffusion or autoregressive model has, in principle, learned physics, object permanence, affordances, and multi-step dynamics; if that prior can be conditioned on proprioception and decoded into actions, one obtains a controller with generalization far beyond what teleoperated demonstration budgets support.
The practical issue is that published WAM systems are monolithic. The generative backbone, the visual tokenizer or latent space, the action head, the information flow between world prediction and action prediction, the denoising/inference schedule, and the pretraining mixture are all co-designed and co-trained. Reported gains conflate many independent choices, and reproducibility across teams is poor. It is unclear which of the following actually matters: which backbone is inherited, what latent representation is used, whether world and action share parameters, whether they are denoised jointly or sequentially, and how much embodied data is needed.
OpenWAM is an attempt to convert this landscape into a controlled experimental program by factoring the design space and running matched ablations on a shared substrate.
Method
The system has two layers. OpenWAM-Infra is an engineering substrate that decomposes WAM training into composable modules with unified training, inference, deployment, and evaluation. Concretely, the factorization exposes independent slots for: (i) the generative backbone (video diffusion / masked video model / AR video model of varying scale), (ii) the visual latent space (VAE compression ratio, discrete vs continuous, token count), (iii) the action head (separate module vs shared trunk; capacity in parameters), (iv) the world-to-action information flow (cross-attention, feature concatenation, KV sharing, or none), (v) the denoising schedule (independent, sequential, or synchronized joint denoising over world tokens and action tokens), and (vi) the data curriculum (video-only pretrain, embodied-only, mixed, staged vs one-stage co-train).
Formally, a WAM defines a joint distribution over future observation latents z_{1:T} and actions a_{1:T} conditioned on history h and goal g. OpenWAM parameterizes this as a diffusion process on the concatenated variable x_t = [z_t, a_t] with a shared noise schedule, so that the training loss is
\mathcal{L} = \mathbb{E}_{t,\epsilon}\big[ \lVert \epsilon^z - \hat{\epsilon}^z_\theta(x_t, t, h, g)\rVert^2 + \lambda \lVert \epsilon^a - \hat{\epsilon}^a_\theta(x_t, t, h, g)\rVert^2 \big],
with \lambda controlling action-head weighting. Ablations replace this with (a) sequential factorization p(z_{1:T}|h,g)\,p(a_{1:T}|z_{1:T},h,g), (b) independent denoising with no cross-flow, and (c) shared-trunk vs dedicated-action-capacity variants.
OpenWAM-Study uses this substrate to pose three questions: what upstream signal transfers, how world and action learning interact, and how their synergy scales.
Findings
The paper distills three empirical principles.
What to inherit. Upstream knowledge transfers only through (a) a sufficiently capable generative backbone and (b) a compact, information-rich latent space. Small backbones or overly high-dimensional pixel-space latents both wash out the transfer: the downstream embodied task fails to benefit from more video pretraining. The finding is that latent compactness and backbone capacity trade off, and there is a regime below which upstream video pretraining is essentially wasted.
How world and action interact. Three conditions must hold simultaneously for world-action synergy to appear: dedicated action capacity (a shared trunk with a thin action head underperforms), explicit world-to-action information flow (the action head must condition on the current world-latent estimate, not just on history), and synchronized joint denoising (world and action noise levels advance together rather than action being predicted from a clean or fully-denoised world). Removing any one of these collapses the gain from world modeling to near zero.
How synergy scales. Embodied pretraining principally improves out-of-domain generalization rather than in-domain success rate. On in-distribution tasks, additional embodied data yields diminishing returns; the payoff appears when evaluating on novel scenes, objects, or instructions. Additionally, one-stage co-training of world and action objectives outperforms staged pipelines (world pretrain then action finetune), because staged training loses the world representation during action adaptation.
Limitations and open questions
The study is deliberately controlled, which bounds its external validity. The comparisons hold backbone, data, and compute matched, but the absolute scales examined are modest relative to frontier video models, and the conclusion that “sufficiently capable” backbones are required is stated qualitatively rather than as a scaling law with fitted exponents. The action spaces studied are those typical of manipulation benchmarks; whether synchronized joint denoising remains necessary for high-frequency continuous control (e.g., locomotion at 100+ Hz) is not established. The generalization claim rests on the specific OOD splits chosen and on the video pretraining corpora used; the paper does not isolate which properties of the video prior (motion diversity, scene diversity, physical plausibility) drive OOD gains. Finally, the abstract text is truncated and the full quantitative table is not reproduced here, so specific success-rate deltas across the ablation cells should be read from the paper itself.
Why this matters
WAM research has been bottlenecked by entangled design choices; OpenWAM turns it into a modular substrate where individual factors can be swapped and measured, and produces three concrete design rules (compact latent + capable backbone, dedicated action head with explicit world-to-action flow and joint denoising, one-stage co-training for OOD) that future systems can adopt or falsify.
Source: https://arxiv.org/abs/2609.07398
Hacker News Signals
AlphaGenome Atlas: a high-resolution map of human DNA
DeepMind’s AlphaGenome Atlas is a genome-scale predictive model that maps regulatory elements across the human genome at single-nucleotide resolution. The core technical contribution is a sequence-to-activity model trained on hundreds of genomic assays (ATAC-seq, ChIP-seq, RNA-seq, Hi-C, and others) simultaneously, predicting chromatin accessibility, transcription factor binding, histone modification, gene expression, and 3D contact maps from raw DNA sequence across 128 bp bins tiled over the full genome.
The architecture builds on the Enformer lineage but extends context windows substantially — handling up to 1 Mb of sequence — and incorporates cross-assay and cross-cell-type conditioning. Multi-task training across thousands of experimental tracks forces the model to learn shared regulatory grammar rather than fitting each assay independently. The output is a dense annotation: for any genomic interval you get predicted regulatory state across dozens of cell types.
The practical payoff is variant effect prediction. Given a SNP or indel, you diff the model’s output on reference vs. alternate allele and get a per-assay, per-cell-type impact score. This is more informative than existing tools like DeepSEA or Basenji because the multi-track output lets you localize whether a variant disrupts, say, H3K27ac in liver specifically vs. broadly. The Atlas release is the pre-computed version of these predictions across known human variants, browsable as a track hub.
Limitations: the model is still trained on bulk assays, so cell-type resolution is limited by training data diversity. Predicting effects of large structural variants or complex haplotypes remains outside scope. Causal interpretation of variant effects still requires experimental follow-up — the model gives correlational regulatory predictions, not mechanistic ones.
Source: https://blog.google/innovation-and-ai/models-and-research/google-deepmind/alphagenome-atlas/
C*: Unifying Programming and Verification in C (2025)
The paper proposes C*, a conservative extension of C that embeds a separation-logic-based specification language directly into the source syntax, enabling deductive verification without leaving the C toolchain or requiring a separate proof assistant frontend.
The key design choice is to treat C* annotations as first-class constructs — function pre/postconditions, loop invariants, and ghost variables — that are syntactically integrated (not just comments) and parsed by an extended compiler. The verification condition generator then extracts proof obligations in the style of Hoare/separation logic and discharges them via an SMT backend (currently Z3). Crucially, C* retains the standard C memory model rather than imposing a safer abstract model, which means the verification target actually matches what the hardware executes.
The separation logic fragment used includes standard points-to predicates and fractional permissions for reasoning about aliasing and ownership. Spatial conjunction P * Q is first-class, so you can write frame-respecting specifications for heap-manipulating code. Ghost state is erased at compile time, keeping the runtime overhead zero.
The paper demonstrates verification of several data structures (linked lists, trees, a memory allocator) and compares annotation burden against Frama-C/WP and VeriFast. C* reportedly requires fewer lines of annotation for equivalent proofs due to tighter integration with C’s syntactic idioms and automation in the VC generator.
Open questions: the SMT encoding of separation logic is known to be incomplete, so complex heap shapes may time out or require manual lemmas. Concurrency is not handled — the ownership model is sequential. Scaling to large codebases where specs must be written incrementally is unaddressed.
Source: https://arxiv.org/abs/2504.02246
Show HN: LLM Attention Visualization
This tool renders attention weight matrices from transformer language models interactively in the browser. The implementation queries a model (currently via a local or API-backed inference endpoint), extracts the full attention tensor of shape [L, H, T, T] (layers \times heads \times sequence \times sequence), and lets you navigate layer/head combinations while highlighting per-token attention distributions.
The technically interesting part is what the tool reveals about induction heads and positional attention patterns. Induction heads — the mechanism responsible for in-context copying, identified in the mechanistic interpretability literature — appear as characteristic diagonal stripes offset by the repeat distance in the attention matrix. The tool makes this visible without any special instrumentation: you just look at attention for a repeated token sequence.
The implementation runs attention extraction client-side where feasible (for smaller models via WebAssembly runtimes) or pipes through a thin server proxy for API-backed models. The visualization uses a canvas-based heatmap renderer rather than SVG to keep it performant for 128×128+ attention matrices. Color mapping is per-head-normalized to prevent dominant heads from washing out the rest.
Known limitation acknowledged by the author: raw attention weights are a poor proxy for information flow. Attention \times value norm (the “attention rollout” or gradient-weighted attention approach) is more faithful but not yet implemented. The tool is most useful for qualitative pattern spotting — detecting positional biases, identifying which heads specialize in syntactic vs. semantic relations — rather than for rigorous circuit-level analysis.
Useful for teaching and initial exploration; not a substitute for activation patching or logit attribution when doing serious interpretability work.
Source: https://ishamf.dev/p/llm-attention-visualizer/
How an AI math breakthrough ignited a controversy
The Science article covers the fallout from the FrontierMath benchmark and the AlphaProof/AlphaGeometry IMO performance claims, focusing on a concrete dispute: several mathematicians whose problems appeared in evaluation sets allege the problems were used without informed consent, and that the benchmark construction process was not sufficiently blinded from model developers.
The technical substance underneath the controversy is real and worth separating from the sociology. FrontierMath is a collection of expert-level problems across number theory, algebraic geometry, and combinatorics, designed to resist memorization by requiring novel computation or proof construction. The claim that a system solved a non-trivial fraction of these problems (exact numbers disputed) was treated as a step-change indicator.
The methodological issue is evaluation contamination. If a model’s training corpus includes mathematical literature from which problems are drawn or adapted, pass rates conflate generalization with retrieval. This is structurally similar to the data contamination problem in NLP benchmarks but harder to audit because mathematical problem similarity is not lexical — a paraphrase can have identical difficulty.
A secondary dispute concerns what “solving” means. Automated theorem provers can verify formal proofs, but the problems on FrontierMath include computational tasks where a numeric answer suffices. A system producing the correct integer output via a non-generalizable chain-of-thought is not the same as one constructing a verifiable proof object. The community is split on whether answer-correct-without-proof counts as a mathematical capability signal.
The open question this surfaces: math benchmarks need a reproducible, auditable construction protocol analogous to held-out test sets in ML, with clear provenance and adversarial problem diversity guarantees.
Source: https://www.science.org/content/article/how-ai-math-breakthrough-ignited-controversy
How GPT-o3 (referred to as GPT-5.6 Sol) helps run quantum computing experiments
OpenAI’s post describes using their frontier reasoning model as a lab assistant in a quantum computing experimental workflow at a partner institution. The technical substance is narrower than the headline implies: the model is not designing quantum algorithms or simulating circuits. Instead, it is being used for three specific tasks — writing and debugging pulse-level control code (in Python, targeting Qiskit or similar frameworks), parsing and summarizing noisy experimental output logs, and drafting parameter sweep configurations for calibration experiments.
The pulse-level code generation case is the most technically interesting. Superconducting qubit experiments require specifying microwave pulse envelopes (Gaussian, DRAG-corrected, flat-top) with precise timing and frequency parameters. This is tedious, error-prone boilerplate. The model generates syntactically correct Qiskit Pulse schedules given a natural-language description of the gate being implemented, which reduces turnaround time on experiment iteration.
The log parsing use case is straightforward: T1/T2 measurement outputs, readout fidelity matrices, and gate error budgets are extracted and summarized. This is essentially structured information extraction from semi-structured text, well within current model capability.
Limitations the post elides: the model has no physics simulator in the loop, so it cannot verify whether a generated pulse schedule will actually implement the intended unitary. All physically meaningful validation still happens on hardware or via separate simulation. The claim of acceleration is plausible but unquantified — no controlled experiment measuring experiment-cycle time with vs. without the model is presented.
Source: https://openai.com/index/codex-quantum-computing-experiments/
The VMs Powering Mobile Agents (Instinct, Claude Code)
This post is a technical survey of the sandboxed execution environments that AI coding agents run inside when operating autonomously — executing shell commands, editing files, running tests, browsing the web. The author covers three layers: the VM or container primitive, the snapshot/restore mechanism, and the network isolation policy.
The core systems problem is that agentic loops need fast, clean-slate environments that can be forked at any state. A naive approach (fresh Docker container per task) incurs 5-30 second startup latency and makes it impossible to checkpoint mid-task and resume. The production solutions use VM snapshotting — either Firecracker microVMs (used by several providers) or QEMU with memory snapshot support — to get sub-second fork times on a warm base image. This is the same primitive that underlies Fly.io’s “machines” product and Lambda cold-start optimization.
For coding agents specifically, the desirable properties are: (1) reproducible filesystem state, so the agent can retry from a checkpoint rather than from scratch; (2) network egress control, to prevent agents from exfiltrating data or making arbitrary external calls; (3) resource accounting, since an agent might accidentally fork-bomb or consume unbounded disk. The post notes that Claude Code’s local execution mode does none of this — it runs directly on the user’s machine, relying on the model’s compliance rather than OS-level isolation.
The contrast with fully sandboxed deployments like Instinct (which uses Firecracker) reveals a real security surface: the threat model for a locally-run coding agent with filesystem access and shell execution is substantially different from a cloud-sandboxed one.
Source: https://rohanadwankar.github.io/posts/platforms.html
Coop: Isolated VM Environments for Running Claude Code and Codex
Coop is a Trail of Bits open-source tool that provisions isolated Firecracker microVM environments for running AI coding agents (Claude Code, OpenAI Codex CLI) without giving them direct access to the host filesystem or network. The security motivation is explicit: these agents execute arbitrary shell commands, and running them with full host privileges is an unacceptable attack surface, especially on developer machines with credentials and sensitive repositories.
The implementation wraps Firecracker’s API to manage VM lifecycle (create, snapshot, restore, destroy), mounts a minimal Linux rootfs, and bind-mounts only the explicitly specified project directory into the guest. Network is either disabled entirely or routed through a restricted proxy that allows only specific outbound hosts (e.g., package registries). The agent process runs as an unprivileged user inside the VM.
The key usability feature is transparent workspace mirroring: the host-side project directory is synced into the VM, so the agent sees and modifies files as if running locally, but all execution is contained. On task completion or failure, you get a clean diff of what changed rather than a potentially corrupted working tree.
Firecracker’s use here is appropriate — it provides hardware-virtualization-level isolation with ~125ms boot time and ~5MB memory overhead per VM, which is practical for interactive agent sessions. The alternative (rootless containers via gVisor or bubblewrap) gives weaker isolation guarantees against kernel exploits.
Current limitations: Linux-only (Firecracker requirement), requires KVM support (no nested virtualization on most cloud VMs without passthrough), and does not yet handle GPU workloads. The snapshot/restore for mid-session checkpointing is listed as a planned feature.
Source: https://github.com/trailofbits/coop
Tao: Open math problems being non-renewably mined by AI
Terence Tao’s Mastodon post makes a pointed observation about AI evaluation on open mathematical problems. His argument is that when a specific unsolved problem is used to benchmark an AI system’s mathematical ability, the act of publicizing that result effectively retires the problem as a benchmark — either because the solution becomes training data for future models, or because the community now knows the problem is solvable by automated methods, changing its perceived difficulty and research value.
The “non-renewable resource” framing is precise. Mathematical open problems have value as benchmarks precisely because their solutions are unknown and their difficulty is calibrated by human expert judgment. Once solved (by AI or otherwise) and published, that calibration signal is consumed. Unlike held-out test sets in ML (which can be replaced by generating new data), deep open problems cannot be manufactured on demand at equivalent difficulty.
This has a concrete methodological implication for AI math evaluation: using famous open problems as one-shot capability demonstrations is scientifically weaker than it appears. A single success on a well-known problem does not establish a capability distribution. You want a large sample of problems spanning difficulty and subfield, evaluated blind, with results aggregated statistically — exactly the design FrontierMath was attempting, and exactly the design whose integrity is contested (see the Science article above).
Tao’s secondary point is about research culture: mathematicians post conjectures and partial results publicly as a collaborative norm, and that openness is now being exploited asymmetrically by AI labs doing private evaluations. This is a genuine tension between open mathematical culture and the incentive structures of AI capability research.
Noteworthy New Repositories
tigerless-labs/agent-memory
A long-term memory runtime for AI agents that treats plain Markdown files as the authoritative store. Rather than embedding everything into a vector database behind an API, agent-memory keeps memories as human-readable .md files and performs local ranked retrieval using a lightweight scoring approach — no external API key required. A notable design decision is the “sleep-time Manage layer”: an independent process that runs outside the hot path to consolidate, deduplicate, and reprioritize memory entries, analogous to offline memory consolidation rather than inline write-through caching. Both Claude Code and Codex can share a single store, which matters when agents hand off tasks or need coherent context across sessions. The plain-Markdown design means you can inspect, edit, or version-control memory directly with standard tooling — a significant operational advantage over opaque embedding stores. Retrieval appears to use keyword/semantic ranking locally, keeping latency low and avoiding vendor lock-in. Useful for anyone building multi-session agents who wants auditability and portability over raw retrieval performance.
Source: https://github.com/tigerless-labs/agent-memory
wanshuiyin/HERO-Anti-OverDefense
HERO identifies four systematic failure modes where coding agents produce worse output through excessive defensive coding: Hashing (adding unnecessary checksums or validation layers), Edge cases (handling improbable branches at the cost of readability), Rubrics (literal over-adherence to stated criteria that misses intent), and Overbuild (scaffolding beyond the specified scope). The repo provides a paste-in contract — a structured prompt/system instruction block — that constrains agent behavior along these four axes. It is framed as a behavioral specification rather than a post-processing filter, meaning it acts at generation time. The approach is model-agnostic: tested against Claude Code, Codex, Cursor, Copilot, Windsurf, and Gemini CLI. The technical substance is lightweight (it is primarily a prompt engineering artifact), but the taxonomy is useful for anyone empirically characterizing where instruction-following models systematically diverge from minimal-sufficient solutions. Worth studying alongside work on specification gaming and reward hacking in code generation.
Source: https://github.com/wanshuiyin/HERO-Anti-OverDefense
useagenthq/useagent
An open-source orchestration layer that provisions AI agents with isolated cloud compute environments and routes them through team-shared tooling and context. Each agent gets its own sandboxed “cloud computer” — persistent enough to install dependencies, run browsers, and write files — and returns completed artifacts (PRs, reports, spreadsheets, decks) rather than intermediate steps. The architecture sits above model providers: it can drive Claude Code, Codex, or OpenCode using the team’s existing subscriptions rather than proxying through its own inference. This is architecturally similar to E2B or Modal-backed agent runners but scoped toward collaborative team workflows rather than developer APIs. Key engineering questions — how sandbox lifecycles are managed, whether state persists across tasks, and how tool access is scoped per-agent — are worth examining in the source. The open-source positioning distinguishes it from commercial alternatives like Devin or Factory, giving teams auditability over what the agent actually executes.
Source: https://github.com/useagenthq/useagent
Vistyy/nopus
A deterministic prose-checking library targeting coding-agent responses specifically. Where tools like LanguageTool or Vale operate on human writing, nopus focuses on the natural-language portions of LLM output — explanations, docstrings, commit messages, inline comments — and applies rule-based checks to flag verbosity, hedge phrases, passive constructions, and filler language that reduce information density. “Deterministic” here means rule-based rather than model-based: the checks are reproducible and inspectable, which matters for CI integration or automated prompt evaluation pipelines. The practical use case is tightening agent output quality without adding another model call in the loop. At 281 stars and sparse documentation, the implementation details require reading the source, but the design direction — static analysis for LLM-generated prose — is a legitimate gap between linters for code and linters for text. Useful as a post-processing step or as a regression test baseline when tuning system prompts.
Source: https://github.com/Vistyy/nopus
SeanEllyJames/deep-research-skill
A plug-in skill file (structured prompt specification) for AI agents designed to produce analytical research outputs rather than information-retrieval summaries. The core distinction it enforces is between aggregating sources and actually reasoning about them: the skill instructs the agent to form hypotheses, identify contradictions between sources, assign confidence levels, and flag what is unknown rather than what was found. Written primarily in Chinese with English sections, it is framed as a drop-in module for agent frameworks that support skill or tool composition. The technical substance is concentrated in the prompt structure itself — how it sequences source evaluation, synthesis, and uncertainty quantification steps. At 201 stars, it is a lightweight but pointed contribution to the prompt engineering space for research agents. Relevant to anyone building agents that need to distinguish “here are facts” from “here is an analysis with justified conclusions.”
Source: https://github.com/SeanEllyJames/deep-research-skill
crmne/fastpotify
A native Spotify client written in Rust targeting Linux, macOS, and Windows. It uses the librespot library for local audio decoding and Spotify Connect protocol support, which means it can act as both a local playback device and a Connect target for remote control from phones or other clients — the full library is accessible without a premium web API key beyond standard Spotify credentials. The Rust implementation targets low resource overhead compared to the official Electron-based client, which is the primary motivation for the project. UI is built natively per-platform rather than through a web renderer. Key technical components: librespot handles audio streaming and the Connect sink; the frontend layer interacts with Spotify’s internal APIs for library metadata. Useful for Linux users who find the official client’s memory footprint or Wayland support inadequate, and for anyone wanting a hackable Spotify client without the Electron layer.
Source: https://github.com/crmne/fastpotify
elie222/rakazo
An open-source alternative to Grok’s conversational bot interface, notable for being model-agnostic and including a code execution sandbox. Rather than hardwiring a specific provider, rakazo lets operators configure the backend model — any OpenAI-compatible endpoint works. The sandbox component allows the agent to run generated code in an isolated environment and return results, which is the core capability that distinguishes conversational coding assistants from pure chat interfaces. The architecture is a Next.js frontend over a flexible model routing layer, with the sandbox likely handled via containerized execution (details are in the source). At 2,168 stars, it has traction as a self-hostable Grok Bot replacement for teams that want control over model choice, data routing, and cost. The open-source positioning is the primary differentiator: operators can audit what gets sent where, add custom tools, and avoid vendor-specific feature gating.
Source: https://github.com/elie222/rakazo
Electricitysheep/dsh-handbook
A comprehensive bilingual (Chinese + English PDF) technical handbook for DeepSeek Harness (dsh), covering installation, plugin development, performance tuning, benchmarking case studies, and multi-agent comparative evaluation with the same underlying model. The multi-agent section is particularly useful: it documents empirical results from running multiple agent instances against identical tasks with the same base model, which surfaces coordination overhead, prompt sensitivity, and output variance in a controlled setting. Performance tuning content covers inference-side configuration rather than training — batch sizing, context window management, and quantization trade-offs for self-hosted DeepSeek deployments. The plugin development documentation provides extension points for adding custom tools or retrieval integrations. At 764 stars, this is primarily a practitioner reference rather than a research artifact, but the empirical benchmarking methodology and multi-agent comparison data make it useful for anyone evaluating DeepSeek model deployments in agentic pipelines.