Daily AI Digest — 2026-08-06
arXiv Highlights
Recursive Synthesis for Long-Horizon Terminal Tasks
Terminal-agent training data is expensive because a single task couples four artifacts that must remain mutually consistent: a natural-language instruction, a sandboxed environment, a reference solution (shell trajectory), and a verifier that grades a rollout via executable checks. Human authoring costs hundreds to thousands of dollars per task; direct LLM generation tends to silently desynchronize these four artifacts (e.g., the verifier no longer probes what the instruction asks). RST (Recursive Synthetic Terminal Tasks) addresses this by treating synthesis as a verified rewrite loop over accepted tasks, producing 37,484 tasks across 15 rounds at roughly $0.05 each while pushing difficulty far past the seed distribution.
Method
RST starts from 639 verified bootstrap seeds drawn from TerminalWorld. Each synthesis round R_r applies four stages to seeds sampled from the accepted pool of R_{r-1}:
- Operator selection. A feasible rewrite operator is chosen (e.g., extend workflow, add dependent stage, tighten verification) and expected outcomes are declared conditional on the seed’s structure.
- Staged rewriting. The executable reference solution is extended first; then the verifier, public instruction, and environment are updated to remain consistent with the new trajectory. This ordering — solution first, then verifier/instruction — is what prevents the drift typical of instruction-first LLM synthesis.
- Validation. Candidates undergo static checks, anti-shortcut/leakage audits (to catch verifiers passable without doing the work), and end-to-end execution in a fresh sandbox. Recoverable failures get bounded repair; unrecoverable ones are discarded.
- Diversity-capped reseeding. Accepted tasks are subject to caps on parent lineage, category, rewrite family, and generation cohort before being admitted to the next seed pool.
Accepted tasks serve two downstream roles: as seeds for R_{r+1}, and as training tasks — for verifier-based RL directly, and (via successful rollouts) as SFT trajectories. The single-round pipeline is spelled out in Figure 3.
Scale, diversity, and difficulty
Applying the pipeline to the 639 bootstrap tasks yields 2,820 accepted tasks defining R_1; recursing through R_{15} yields 37,484 tasks total. Two questions dominate the empirical evaluation: does the pool collapse under repeated reuse, and does difficulty actually grow?
On collapse: the lineage caps preserve domain balance almost exactly. Across 19 consolidated domains, the largest domain stays below 25% of the pool from seeds through R_{15}, normalized Shannon entropy moves only from 0.821 to 0.817, and the effective number of domains goes from 11.22 to 11.09.
On difficulty: the median reference solution grows from 67 to 374 lines, and the median number of executed commands per solution grows from 40 to 244 — roughly a 6\times increase in trajectory length. DeepSeek-V4-Pro pass@4 collapses from 90% at R_1 to 2.5% at R_{15}, indicating that the recursion is producing tasks well outside the reach of a strong frontier model even with four attempts.
Contamination audit
Because the target benchmarks (Terminal-Bench 2, Terminal-Bench Hard from TMax-15K, and Long-Horizon Terminal Bench) share surface features with terminal tasks, RST reports a leakage audit comparing R_1, R_5, R_{10}, R_{15} against 89 TB2 + 100 TB-Hard + 46 LHTB tasks. Under a normalized 13-token sliding window, exact overlap is 0/89, 0/46, 0/100 for all four rounds. The maximum pairwise 5-gram Jaccard similarity stays below 0.009 (peak J_5 = 0.0081 at R_1, dropping to 0.0051 at R_{15}). Unigram Jensen–Shannon divergence to each benchmark increases monotonically with r — TB2: 0.358 → 0.433; LHTB: 0.441 → 0.485; TB Hard: 0.331 → 0.406 — i.e., recursive synthesis moves away from the benchmark distribution rather than toward it. Any downstream gains cannot be attributed to distributional convergence with the eval set.
Limitations and open questions
Several things are worth flagging. First, the difficulty proxy is DeepSeek-V4-Pro pass@4; a 2.5% pass rate at R_{15} could reflect genuinely harder workflows or pathological tasks that are technically solvable-in-sandbox but ill-posed for a model. The anti-shortcut audit and sandbox validation guard against the extremes, but medium-grade pathology (e.g., verifier over-specification) is hard to rule out from the reported statistics alone. Second, diversity is measured over 19 hand-consolidated domains, which is coarse; entropy stability at that granularity is compatible with fine-grained rewrite-family homogenization inside a domain. Third, cost ($0.05/task) excludes sandbox compute amortization and the human effort embedded in the 639 bootstrap seeds and the operator library. Finally, generalization is demonstrated only for Qwen3.5-27B/122B-A10B trained via SFT + verifier-based RL; whether recursion depth r trades off cleanly against training utility, or saturates earlier than R_{15}, is not resolved by the excerpts shown.
Why this matters
Long-horizon agent training has been bottlenecked by the four-artifact consistency problem, and RST shows that a solution-first, sandbox-validated recursive rewrite loop can push both scale (37k tasks) and difficulty (pass@4 from 90% to 2.5%) without domain collapse or benchmark contamination. If the training-utility claims hold up, this is a plausible template for producing verifiable, executable curricula for any agent domain with a deterministic sandbox and programmatic grader.
Source: https://arxiv.org/abs/2608.05466
ABSeeker: Training Long-Horizon Search Agents via Answer-Backtracked Credit Assignment
Problem
Long-horizon search agents commonly execute hundreds of tool calls per query: issuing web searches, opening pages, cross-referencing entities, and filtering candidates before committing to an answer. Training such agents with either SFT on demonstration trajectories or RL with outcome rewards uses the same signal for every step in a trajectory. The outcome reward
r_{\text{ans}}(\tau) = \begin{cases} 1 & \text{if } a = a^*\\ 0 & \text{otherwise}\end{cases}
collapses two failure modes: (i) failed trajectories that contain genuinely useful intermediate discoveries receive zero signal on those correct steps, and (ii) successful trajectories that contain redundant or misleading intermediate reasoning still positively reinforce those steps. With trajectories of up to 200 tool calls, this credit-assignment noise dominates learning.
Method: Answer-Backtracked Credit Assignment (ABC)
ABC converts the sparse binary outcome r_{\text{ans}} into a dense per-step reward r_t for every step s_t in a rolled-out trajectory \tau=(s_1,\ldots,s_T,a). Each step contains the model’s reasoning, a tool call, and the tool response.
The pipeline has two stages:
Stage 1 — Answer-Backtracked Clue Recovery. Given the query q and the verified answer a^*, an auxiliary LLM (DeepSeek-V4-Flash in the experiments) reasons backward from a^* to produce a set of intermediate evidence clues \mathcal{C}=\{c_1,\ldots,c_K\} that constitute a verified evidence chain from q to a^*. Because these clues are derived from the ground-truth answer rather than any particular rollout, they act as trajectory-independent anchors: the same \mathcal{C} scores every rollout for that question, avoiding the drift and inconsistency of per-rollout critic models.
The example in Figure 3 shows a multi-constraint query yielding six clues c_1–c_6, each corresponding to a discrete constraint that must be resolved to reach a^*.
Stage 2 — Clue-Anchored Step Scoring. For each rolled-out step s_t, the scorer LLM measures which subset of clues \mathcal{C} is advanced, verified, or contradicted by the step’s tool call and observation. This produces a fine-grained scalar r_t that is positive when a step surfaces or corroborates a previously unmet clue, zero for redundant retrieval, and negative when the step discards or contradicts an established clue. Crucially, this score is independent of whether the final a matched a^*: useful steps in failed trajectories get positive credit, and lazy or misleading steps in successful trajectories are penalized.
Stage 3 — Optimization. The dense r_t signal drives two training procedures. ABC-SFT reweights the imitation loss on collected trajectories by step-level score (so imitation focuses on high-r_t steps, including those in failed trajectories that still contained useful evidence gathering). ABC-RL then uses r_t as the per-step reward within policy optimization, starting from the ABC-SFT checkpoint.
Experimental setup
The backbone is Qwen3.5-4B. Training data is drawn from OpenSeeker, with both correct and incorrect rollouts retained (a departure from rejection-sampling SFT). SFT uses 8.5K trajectories over 3 epochs; RL uses 1000 questions with 8 rollouts each. Trajectory length is capped at 200 tool calls. Evaluation spans four suites: BrowseComp (English long-horizon browsing with multi-constraint queries), BrowseComp-ZH (Chinese counterpart), xbench (professional deep-research), and GAIA text-only. Each benchmark is run three times and averaged.
Baselines cover three tiers: frontier foundation models with search (Gemini-3.1-Pro, GPT-5 High, DeepSeek-V4-Pro-Max, GLM-5, Seed-2.0-Pro), ~30B search agents (MiroThinker-1.7-mini, RedSearcher, DeepMiner, Tongyi-DeepResearch, OpenSeeker), and 4B search agents (QUEST-4B, DR-Venus, AgentCPM-Explore).
Results
Figure 1 summarizes headline performance: ABSeeker is the strongest 4B agent across all four suites and remains competitive with agents roughly an order of magnitude larger. The striped overlays indicate configurations with context management enabled, which extends effective trajectory length beyond raw context limits — a non-trivial factor given the 200-tool-call budget.
Limitations and open questions
The clue recovery and step scoring both rely on a strong auxiliary LLM (DeepSeek-V4-Flash). Errors in clue recovery — missing a required constraint, or introducing a spurious one — will contaminate every reward signal for that question, and the paper does not quantify sensitivity to scorer quality or provide human agreement rates on clue sets. The method also assumes the query is decomposable into a discrete set of retrievable clues, which fits multi-hop and multi-constraint browsing benchmarks but is a weaker match for tasks requiring holistic synthesis or numerical reasoning where “evidence” is not cleanly enumerable. Finally, the ABC reward is computed offline on rollouts; scaling to on-policy RL where the scorer must run in the training loop imposes substantial inference cost, and the paper does not report the compute overhead relative to the base RL setup.
Why this matters
Dense per-step credit derived from the verified answer — not from a learned critic or from outcome-matching — is a practical way to rescue signal from the ~200-step trajectories that long-horizon search demands, and it lets a 4B agent match much larger systems. The technique generalizes beyond search: any task with a verifiable final answer and decomposable intermediate structure (multi-hop QA, tool-augmented math, code with unit tests) admits an analogous backtracking-based reward.
Source: https://arxiv.org/abs/2608.05102
Towards Physics of Multimodal Pretraining: Knowledge Flow, Modality Synergy, Early Unification, and Recipes
This paper conducts a controlled empirical study of unified multimodal pretraining, treating the interaction between language modeling, image understanding (image→text), and image generation (text→image) as the object of study rather than optimizing a single downstream metric. The design space for natively unified models — when to introduce vision, which parameters to share, how to mix data — has been explored mostly through ad hoc recipes with contradictory conclusions. The authors run mixture experiments across 100B–2T tokens with a fixed 1.5B Llama-3-style backbone in the Transfusion framework (discrete NTP for text, rectified-flow matching for images) and derive four findings that translate directly into recipe choices.
Setup
The backbone is 16 layers, hidden 2048, GQA (32 Q heads, 8 KV), FFN multiplier 1.5, with modality-specific split FFNs (2.3B total). Images default to RAE tokens: SigLIP-2 ViT-400m/14 producing a 16\times 16 grid of 256 semantic tokens, with generation done as flow matching in SigLIP latent space, decoded by a Representation Autoencoder. The flow model uses x-prediction with velocity conversion v = (x_0 - x_t)/(1 - t) and a 25-step Euler sampler at CFG 5.0. The flow-matching loss is up-weighted 3\times relative to text cross-entropy. Timesteps use logit-normal sampling. Three alternative visual tokenizers (raw pixels, CLIP+SD3 VAE, UniTok RQ codes with a causal depth head) are used to check generality.
Knowledge flow is asymmetric
The first block of experiments scales one modality at a time on real web data (SSTK image–text, DCLM text).
Scaling language monotonically improves both understanding and generation benchmarks; language acts as a universal booster with no observed trade-off against vision.
Scaling understanding data yields large gains on generation — consistent with understanding providing a semantic prior that generation reuses — but visibly degrades pure language metrics as capacity is diverted.
Scaling generation data, by contrast, produces only minor fluctuations in language and most understanding tasks: generation does not appreciably feed back into the other abilities.
The synthetic replication (procedurally generated concepts, per-concept eval) turns this correlational picture into causal statements: inserting/removing concepts from the understanding stream propagates into generation performance on those concepts, while the reverse does not hold. The resulting DAG is language → {understanding, generation} and understanding → generation, with generation a sink.
Synergy vs. competition
Whether unification is net positive depends on task complexity and parameter sharing. Simple tasks in one modality act as boosters across modalities; sufficiently complex tasks compete for capacity and the synergy is dominated by interference. Architecturally, the paper finds a consistent recipe: share attention and normalization, split FFNs by modality. Shared attention/QK-norm/RMSNorm parameters carry the cross-modal alignment signal, while modality-specific FFNs absorb modality-idiosyncratic feature transformations and prevent the two token streams from fighting over the same MLP capacity. The pattern holds across RAE, raw pixels, CLIP+VAE, and UniTok — i.e., it is not an artifact of a particular visual tokenizer or of continuous-vs-discrete image modeling.
Early unification
Delaying vision to a later stage of pretraining, or training language → understanding → generation sequentially, consistently underperforms joint pretraining from the start. Sequential curricula exhibit catastrophic forgetting on the earlier stage and fail to realize the language→generation and understanding→generation transfer identified in §3. This is a strong claim against the common “LLM first, add vision later” recipe: the LM prior helps most when the vision loss is present during the tokens that build that prior, not after.
Recipes at scale
The knowledge-flow asymmetry has a direct budgeting implication. Because generation is a downstream beneficiary rather than a source of transfer, the compute mix should be heavily skewed toward language and understanding; generation data is highly sample-efficient in this joint regime. Combined with early unification and shared-attention/split-FFN parameter sharing, the authors extend this to an MoE variant to further mitigate capacity competition, and report that this recipe scales cleanly to strong unified benchmarks (specific final numbers are given in §6.2 but not reproduced in the excerpts here).
Limitations and open questions
The controlled experiments are at 1.5B/2.3B parameters up to 2T tokens; whether the asymmetry weakens at 30B+ scale where models may develop enough capacity for generation-to-understanding backward transfer is untested. The Transfusion coupling (NTP + flow matching in one model) is fixed; the “generation is a sink” conclusion could be partly attributable to flow matching being a poor gradient signal for representation learning rather than an intrinsic property of image synthesis. The 3\times loss weighting is a hyperparameter that could interact with the observed asymmetries. Finally, “shared attention + split FFN” is validated as better than the endpoints tested, but finer-grained sharing (e.g., shared FFN up-proj only) is not swept.
Why this matters
The paper replaces recipe folklore with a small set of falsifiable claims about which modality helps which, and grounds them with a causal synthetic benchmark. If the language→understanding→generation DAG holds at scale, unified multimodal pretraining should look very different from current “vision-tax” recipes: front-load language and understanding compute, unify early, share attention but not FFNs, and treat generation as a nearly-free downstream capability.
Source: https://arxiv.org/abs/2608.05000
The Personalization Mirage: How LLMs Fabricate User Profiles, and Why Self-Monitoring Misleads
Persistent-memory personalization is now standard in deployed LLM assistants: the model accrues facts about a user across sessions and conditions its responses on that store. The unexamined question is whether the model’s internal user representation actually corresponds to what the user revealed, or whether it silently drifts into invention. This paper isolates that failure mode — over-inference (OI), the assertion of user attributes not licensed by evidence — and shows it is universal across current frontier models, while the obvious mitigation (self-audit) is worse than useless at the model-selection level.
Problem setup
Formally, a user reveals a set of facts E = \{e_1, \ldots, e_k\} and the model responds with claims C = \{c_1, \ldots, c_n\} about the user. Faithfulness is defined relative to E, not to world truth — this is not classical hallucination but per-user unwarranted inference. The authors fix k=3, deliberately targeting the sparse-evidence regime where personalization is tempting but unjustified.
Each claim is placed into one of four mutually exclusive categories: Grounded (restates E), Reasonable (one common-sense step from E), Stereotype (substitutes demographic/occupational priors), and Fabricated (no evidential basis).
The over-inference rate is
\mathrm{OI\ Rate}(M) = \frac{\#\textsc{Stereotype} + \#\textsc{Fabricated}}{\#\textsc{Total Claims}}.
The Reasonable/Stereotype boundary is the operationally hardest one, so classification is delegated to a fixed independent Judge (Claude-Opus-4-7) rather than the model under test. The judge is validated against a blind human annotator on 400 claims: Cohen’s \kappa = 0.863 four-class, \kappa = 0.900 binary.
MirageBench
MirageBench pairs 150 personas with 6 personalization tasks spanning an “imagination gradient” (900 instances per model), and runs three instruments — Probe (explicit belief elicitation), Task (implicit inference in normal use), and Accum (longitudinal accumulation) — feeding all outputs to the Judge.
Personas are ground-truth 15-attribute profiles P paired with |E|=3 first-person facts. With 12 attributes systematically unmentioned, any personalization must extrapolate. Personas are stratified into 50 stereotypical / 50 counter-stereotypical / 50 neutral, cleanly separating OI-as-population-prior from OI-as-blank-filling. Total: 143,616 judged claims across 12 models from 7 families.
Over-inference is universal
Every one of the 12 models over-infers between 35% and 49% of its claims. Cross-model mean OI is 41.6%; the claim-weighted micro-average over 143,616 claims is 41.8%. Qwen3-8B tops the leaderboard at 48.7% OI; the best-behaved, Gemini-3.1-pro, still sits at 35.1%. Only 24%–31% of personalized content is grounded in E: from the user’s perspective, roughly three-quarters of what the assistant “knows” about them was never actually communicated.
Two structural findings sharpen this. First, fabrication dominates stereotyping: mean 31.1% fabricated vs. 10.5% stereotype. Models are not primarily leaning on demographic priors — they are inventing. Second, stratification by persona type produces a persistent gap: 44.8% OI on stereotypical personas vs. 37.0% on counter-stereotypical (a 7.8 pp gap, present in all 12 models individually, with per-model gaps of +4.0 to +10.5 pp). Counter-stereotypical personas function as a real stress test rather than a matched control, and models measurably do better when the “obvious” prior is aligned with the truth.
The Self-Monitoring Inversion
The natural defense is to have the model audit its own claims before writing them to memory. Let \mathrm{Gap}(M) = \mathrm{OI}_{\textsc{Judge}}(M) - \mathrm{OI}_{\text{self}}(M). Positive gap: the model under-detects its own over-inference. Negative gap: it over-reports.
The distribution across models is bimodal: Qwen3-8B under-reports by +35.7 pp (self-audit says 13.0% OI, judge says 48.7%), GPT-4o-mini by +25.0 pp, while at the other end Kimi-K2.5 over-reports by -15.1 pp (self 58.2%, judge 43.1%) and GPT-5.4-nano by -11.4 pp. Only three models (DeepSeek-v4-pro, Gemini-3-flash, Qwen3.6-plus) are within \pm 1 pp of calibrated.
The critical result is at the model-selection level: Spearman \rho = -0.60 between self-assessed and judge-measured OI (p = 0.044 by permutation, n=12; bootstrap 95% CI [-0.90, +0.06], family-clustered [-0.87, +0.14]). Ranking models by their own self-reported honesty inverts, in expectation, the ranking by external OI. Models that most confidently report low over-inference are, on average, worse offenders. The CI crosses zero, so this is exploratory rather than definitive, but the qualitative message — self-audit is not a substitute for external evaluation — is clean.
Limitations and open questions
The evaluation is fixed at k=3; scaling behavior as evidence density increases is not characterized here, and it is plausible OI decays non-trivially with |E|. The Judge is a single frontier model; despite high \kappa with a human on 400 claims, judge-induced systematic bias on 143k claims cannot be ruled out. The Reasonable/Stereotype boundary is the paper’s own noted weak point. And with n=12, the Self-Monitoring Inversion has a wide CI — the sign, not the magnitude, is what should be trusted. The paper does not propose a mitigation; it only shows self-audit fails as one.
Why this matters
Persistent-memory personalization products are being shipped on the assumption that the user model reflects the user. This work shows that assumption is false at scale (41.8% of claims unsupported) and that the ergonomically obvious safeguard — asking the model to check itself — inverts the ranking you would use to pick a safer model. External, held-constant adjudication is not optional for this failure mode.
Source: https://arxiv.org/abs/2608.04570
Toward Skill-Native LLMs: Skill Entropy for Benchmarking and Training Long-Horizon Reasoning
Long-horizon reasoning traces in current LLMs frequently interleave heterogeneous skills — deriving a closed-form expression, then using that result to plan a schedule, then formatting the output as JSON. Existing benchmarks largely evaluate each skill in isolation and thus cannot separate a model’s per-skill competence from its ability to switch between skills mid-chain. This paper proposes a scalar, model-invariant measure of switching difficulty (skill entropy), a benchmark (Skill²-Bench) built around it, and an RL recipe (Skill-Entropy RL) that turns the same quantity into a reward.
Skill entropy
Skill entropy is a directional pairwise quantity on skills s_a, s_b \in \mathcal{S}. Under a fixed reference model, let \text{Accuracy}(s) be accuracy on multi-step questions restricted to skill s and \text{Accuracy}(s_a, s_b) the average per-step accuracy on two-step tasks that first invoke s_a then s_b. With Laplace smoothing \alpha = 0.1,
\text{SkE}(s_a, s_b) = \frac{\tfrac{1}{2}\bigl(\text{Accuracy}(s_a) + \text{Accuracy}(s_b)\bigr) + \alpha}{\text{Accuracy}(s_a, s_b) + \alpha}.
\text{SkE} > 1 means chaining costs accuracy relative to the per-skill baselines; \text{SkE} \leq 1 means the switch is essentially free. Ordering matters: \text{SkE}(s_a, s_b) \neq \text{SkE}(s_b, s_a) in general, because the two two-step compositions are different tasks. Because SkE is defined under a fixed reference model, it functions as a shared difficulty axis for all evaluated systems.
The task-level extension aggregates pairwise SkE along a task’s skill sequence and is quantile-binned into three difficulty levels used to stratify Skill²-Bench.
Skill²-Bench
The benchmark spans 558 labeled skills across 9 domains: math, science, coding, logic, information extraction, planning (verifiable, using seeds like OpenR1-Math, MMLU-Pro, LiveCodeBench, ZebraLogicBench, WikiTable/WebSRC, NaturalPlan) plus creative writing, context retrieval, and instruction following (open-ended, LLM-judged with rubrics).
Cross-domain switching is markedly non-uniform. The pairwise SkE heatmap shows that switching into certain domains (e.g., planning, creative writing) from math-like sources is systematically harder than the reverse, and per-domain accuracy is strongly anti-correlated with per-domain skill entropy.
Evaluating 8 frontier and 4 open-source models, the authors observe a monotone drop in accuracy as task-level skill entropy increases — a “skill-switching gap” that is larger for smaller open-source models.
Skill-Entropy RL
The second contribution converts skill entropy into a training signal. A cross-skill task \tau = ((q_1,a_1),\dots,(q_L,a_L)) is answered in a structured format that interleaves explicit skill declarations with per-step answers:
<think> ... </think>
<skill> Domain_i, Skill_i </skill><answer> Step_i Answer </answer>The response parses into a predicted skill plan \hat\mu(\tau) = (\hat s_1,\dots,\hat s_L) and an answer sequence. GRPO is run with a composite per-task reward:
r = \lambda_{\text{ans}} r_{\text{ans}} + \lambda_{\text{ent}} r_{\text{ent}}, \qquad r_{\text{ent}} = 1 - |\hat\rho - \rho^\star|,
where r_{\text{ans}} is mean per-step accuracy under the per-domain scorers, and \hat\rho, \rho^\star \in [0,1] are the empirical ranks of the predicted and gold task-level skill entropies on the training distribution. To compute \hat\rho, each predicted skill string is first mapped to its nearest entry in the 558-skill bank by embedding similarity, so the reward tolerates semantic paraphrases of the gold skill. Intuitively, r_{\text{ent}} pushes the model to plan a skill sequence whose difficulty profile matches the gold plan, not merely to guess labels.
Results
On Skill²-Bench with Qwen3-4B-Instruct, the base model averages 34.4. SFT reaches 55.8, vanilla GRPO 58.8, and prior post-training methods (Skill-Distill 58.1, SkillRL 59.3, STAT 61.4) all cluster in the high-50s to low-60s. Skill-Entropy RL reaches 68.4, a +7.0 improvement over the strongest baseline. Gains are broad: math 44.7→49.3, coding 42.8→47.8, science 54.6→71.1, logic 41.4→47.1, creative writing 68.8→85.6. The picture on Qwen3-1.7B is similar but sharper: 14.6 (base) → 40.1 (Skill-Entropy RL), versus 33.0 for the best baseline (STAT). Notably, on the small model math jumps from 14.3 (GRPO) to 27.4, suggesting the skill-plan reward provides useful structure precisely where the base policy is weakest.
Qualitatively, the case study in Figure 3 shows the failure mode Skill-Entropy RL corrects: base Qwen3-4B, having produced a numeric math result in step 1, tends to repeat a math-style skill and short numeric answer in step 2 even when the second question requires “Theme Creation” and a prose answer. After training the model switches both the declared skill and the answer modality.
Limitations and open questions
SkE is defined relative to a fixed reference model; whether the induced difficulty ranking is stable as reference models improve is untested. The reward r_{\text{ent}} depends on an embedding-based match to a fixed 558-skill bank, so skills outside the bank are silently projected onto their nearest neighbor; this may under-penalize creative but off-manifold plans. Skill entropy is defined pairwise and aggregated to task level heuristically — higher-order interactions across three or more skills (e.g., non-Markovian dependency structures) are not modeled. Finally, per-step scoring on open-ended domains still relies on LLM judges, which the pairwise SkE definition inherits.
Why this matters
Skill entropy is a simple, model-relative quantity that makes the previously implicit cost of skill switching directly measurable and directly optimizable. That the same scalar works as both an evaluation axis exposing a switching gap and an RL reward that closes ~7 points of it on Skill²-Bench suggests skill-composition structure — not just per-skill capability — is a first-class training target for long-horizon reasoning.
Source: https://arxiv.org/abs/2608.05139
When Teachers Mislead: Spurious-Signal-Aware On-Policy Distillation
On-policy distillation (OPD) has become the workhorse for compressing large instruction/reasoning models: the student samples trajectories y \sim \pi_\theta(\cdot\mid x), and the teacher \pi_T supplies a dense token-level KL signal on the student’s own prefixes. Recent “selective” OPD variants prune this signal by confidence, informativeness, or learnability. This paper argues that all such selectors miss a structural failure: the teacher’s high-divergence tokens can be driven by input-agnostic language priors — formatting habits, stereotyped reasoning templates, entity-name defaults — rather than by evidence in x. Such tokens produce large gradients that push the student toward the teacher’s idiolect without improving task competence.
Formalizing spurious signals
Let A_t = \log \pi_\theta(y_t \mid x, y_{<t}) - \log \pi_T(y_t \mid x, y_{<t}) be the sampled teacher–student log-ratio on the student-visited prefix. Under a stop-gradient treatment of A_t, the OPD update is g_t^{\rm OPD} = -A_t \nabla_\theta \log \pi_\theta(y_t \mid x, y_{<t}). The paper decomposes A_t = A_t^{\rm grd} + A_t^{\rm prior}, where A_t^{\rm grd} varies with x and A_t^{\rm prior} is predictable from the prefix y_{<t} alone. Linearity of the gradient yields g_t^{\rm OPD} = g_t^{\rm grd} + g_t^{\rm prior}. Selective OPD methods that rank by |A_t| or by teacher entropy cannot distinguish these two components — precisely the tokens with large A_t^{\rm prior} tend to be confident and high-divergence, so they get upweighted.
Figure 1 makes the failure concrete in a VLM setting: for many tokens along a student rollout, the teacher–student divergence is essentially invariant to whether the image and question are present. Those tokens’ supervision therefore cannot depend on the input; it is A_t^{\rm prior} masquerading as signal.
SA-OPD: an input-groundedness proxy
SA-OPD instantiates the decomposition with a cheap ablation: for each rollout, recompute teacher and student log-probs on a residual no-prompt context (the same y_{<t} without x). The change in divergence, \Delta_t = A_t - A_t^{\rm no\text{-}prompt}, serves as a proxy for A_t^{\rm grd}; |\Delta_t| small means the token’s supervision is prior-dominated. SA-OPD filters tokens satisfying two conditions simultaneously: (i) low input-groundedness (|\Delta_t| below a threshold) and (ii) high optimization impact (|A_t| in the upper tail). Tokens that are weakly grounded but low-impact are harmless and retained; tokens that are strongly grounded, even with extreme divergence, are kept because they carry genuine task signal.
The mechanical cost is one extra teacher and one extra student forward pass per rollout on a shortened context, which is amortizable against sampling cost. The filter is applied to the reverse-KL loss in Eq. (1) as a per-token mask; no reweighting or auxiliary loss is introduced, which keeps the interaction with existing OPD infrastructure minimal.
Experimental setup and dynamics
Experiments use Qwen3 and Qwen3.5 non-thinking variants, with teacher/student pairs Qwen3-4B-Instruct → Qwen3-1.7B and Qwen3.5-35B-A3B → Qwen3.5-2B as the primary settings, plus DeepSeek-R1-0528-Qwen3-8B → Qwen3-1.7B and Qwen3.5-9B → Qwen3.5-2B for generalization. Text-only OPD uses ~7K DeepMath examples filtered to difficulty ≥6; VLM OPD uses 10% samples from VERO-600K (captioning/IF, grounding, counting/search) and MMRL30k for visual reasoning.
Figure 3 shows the qualitative pattern the method targets: vanilla OPD’s validation curves flatten or regress in later training as prior-driven gradients accumulate, while SA-OPD’s curves continue to rise. This is consistent with the mechanistic claim — removing g_t^{\rm prior} prevents the student from drifting toward the teacher’s input-agnostic style once the easy, well-grounded signal is exhausted.
Limitations and open questions
The no-prompt ablation is a first-order proxy for A_t^{\rm grd}: it assumes the prefix y_{<t} itself does not encode the input’s content. For long chains of thought where earlier reasoning restates the problem, A_t^{\rm no\text{-}prompt} will still be input-informed, biasing the filter toward under-filtering. The dual-threshold rule (low |\Delta_t| and high |A_t|) introduces two hyperparameters that likely need per-task tuning; the paper’s ablations on thresholds and on the interaction with token-count budgets would determine how brittle this is. Finally, the decomposition A_t = A_t^{\rm grd} + A_t^{\rm prior} is conceptual — there is no guarantee that the ablation cleanly recovers either component under non-linear log-softmax normalization.
Why this matters
Selective OPD has focused on which confident tokens to keep; SA-OPD reframes the question as which confident tokens are actually about the input. If the input-groundedness proxy generalizes, it provides a principled counterweight to the tendency of KD to transfer stylistic priors along with capability, which is a recurring failure mode in small-model distillation for reasoning and multimodal tasks.
Source: https://arxiv.org/abs/2608.03632
Distill Where You Fail: Recovering Learning Signals of Negative RL-Groups from Adaptive Teacher Guidance
Problem
GRPO estimates advantages within a group of G rollouts per prompt as A_i = (r_i - \mu_G)/\sigma_G. When all rollouts share the same reward — in RLVR settings this typically means all fail (r_j = 0, \forall j \in G) — the advantage collapses to zero and the prompt contributes no gradient. These “negative zero-variance” groups are precisely the hard prompts where the model most needs to learn. On-policy distillation (OPD) from a stronger teacher provides dense token-level supervision and is a natural complement, but naive GRPO+OPD hybrids underperform pure GRPO: the training curves in Figure 1 show GRPO+OPD flatlining below GRPO on MATH.
The authors diagnose three failure modes: (i) most prompts do not need distillation and mixing OPD indiscriminately dilutes RL exploration; (ii) fitting the teacher too aggressively collapses the policy’s exploratory distribution; (iii) OPD’s per-token advantage is asymmetric — it suppresses the majority of tokens because \log \pi_T - \log \pi_S is negative on most positions.
Method: RSTG
RSTG (Recovering Learning Signals via Adaptive Teacher Guidance) routes distillation only through the channels where GRPO is blind. The dispatch is prompt-conditioned: standard GRPO runs on prompts with reward variance; a separate RSTG branch fires on negative zero-variance prompts.
Sample-level selection and teacher weighting. From a 57k dataset \mathcal{D}, they define \mathcal{D}_{\text{sw}} (9k) as prompts with student mean@8 = 0, and \mathcal{D}_{\text{swtr}} (2k) as the subset where teacher mean@8 = 1. Running OPD on each partition (Figure 3) yields the ablation that motivates the design: OPD on \mathcal{D}_{\text{swtr}} — 3.63% of \mathcal{D} — outperforms OPD on the full corpus. This is operationalized in the online setting by identifying negative zero-variance GRPO groups and weighting them by the teacher’s empirical success rate \omega_i \in [0,1] (teacher mean@8) as a soft proxy for teacher proficiency:
A_{i,t}^{\text{Hybrid}} = \begin{cases} \beta \cdot \omega_i \cdot A_{i,t}^{\text{OPD}}, & \text{if } r_j = 0, \forall j \in G \\ A_{i,t}^{\text{GRPO}}, & \text{otherwise} \end{cases}
Token-level filtering. Rather than propagate OPD advantages through every token, gradients are restricted to tokens satisfying either high student entropy H(\pi_S) (uncertain decisions where teacher signal is most informative) or large teacher-student divergence (positions where the policy disagrees with the teacher). This addresses the suppression asymmetry: without filtering, most tokens receive negative OPD advantage and the policy contracts toward the teacher indiscriminately.
Auxiliary SFT. For negative zero-variance prompts, teacher-generated reference completions are added as SFT targets, giving the student at least one correct trajectory to imitate directly.
Results
On three student→teacher pairs across MATH (AIME24/25, MATH500, OLMPIAD) and CODE (APPS, MBPP+):
- Qwen3-1.7B ← Qwen3-4B-Instruct-2507: RSTG reaches 55.39 MATH avg and 67.11 CODE avg, versus GRPO at 51.57/60.03, GRPO+OPD at 51.37/64.55, and ReLIFT at 52.52/60.58. AIME24 climbs from 34.79 (GRPO) to 42.98.
- Qwen3-4B ← Qwen3-4B-Instruct-2507: 66.89 MATH / 82.05 CODE, versus GRPO 64.94/71.56 and ReLIFT 65.05/80.77. AIME25 improves 45.00 → 47.92.
- Qwen2.5-3B ← Qwen2.5-14B: 28.66 MATH / 63.52 CODE, versus GRPO 27.41/51.91.
Notably, naive GRPO+OPD sometimes regresses relative to GRPO (Pair ❷: 63.37 vs. 64.94 on MATH), consistent with the training-dynamics failure in Figure 1. RSTG dominates across all three pairs on aggregate averages.
Limitations and open questions
The method requires per-prompt teacher mean@8 estimates to compute \omega_i, which is expensive to maintain online and appears here to be precomputed on a fixed 57k pool; how this scales to open-ended or non-verifiable domains is unclear. The token-filter thresholds (entropy quantile, divergence cutoff) and \beta are hyperparameters whose sensitivity is not fully characterized in the shown sections. The evaluation is confined to math and code, where teacher verification is cheap; extension to reasoning tasks without deterministic verifiers is open. Finally, the gains on Qwen2.5-3B on AIME are modest in absolute terms (8.33 / 5.42), suggesting distillation cannot substitute for missing base capability when the student is far below the teacher.
Why this matters
RSTG offers a clean prescription for the recurring problem of zero-gradient groups in GRPO: instead of augmenting every prompt with imitation loss, distill exactly and only where RL is silent and the teacher is competent. The framing — treating OPD as gradient recovery for negative zero-variance groups rather than a parallel objective — is a useful mental model for other hybrid RL+SFT recipes.
Source: https://arxiv.org/abs/2608.00782
Hacker News Signals
Branchless Rust: Making a Filter 4x Faster by Removing an If
Source: https://www.greyblake.com/blog/branchless-rust/
The post walks through a concrete micro-optimization: replacing a conditional branch inside a hot filter loop with arithmetic that the CPU can execute without speculative execution stalls. The motivating example is filtering a slice of integers — the naive version uses an if to decide whether to push an element, which introduces a branch the CPU must predict. On random or adversarial data, misprediction penalties dominate.
The branchless rewrite exploits the fact that a boolean in Rust coerces to 0u8 or 1u8. The core trick is computing a mask from the predicate and using it to conditionally write without branching:
// Branchless: always write, advance pointer conditionally
*out_ptr = val;
out_ptr = out_ptr.add(predicate as usize);This converts control-flow dependency into a data dependency, which modern out-of-order CPUs handle with far less penalty. The post benchmarks with criterion, showing roughly 4x throughput improvement on random data where branch prediction accuracy is ~50%. The gain shrinks when data is sorted or otherwise predictable because the branch predictor succeeds most of the time.
Several implementation details matter: the write must occur regardless of the predicate (so the output buffer must be pre-allocated to worst-case size), and the approach requires unsafe Rust to manipulate raw pointers directly. The post discusses a safe abstraction using MaybeUninit to avoid initializing the buffer.
The broader lesson is about CPU pipeline architecture: a branch mispredict on modern x86 costs roughly 15-20 cycles, while a data-dependent pointer increment costs one cycle. The 4x speedup is consistent with ~50% mispredict rate on random data and a moderate loop body cost. LLVM will sometimes auto-vectorize or auto-branchless-ify simple cases, but the compiler cannot always prove the transformation is valid, particularly across trait boundaries. This technique is well-known in SIMD/HPC circles but underused in systems Rust.
Why Erdős Problems Are Falling to AI
Source: https://www.quantamagazine.org/why-the-legendary-erdos-problems-are-falling-to-ai-20260803/
The article surveys recent results where AI-assisted or AI-driven methods have cracked combinatorics problems from Erdős’s open problem catalog — notably extremal graph theory and additive combinatorics questions that resisted human attack for decades. The technical substance centers on two modes of AI involvement.
First, LLM-guided conjecture refinement: systems like AlphaProof and related tools iteratively propose candidate constructions or bounds, verify them with a formal checker or explicit computation, and use the verification signal to guide search. This is closer to Monte Carlo tree search over mathematical objects than “reasoning” in the colloquial sense.
Second, and more technically interesting, is the use of large-scale SAT/SMT solvers and integer programming formulations that were previously intractable but become feasible when an LLM proposes a compact representation or symmetry-breaking constraint. The LLM effectively acts as a heuristic preprocessor that reduces the search space before handing off to exact solvers.
The specific Erdős problems mentioned include bounds on cap sets, Ramsey multiplicity, and arithmetic progressions in dense sets. For cap sets, improved upper bounds on r_3(n) (the maximum size of a subset of \mathbb{Z}_3^n with no 3-term AP) were tightened using tensor-method constructions partially discovered by automated search.
The article is careful to note that no current system produces formal proofs autonomously — human mathematicians verify and formalize the outputs. The open question is whether the “easy” Erdős problems (those reducible to finite search or algebraic manipulation) are cherry-picked, and whether the harder problems requiring genuinely novel proof techniques remain out of reach. The article does not overstate what has been demonstrated, which makes it worth reading.
Zapscape (CVE-2026-64561): Guest-to-Host Escape in KVM/x86
Source: https://github.com/V4bel/Zapscape
Zapscape is a published exploit for a guest-to-host VM escape in KVM on x86. The CVE is assigned to 2026, marking it as a recently disclosed vulnerability. The repository contains proof-of-concept code and a writeup describing the root cause.
The vulnerability is in KVM’s handling of the x86 APIC virtualization path, specifically in how KVM/x86 processes certain APIC write exits when hardware APIC virtualization (APICv) is enabled. The bug is a use-after-free or incorrect state transition — the precise class is a race condition in the vCPU APIC state machine where an interrupt injection path can be triggered after a partial teardown of the virtual APIC structure, leaving a stale pointer that the hypervisor dereferences with attacker-controlled data.
The exploit chain requires: (1) triggering the race from inside the guest using precise timing of APIC writes and VM exits, (2) heap shaping the host kernel to place attacker-controlled data at the freed address, and (3) achieving arbitrary write or code execution in the host kernel context. Step (1) is the novel contribution — the PoC uses a guest-side busy-loop synchronized against a shared memory page to hit the race window reliably.
The practical impact is significant: any tenant on a shared KVM-based cloud infrastructure running an affected kernel could potentially escape their VM. The affected kernel versions and patch status are documented in the repository. The fix involves adding proper locking around the APIC teardown path and auditing adjacent state transitions.
This class of bug — races in hypervisor interrupt virtualization code — is notoriously hard to find with static analysis because the window depends on hardware-accelerated VM exit timing that is difficult to model symbolically.
Qwen3.8-Max: A New Bar for Coding and Cowork
Source: https://qwen.ai/blog?id=qwen3.8
Qwen3.8-Max is Alibaba’s latest release in the Qwen3 series, positioned as their strongest coding and agentic collaboration model. The blog describes an architecture that extends the Qwen3 MoE design — sparse mixture-of-experts with a large total parameter count but a smaller activated footprint per token — with training modifications focused on instruction following, multi-turn tool use, and code generation.
The “cowork” framing refers to multi-agent task decomposition: the model is trained to act both as an orchestrator (decomposing tasks and issuing subtasks to specialist agents) and as a subagent (receiving structured tool calls and returning structured outputs). This requires training on synthetic multi-agent trajectories with explicit role markers, a technique now standard across frontier labs.
On coding benchmarks, Qwen3.8-Max reports state-of-the-art or near-SOTA scores on HumanEval, MBPP, LiveCodeBench, and SWE-bench Verified. The SWE-bench Verified number is the one worth tracking — the blog claims above 70% resolution rate, which if reproducible would represent a significant jump. The model is accessible via API; weights availability is not confirmed in the blog post as of writing.
The MoE architecture means inference cost per token is lower than a dense model of equivalent benchmark performance, which matters for deployment. The HN discussion is predictably skeptical about benchmark overfitting, and several commenters note that LiveCodeBench has a data cutoff problem — models trained more recently inherently see more of the evaluation distribution. The “Max” suffix follows Qwen’s naming convention distinguishing their largest API-only models from smaller open-weight releases.
Mistral’s Shieldstral: 3B Open-Weights Model for Multimodal Moderation
Source: https://mistral.ai/news/shieldstral/
Shieldstral is a 3B-parameter open-weights model from Mistral designed as a content moderation classifier for both text and image inputs. The core contribution is combining a small, deployable parameter count with multimodal capability — most prior open moderation models are either text-only or much larger.
The model is fine-tuned from a Mistral base using a combination of human-labeled moderation datasets and synthetic data generated by larger models then filtered. The classification taxonomy covers standard harm categories (CSAM, violence, hate speech, self-harm, illegal activity) plus agentic-specific categories relevant to tool-calling contexts (prompt injection, jailbreak attempts, unauthorized data exfiltration patterns).
The multimodal path handles images via a vision encoder consistent with Mistral’s existing VLM work. For moderation specifically, the image encoder is trained to be sensitive to visual harm signals (explicit content, violence) that require different features than general visual understanding — the fine-tuning process uses contrastive objectives on pairs of benign and policy-violating images with similar semantic content.
At 3B parameters, Shieldstral can run on a single consumer GPU and is fast enough for inline request filtering (latency competitive with a network round-trip). Mistral reports precision/recall numbers on their internal eval set and on publicly available moderation benchmarks including ToxicChat and OpenAI’s moderation eval. The open-weights release is notable because most production-grade multimodal moderation systems are proprietary API endpoints.
The main limitation is that 3B parameters constrains nuanced judgment on borderline content — the model trades recall for precision on ambiguous cases. The open-weights nature also means adversaries can probe it systematically for evasion.
DeepSeek V4 Flash on a Single AMD MI300X
Source: https://github.com/ryanzhou/deepseek-v4-flash-mi300x
This repository documents running DeepSeek V4 Flash — a distilled, quantized derivative of DeepSeek V3/R1 lineage — on a single AMD MI300X GPU (192 GB HBM3). The engineering interest is that DeepSeek’s full MoE models require multi-node clusters, but the Flash variant is small enough to fit in one GPU’s memory with appropriate quantization.
The setup uses ROCm with custom attention kernels ported from the CUDA FlashAttention-2 implementation. The MI300X’s HBM3 bandwidth (~5.3 TB/s) makes it well-suited for memory-bandwidth-bound inference of large quantized models. The repository includes configuration for 4-bit and 8-bit GPTQ quantization of the expert weights, keeping active parameters per token in a range that sustains reasonable MFU.
Key technical details: the MoE routing in DeepSeek V4 uses a top-K expert selection per token with auxiliary load-balancing loss during training. At inference on a single GPU, all expert weights must fit in device memory simultaneously — this is the binding constraint the quantization addresses. With INT4 expert weights and FP16 attention, the full model fits within ~160 GB, leaving headroom for the KV cache.
Throughput numbers quoted are in the range of 15-30 tokens/second for batch size 1, which is usable for interactive inference. The repository also notes that ROCm’s performance on attention kernels still lags CUDA equivalents by 10-20% for this workload, with specific profiling traces included. The value here is the reproducible single-node recipe — most DeepSeek deployment documentation assumes NVIDIA multi-GPU setups.
Muse Code and Muse Spark 1.2
Source: https://research.meta.ai/blog/introducing-muse-code-and-muse-spark-1-2
Meta AI Research released Muse Code and an update to Muse Spark (1.2), both positioned within their multimodal generative framework. Muse Spark 1.2 extends the earlier image/video generation model with improved temporal consistency for video and better prompt adherence for multi-object scenes. The architecture remains a masked generative transformer (MaskGIT-style) operating on discrete token sequences from a VQVAE codebook, with the 1.2 update focusing on the token prediction head and training data curation rather than architectural changes.
Muse Code is the more novel release: a code generation model that operates not on raw text tokens but on structured program representations. The model uses a tree-sitter parse of the input codebase to condition generation, allowing it to reason over the AST rather than raw character sequences. This is architecturally similar to prior work on code infilling with structural priors, but applied at the file and repository scale.
The training objective combines standard next-token prediction with a structural consistency loss that penalizes generated code whose AST deviates from predicted structural patterns (e.g., generating a function body that violates the signature inferred from context). This requires differentiating through the parser, which is handled by a learned surrogate that approximates parse tree structure.
Benchmark results on HumanEval, SWE-bench, and an internal repository-level completion eval show improvements over prior Muse versions. The HN discussion raises questions about the gap between HumanEval (isolated functions) and real repository-level tasks — a fair concern given that the structural conditioning is most valuable in the latter setting. Weights and inference code are not publicly released; the blog is a research announcement.
“Clean” Code, Horrible Performance (2023)
Source: https://www.computerenhance.com/p/clean-code-horrible-performance
Casey Muratori’s essay (from 2023, recirculating) benchmarks several canonical “clean code” refactoring patterns and quantifies their runtime cost. The core argument is empirical rather than philosophical: specific OOP idioms promoted in clean code pedagogy — virtual dispatch hierarchies, excessive abstraction layers, small methods — introduce measurable overhead that compounds in hot paths.
The benchmark compares a “clean” shape-rendering implementation using polymorphism and virtual method dispatch against a switch-statement version operating on a tagged union. The virtual dispatch version is roughly 5-10x slower depending on the workload, primarily because virtual calls inhibit inlining and introduce indirect branches that defeat the CPU’s branch target predictor. With random dispatch sequences (the worst case), the misprediction rate on the indirect branch approaches 100%.
The data layout argument is equally important: the “clean” version stores shape objects as separately allocated heap objects with vtable pointers, fragmenting what could be contiguous arrays. This destroys cache locality — a tight loop over a heterogeneous vector<Shape*> triggers a pointer chase with near-random access pattern, versus iterating a struct-of-arrays layout.
Muratori’s prescription is not “never abstract” but “be aware of what the CPU actually executes.” The SIMD-friendly rewrite using flat arrays of tagged structs processes the same workload in roughly 1/10 the time with explicit vectorization. The essay’s value is in the concrete assembly output and profiler traces shown, not the argument itself — which is well-known in performance engineering but apparently needs periodic restatement. The HN comment threads reliably argue about whether the examples are representative of real codebases, which is the interesting question the essay does not fully address.
Noteworthy New Repositories
Kritt-ai/open-kritt
An agentic security analysis framework that orchestrates AI agents to find real, exploitable vulnerabilities in codebases rather than surface-level lint warnings. The system decomposes vulnerability discovery into specialized sub-agents handling reconnaissance, taint analysis, data-flow tracing, and exploit hypothesis generation, then coordinates their outputs to produce actionable findings with reproduction steps. The architecture targets the gap between static analysis tools (which suffer high false-positive rates) and manual penetration testing (which does not scale). Under the hood it builds a code property graph and feeds context-windowed slices to each agent, keeping individual prompts within manageable token budgets while maintaining global state. Output is structured as a vulnerability report with CWE classification, affected code paths, and suggested patches. The project is early-stage but already supports multiple languages and integrates with common CI pipelines. Primary users would be security engineers wanting to automate the first-pass triage of a large codebase, or red teams augmenting manual review. The all-agent design means findings quality scales with model capability, making it straightforward to swap in newer frontier models as they appear.
Source: https://github.com/Kritt-ai/open-kritt
vshulcz/deja-vu
Addresses the cold-start problem in coding agent sessions: agents repeatedly solve the same sub-problems because they have no persistent memory across sessions. deja-vu indexes session histories already written to disk by seventeen common agent harnesses (Cursor, Aider, Claude Code, etc.) including retroactively, with no requirement to have been installed when those sessions ran. At session start it retrieves relevant past solutions automatically. The retrieval mechanism is purely lexical and structural — no embeddings, no LLM calls — which keeps the entire system dependency-free and fully local. The benchmark result is 84.9% hit@1 on LongMemEval-S, competitive with embedding-based approaches at a fraction of the operational cost. The index is built from raw session files using a single zero-dependency binary, making deployment trivial: copy the binary, run it, done. For teams running agents in air-gapped or privacy-sensitive environments where calling an embedding API is not acceptable, this is the only practical option in this space currently. The retrieval algorithm appears to use n-gram and token-overlap heuristics with lightweight structural parsing of the session format; the no-LLM constraint forces the implementation to be robust to messy, unstructured agent output.
Source: https://github.com/vshulcz/deja-vu
MemTensor/memmy-agent
A shared memory substrate for multiple concurrent AI coding agents. The core problem: Claude Code, Codex, and similar tools each maintain isolated context windows, so running several agents on the same codebase produces inconsistent, redundant, or conflicting state. memmy-agent acts as a local memory hub that all agents read from and write to via a unified interface, giving every agent the same persistent representation of the user, the project state, and prior decisions. The architecture separates episodic memory (session transcripts), semantic memory (extracted facts and preferences), and working memory (current task state), and handles merge conflicts when multiple agents update simultaneously. Everything runs locally, so no user context leaves the machine. The implementation targets the MCP (Model Context Protocol) standard where supported, with fallback adapters for agents that lack native MCP support. This is relevant for anyone running multi-agent workflows where coherence across agents matters — e.g., one agent writing tests while another refactors implementation. The main open question is conflict resolution policy when two agents form contradictory beliefs about project state; the current approach is last-write-wins with a diff log.
Source: https://github.com/MemTensor/memmy-agent
aws-samples/sample-specship
A structured autonomous engineering workflow packaged as a Kiro Power (AWS’s agent extension format). The pipeline enforces a five-phase sequence: recon (parse requirements and existing codebase), plan (produce a task decomposition with explicit contracts), build (generate implementation), validate (adversarial self-critique and test execution), and ship (final quality gating before output). The TDD integration means the build phase generates tests before implementation and iterates until they pass. The adversarial validation step runs a separate critic agent over the output specifically looking for slop patterns: hallucinated API calls, copy-pasted boilerplate that doesn’t fit the context, spec drift. Quality gates are defined as structured predicates checked programmatically, not subjectively by the model itself, which is the meaningful design choice here — it limits the degree to which a model can convince itself that bad output is acceptable. The spec-driven framing means the entire workflow is anchored to a formal requirements document, reducing the tendency of long-horizon agents to drift from original intent. Useful as a reference architecture for teams building internal agent pipelines who want principled structure rather than a single-prompt approach.
Source: https://github.com/aws-samples/sample-specship
arcships/aimux
A unified LLM access layer written in Rust that exposes a single API surface across 325 AI providers. The value proposition is operational: production systems that call multiple providers for cost routing, fallback, or capability selection currently require per-provider SDK integrations with incompatible request/response schemas. aimux normalizes these into one interface and handles the translation layer internally. Being written in Rust means it can embed directly into systems that need low-latency routing without a sidecar process, and the memory safety guarantees matter when handling API keys and response streaming at scale. The abstraction covers provider-specific features like tool calling, streaming, vision inputs, and structured output formats, mapping them onto a unified schema with graceful degradation when a target provider lacks a capability. For teams building LLM-agnostic infrastructure — routing traffic based on latency, cost, or model-specific strengths — this eliminates significant integration surface area. The 325-provider coverage is the headline number; more important in practice is whether the normalization layer handles edge cases in streaming and error codes consistently, which requires inspecting the implementation against specific providers of interest.
Source: https://github.com/arcships/aimux
arcships/light-ocr
Offline OCR for Node.js and C++ built on PP-OCRv6 (PaddleOCR’s latest generation detection and recognition pipeline) with hardware-accelerated backends: Core ML on Apple Silicon and WebGPU for cross-platform GPU inference. The output includes bounding box coordinates, recognized text, and per-region confidence scores, making it suitable as a component in document processing pipelines rather than just a black-box text extractor. Running fully offline is the primary differentiator from cloud OCR APIs: no per-call cost, no data egress, deterministic latency. The Node.js packaging as @arcships/light-ocr means it integrates directly into JS/TS server-side tooling without a Python subprocess bridge, which matters for teams with Node-only infrastructure. The Core ML backend is architecturally interesting — PP-OCRv6 is a two-stage pipeline (text detection via DBNet-style segmentation, then recognition via CRNN), and mapping that onto Core ML’s graph format requires splitting the pipeline at the stage boundary. WebGPU support extends hardware acceleration to Linux and Windows GPU targets. Useful for document ingestion, screenshot parsing, and any pipeline that processes images in a privacy-sensitive or latency-constrained environment.
Source: https://github.com/arcships/light-ocr
hahhforest/pi-textbook
A Chinese-language hands-on textbook — “Hands-on Learning Pi” — that walks readers through building a Pi-style agent (reasoning-and-acting loop in the style of DeepSeek-R1 / similar) from scratch along 15 discrete checkpoints. Each checkpoint corresponds to a concrete, runnable state of the system, so readers can verify their understanding against a working artifact at each stage rather than only at the end. The curriculum covers the full stack: tokenization, pretraining objectives, RLHF/RLAIF fine-tuning for reasoning, tool use integration, and the agent loop itself. The Pi-style framing specifically targets the interleaving of chain-of-thought reasoning with action execution, which is mechanically different from vanilla instruction-following and requires explicit treatment of how reasoning tokens are generated and masked during training. For Chinese-speaking ML practitioners who find English-primary resources like Karpathy’s nanoGPT or Hugging Face course insufficient for the agent-specific material, this fills a real gap. The checkpoint structure also makes it usable as a course scaffold. The 743-star count in a short window suggests genuine demand for this type of structured, buildable curriculum in this language.
Source: https://github.com/hahhforest/pi-textbook
haoran-zha/Awesome-Spiking-Neural-Networks-Hub
A curated, bilingual (English and Mandarin) reference hub for spiking neural networks covering 340+ papers organized by topic, alongside links to neuromorphic hardware platforms (Intel Loihi, BrainScaleS, SpiNNaker), datasets, simulation frameworks (NEST, Brian2, SpikingJelly), and active research groups. The bilingual organization is the distinguishing feature relative to existing SNN awesome-lists: it makes the resource accessible to the substantial Chinese-language neuromorphic research community while remaining usable for English-primary readers, and cross-references work from both communities that often does not surface in the other’s literature searches. Coverage spans the main technical axes of SNN research: surrogate gradient training methods (STBP and variants), rate vs. temporal coding, conversion from ANN, hardware-aware network design, and applications in low-power inference. For someone entering the field or surveying it for a specific application area like event-camera processing or edge inference, this is a useful structured starting point. The hardware section is particularly valuable since neuromorphic platform documentation is scattered and the hub aggregates deployment-relevant constraints alongside the algorithmic literature.
Source: https://github.com/haoran-zha/Awesome-Spiking-Neural-Networks-Hub