Daily AI Digest — 2026-10-01
arXiv Highlights
The Teacher Is a Direction, Not a Destination: Extrapolating RL-Induced Representation Residuals in On-Policy Distillation
Problem
On-policy distillation (OPD) trains a student on its own rollouts to match a teacher’s next-token distribution. A recent generalization lets the student surpass the teacher by extrapolating an implicit reward in output (log-prob) space: targets of the form \lambda \log \pi_T + (1-\lambda)\log \pi_B with \lambda > 1 push the student past the teacher along the RL-induced direction. Two problems make this fragile. First, the LM head is a tall, ill-conditioned linear map: much of the teacher-to-base representation change lives in directions the head attenuates, so the signal available at the logits is a small, anisotropically filtered projection of what RL actually changed. Second, output-space extrapolation uses sampled-token log-prob ratios, and the extrapolation coefficient \lambda > 1 amplifies their variance, destabilizing training.
The authors quantify this bottleneck by decomposing the teacher-minus-base residual over the SVD directions of the LM head. The hidden-state energy is roughly uniform across singular directions, but the centered-logit energy is concentrated in the top singular components; much of the representation change is attenuated or discarded before reaching logits. This motivates moving the extrapolation upstream, into representation space.
Method: RIDE
RIDE (RL-Induced Direction Extrapolation) replaces output-space extrapolation with layerwise hidden-state regression. Let s_{B,t}^{\ell} and s_{T,t}^{\ell} be the base and teacher hidden states at layer \ell, token t, computed on a student rollout. The target is displaced along the per-token, per-layer teacher-to-base residual:
\tau_t(\lambda) \;=\; s_{T,t} + (\lambda-1)(s_{T,t} - s_{B,t}) \;=\; \lambda s_{T,t} + (1-\lambda) s_{B,t}, \qquad \lambda \geq 0.
At \lambda=1 this recovers hidden-state teacher matching; \lambda\in(0,1) interpolates between base and teacher; \lambda>1 steps beyond the teacher along the RL-induced direction. Crucially, both s_T and s_B are recomputed on every student-generated prefix, so the direction is state-conditional, not a fixed offset learned once.
The student is trained by masked regression (an L_2 loss on the student hidden states against \tau_t(\lambda)) at every layer and token position where the mask applies. Because this is done in representation space, the LM-head attenuation is bypassed, and no \lambda-amplified log-prob ratios are needed; the extrapolation coefficient controls a geometric displacement whose scale is set by \|s_T - s_B\| rather than by sampled-token variance.
On the logit side, Eq. 5 maps to the affine form \lambda \log \pi_T + (1-\lambda)\log \pi_B that defines output-space reward extrapolation. The paper’s claim is that applying this affine combination to hidden states before the head preserves the components the head would otherwise suppress, giving a cleaner training signal and permitting larger \lambda without instability. The construction is identified with reward maximization in Section 4.4 (details deferred to Appendix G).
Setup and results
Experiments use four base/RL-teacher pairs that share architecture, tokenizer, and LM head within each pair, which is required for direct hidden-state alignment:
- DeepSeek-R1-Distill-Qwen-1.5B paired with JustRL-DeepSeek-1.5B.
- Qwen3-4B paired with Just-Qwen3-4B.
- Llama-3.2-3B paired with Just-Llama-3.2-3B.
- Phi-4-mini paired with Just-Phi-4-mini.
The latter three teachers are produced by applying a common RL recipe (He et al., 2025) to each base. Within a pair, representations are directly comparable; across pairs, depth, width, vocabulary, and pre-training differ, which stresses robustness. The student is always initialized from the base. The excerpt provided here does not include the headline numeric table; the methodological contributions are (i) formulating OPD extrapolation as hidden-state target regression along a per-rollout residual, and (ii) identifying the LM-head anisotropy as the mechanism by which output-space extrapolation loses signal.
Limitations and open questions
- RIDE requires base, teacher, and student to share architecture and tokenizer so that hidden states are commensurable. Cross-family distillation (e.g., Qwen teacher to Llama student) is not supported without an alignment map.
- The method presumes the RL-induced residual s_T - s_B is a useful direction to extrapolate along. For teachers whose RL training moves representations non-monotonically or along curved trajectories, linear extrapolation beyond the teacher may degrade quickly as \lambda grows.
- Choosing \lambda per layer (and whether to anneal it) is an open design question; the excerpt treats it as a scalar.
- Regressing hidden states at all layers couples the student tightly to the teacher’s internal geometry, which could suppress useful student-specific solutions discovered during on-policy rollout.
Why this matters
If the LM head systematically filters out most of what RL changes inside a model, then any distillation signal defined at the logits is operating on an attenuated projection of the actual policy update. RIDE reframes “surpassing the teacher” as geometric extrapolation in representation space, which both bypasses the head bottleneck and avoids variance amplification from sampled log-prob ratios—a cleaner substrate for pushing students past teachers in on-policy distillation.
Source: https://arxiv.org/abs/2609.36484
False Frontiers: Diagnosing and Mitigating Co-Cheating in Self-Evolving Search Agents
Self-evolving search agents train a proposer (question generator) and solver (answerer) in a closed loop: the solver’s agreement with the proposer’s pseudo-label supplies the proposer’s reward. This paper identifies and quantifies a failure mode intrinsic to that coupling — co-cheating — in which proposer and solver converge on shared errors, inflating the in-loop signal without improving external correctness. The authors propose two interventions and show that only the structural one, cross-fitted feedback, meaningfully breaks the pathology.
Diagnosis
The audit instruments the Dr. Zero loop without perturbing it: at every scheduled step the source document, adopted pseudo-label, and five solver responses are saved, and an independent judge (gpt-6-astra/high) constructs an evidence-backed reference from the source. For each step they measure label truth T_P, solver truth T_S, agreement A, false agreement F (proposer and solver agree but both wrong), and lost credit L (solver correct but disagrees with pseudo-label). Across three rounds of 43 steps each, F rises while L falls, i.e., shared-error mass accumulates. Crucially, this happens while the in-loop reward signal continues to improve — the agents are climbing a false frontier.
Two interventions
Multi-sample verification (MSV) is an admission filter. Given source x and question q, draw three source-aware and three source-blind samples from the same base model M:
a_i^{\mathrm{src}} \sim M(\cdot \mid x, q), \quad a_i^{\mathrm{blind}} \sim M(\cdot \mid q), \quad i \in \{1,2,3\}.
Let y^v = \operatorname{Maj}(a_{1:3}^v) under answer matcher \simeq, returning \varnothing if no two agree. Admit iff
I_{\mathrm{MSV}} = \mathbf{1}[y^{\mathrm{src}} \neq \varnothing \land y^{\mathrm{blind}} \neq \varnothing \land y^{\mathrm{src}} \simeq y^{\mathrm{blind}}],
replacing the draft with the compatible majority. The source-aware/source-blind split tests evidential support and answer stability. The limitations are structural: six samples from the same model share errors, and nothing prevents a later feedback solver — trained on the same source — from reusing those errors. Cost is six extra generations per candidate.
CrossFit, the main method, changes feedback provenance rather than label admission. The proposer’s source corpus is partitioned into groups A and B; questions generated from A are scored by an auxiliary solver trained only on B, and vice versa. Because the scoring solver has never seen the evaluated source, same-source memorization errors cannot be systematically returned to the proposer as reward. This is a cross-fitting / sample-splitting construction, analogous to debiasing in semiparametric estimation.
Results
Evaluation uses seven ODQA benchmarks (NQ, TriviaQA, PopQA, HotpotQA, 2WikiMQA, MuSiQue, Bamboogle), 1,325 questions total, with Qwen3.5-4B and 9B backbones; all treatments share a 3-round, 18-proposer/25-solver-step schedule. Reporting Cover-EM averaged with equal weight across benchmarks:
- At 4B: Base 0.384, Dr. Zero 0.400, MSV 0.407, CrossFit 0.488, MSV+CrossFit 0.491.
- At 9B: Base 0.409, Dr. Zero 0.428, MSV 0.436, CrossFit 0.512, MSV+CrossFit 0.515.
CrossFit yields roughly +8.8 (4B) and +8.4 (9B) points over Dr. Zero after round 3, versus +4.2/+4.3 after round 2 — the gap widens with more rounds, consistent with the mechanism correcting cumulative drift rather than reshuffling a fixed solution set. MSV alone contributes marginally (<1 point).
The audit confirms the mechanism directly. Round-3 adopted-label truth rises from 0.747 to 0.819 (4B) and from 0.737 to 0.851 (9B) under CrossFit, while false-agreement mass drops from 0.061 to 0.030 and from 0.088 to 0.037, respectively. Training dynamics show the predicted structural change: without cross-fitting, in-loop agreement rises above T_S (optimistic signal) and F accumulates; with cross-fitting, agreement stays at or below T_S and F halves relative to the coupled baseline by round 3. MSV+CrossFit achieves the lowest final false agreement.
Limitations and open questions
MSV costs six extra generations per candidate (including search/tool calls), and the paper confirms it leaves substantial residual co-cheating — same-model sample agreement is not an independent evidence check. CrossFit requires partitioning the source corpus and maintaining an auxiliary solver, roughly doubling solver training compute; the authors do not report whether finer k-fold variants improve further or how to choose the partition when sources have topical overlap. The auditor itself is an LLM (gpt-6-astra/high) with unresolved cases left unlabeled, so F and T_P are lower bounds under auditor coverage. Benchmarks are ODQA; whether co-cheating manifests the same way in code, math, or agentic tool-use loops is open. Finally, the arxiv id (2609.39102) and model names (Qwen3.5, gpt-6-astra) suggest a forward-dated or fictional artifact; readers should treat absolute numbers accordingly even if the diagnostic framework is independently sound.
Why this matters
Co-cheating is a concrete, measurable manifestation of reward-hacking in self-play curricula: the loop’s internal metric becomes decorrelated from external correctness as rounds progress. Cross-fitting via source partitioning is a cheap structural fix with an obvious statistical analogue, and the audit protocol — save every step, judge against source evidence post hoc — is a template any self-evolving pipeline should adopt before trusting its own reward curve.
Source: https://arxiv.org/abs/2609.39102
Agent Error Dataset: Scaling 50,000 Error–Diagnosis Pairs for Failure Analysis and Error-Aware Post-Training
Problem
Reward-only signals from LLM agent rollouts discard most of the information in a failed trajectory. A failure trace contains the observations the agent saw, the actions it took, and the environment’s responses — enough, in principle, to locate the specific decision that went wrong and test a concrete alternative. But existing agent post-training datasets either (a) throw away failures entirely in favor of successful rollouts, or (b) label them with coarse outcome rewards that do not identify a revisable decision. The Agent Error Dataset (AED) is a direct attempt to fill this gap: 50,228 error–diagnosis pairs drawn from 9,961 source tasks across 33 environments, 19 harness families, and 23 policy models, each pairing a failed trace with a localized diagnosis, a proposed correction, and — where replay is supported — matched counterfactual outcomes.
Construction: the AET pipeline
A run is counted as failed only when its environment adapter reports an unsuccessful terminal outcome within budget. Crucially, this collection-level signal does not by itself locate an error; attributing an agent error requires identifying a trace-supported, avoidable decision. The authors deliberately separate task failures, recovered tool errors, and ungradable runs, since these have very different implications for learning.
Each record stores the failed action–observation trace, one diagnosis, a proposed correction, review decisions, available replay branches, and construction metadata (policy, harness, debugger, information visible to each stage). Diagnoses are free text — d_i = (t_i^*, u_i^*, e_i, a_i^*), i.e., attributed step, responsible agent, evidence-grounded explanation, and proposed correction — rather than labels from a fixed taxonomy. Error modes are induced post hoc, leaving the underlying labels unchanged. Multiple proposals for the same failure are retained as distinct attempts and grouped by source task for splitting.
The five-stage Agentic Error-to-Training (AET) pipeline (i) collects natural failures, (ii) generates diagnoses and corrections, (iii) checks them against recorded trace evidence, (iv) where supported, replays corrections from the same checkpoint under matched execution settings, and (v) compares to original-action retries to isolate the effect of the correction rather than stochastic re-execution.
Training views
AED exposes two post-training views over the same records, differing only in what is masked and how losses are normalized. Let x_i be the visible context, y_i the target response, m_{ik} a binary token mask with M_i = \sum_k m_{ik}. Per-example loss is standard token-level NLL on target tokens only:
\ell_i(\theta) = -\sum_k m_{ik} \log \pi_\theta(y_{ik} \mid x_i, y_{i,<k}).
The two aggregations differ:
\mathcal{L}_{\mathrm{diag}}(\theta) = \frac{1}{|\mathcal{B}|}\sum_{i\in\mathcal{B}} \frac{\ell_i(\theta)}{M_i}, \qquad \mathcal{L}_{\mathrm{actor}}(\theta) = \frac{\sum_{i\in\mathcal{B}} \ell_i(\theta)}{\sum_{i\in\mathcal{B}} M_i}.
Diagnosis training uses per-example mean loss (each failure contributes equally regardless of diagnosis length), while actor training uses token-level normalization spanning all ranks and accumulation steps (longer corrections get proportionally more gradient). Only target assistant tokens — including the end-of-turn token for the actor view — receive loss; context and tool observations do not. The diagnosis view pairs x_i = \tau_i (failed trace) with y_i = d_i, and critically excludes construction-only information: verifier context, successful reference trajectories, and replay outcomes are never shown to the diagnosis model, so admission into the dataset does not require a successful replay.
Results
The headline counterfactual result comes from 3,062 matched replay pairs, where a first-proposal correction is executed from the same checkpoint under matched execution settings and compared against a plain retry of the original action. First-proposal corrections raise verifier pass rates from 18.4% to 51.1%, a +32.7 pp gain. Because the comparison is matched on checkpoint and execution budget, this is a reasonably clean estimate of correction utility over stochastic re-execution of the original decision.
Experiments use Qwen3-8B as the trainable base, with objective-specific frozen populations and source-task-held-out internal splits. Missing or unparseable responses count as misses; public comparisons share visible inputs and scorers within protocol. The abstract indicates downstream gains from a separately frozen diagnoser used in training recipes, though the quoted excerpt is truncated at that point.
Limitations and open questions
Several caveats are worth flagging. First, “failure” is defined by environment adapters, so the dataset inherits whatever labeling noise those adapters contain, and the task/tool/ungradable distinction is pushed into the appendix. Second, diagnoses are free text and partly LLM-generated; the evidence check mitigates but does not eliminate the risk that diagnoses rationalize rather than localize. Third, the +32.7 pp replay gain is restricted to the subset of environments and tasks that support deterministic replay — likely biased toward tool-use and sandboxed coding tasks, and away from stochastic web environments. Fourth, with 23 policy models contributing failures, there are open questions about how transferable the induced “error modes” are across model families and scales, and whether an error-aware actor trained from Qwen3-8B diagnoses generalizes to failures produced by stronger policies.
Why this matters
Treating failed rollouts as structured supervision — localized to a decision, tested against a counterfactual — is a concrete alternative to reward-only RL on agent trajectories, and the 18.4% → 51.1% matched-replay improvement suggests that cheap diagnosis-and-correction can recover a nontrivial fraction of failed tasks without additional environment interaction. At 50k pairs across 33 environments it is also large enough to use as a general-purpose post-training resource rather than a per-benchmark artifact.
Source: https://arxiv.org/abs/2609.40111
UniEvo-VL: An On-policy Self-Distillation Training Recipe for Multimodal Model Self-improvement
Problem
Unified multimodal models (MMMs) that both generate and understand images open a path to self-improvement without external supervision: the same network can critique its own outputs and use that critique as a learning signal. The practical question is how to convert these critiques into stable gradients for a diffusion generator without (i) requiring a larger teacher model, (ii) collapsing the student onto the critic’s text distribution, or (iii) destroying the model’s ability to still consume reflective feedback at inference. UniEvo-VL frames this as on-policy self-distillation: a single network plays both teacher and student, differentiated only by access to privileged critique context.
Method
Let \mathcal{M}_{\boldsymbol{\theta}} denote an MMM operating in two modes. In generation mode it maps a prompt p and noise \boldsymbol{\epsilon}\sim\mathcal{N}(\mathbf{0},\boldsymbol{I}) to an image, and in understanding mode it maps (p, I) to a critique c and an acceptance bit a\in\{0,1\}:
I=\mathcal{M}_{\boldsymbol{\theta}}^{\mathrm{gen}}(p,\boldsymbol{\epsilon}),\qquad (c,a)=\mathcal{M}_{\boldsymbol{\theta}}^{\mathrm{und}}(p,I).
A valid assessment with a=0 emits corrective text c specifying what diverges between I and p along semantic, text-rendering, and visual-quality axes; a=1 keeps I as-is. Invalid or empty critiques are filtered.
The training loop (Figure 2) proceeds as follows. The student samples a draft trajectory from the original prompt p. The frozen understanding mode produces (c,a), and a prompt-synthesis step merges (p,c) into a revised, privileged prompt p^{+}. An EMA copy of the model, acting as teacher \mathcal{M}_{\bar{\boldsymbol{\theta}}}^{\mathrm{gen}}(\cdot \mid p^{+}), denoises along the student’s trajectory conditioned on p^{+}. The student, conditioned only on p, is trained to match the teacher per-state via a transition-matching divergence over the denoising distributions. Schematically,
\mathcal{L}(\boldsymbol{\theta}) = \mathbb{E}_{t,\, x_t \sim \pi_{\boldsymbol{\theta}}(p)} \big[\, D\!\left(\, q_{\bar{\boldsymbol{\theta}}}(x_{t-1}\mid x_t, p^{+})\;\big\|\; q_{\boldsymbol{\theta}}(x_{t-1}\mid x_t, p)\,\right) \big].
Three design choices matter. First, the trajectories are the student’s own, so training is on-policy with respect to the deployed sampler. Second, the critique enters only the teacher’s context; the student never sees c during the loss, which prevents the model from learning to depend on revised prompts at inference. Third, only generator LoRA parameters are updated, while the critic (Qwen-VL) is frozen, decoupling improvement in generation from drift in understanding.
Separate LoRA adapters are trained for GenEval, GenEval2, and OCR text rendering. The authors evaluate both with and without a post-revision verification pass (the critic re-checks the revised prompt before it is accepted as teacher context), and additionally substitute a stronger external critic (GPT-5.6-Luna) to test whether critic quality bounds the attainable improvement.
Results
Built on Qwen-Image-2512 with a fixed Qwen-VL critic, UniEvo-VL raises GenEval from 0.747 to 0.808 and GenEval2 Soft-TIFA from 32.97 to 35.53. These gains are obtained without changing the architecture or sampler and without any human preference data: the only external signal is the critic’s text, which is itself produced by the same model family.
Qualitatively, improvements concentrate on the compositional axes that GenEval2 stresses — object counts, colors, materials, and surface patterns — where the base model frequently miscounts or mis-attributes. The direct-generation row (without any inference-time critique) already closes much of the gap, confirming that the privileged-teacher signal has been internalized rather than merely re-routed through revised prompts.
A key behavioral property is preserved: because the student is never trained to consume c directly, the evolved model still responds to an optional reflection pass at test time. The third row of Figure 7 shows that an additional critique step yields further corrections on hard cases rather than being ignored or over-fitted. Experiments with the stronger GPT-5.6-Luna critic indicate that critic quality is a non-trivial lever on headroom, consistent with the view that this is self-distillation from a privileged context rather than true bootstrapping from nothing.
Limitations and open questions
The method inherits the critic’s blind spots: failure modes the understanding mode cannot articulate — fine typographic errors, physical plausibility, long-range spatial logic — are unlikely to be fixed. The acceptance bit a is binary and the critique is free-form text, so the training signal is coarse and noisy; invalid-assessment filtering is a necessary but ad hoc safeguard. Only generator LoRA is updated, which leaves open whether jointly updating the understanding mode would compound gains or induce critic–generator collusion. Separate adapters per benchmark raise the question of whether a single unified LoRA can match specialized ones without interference, and the absolute improvement on GenEval2 (≈2.6 Soft-TIFA points) suggests diminishing returns once the critic is saturated. Compute cost, discussed in Appendix A.4, scales with trajectory sampling plus EMA teacher passes, roughly doubling the per-step cost of ordinary diffusion fine-tuning.
Why this matters
UniEvo-VL shows that unification of generation and understanding in a single MMM is not just an inference-time convenience but a training-time asset: the model’s own critiques, treated as privileged context for an EMA teacher, suffice to drive measurable on-policy improvement without a larger teacher or human labels, while preserving the model’s responsiveness to reflection at test time.
Source: https://arxiv.org/abs/2609.38721
AREX-2: Advancing Self-Improving Agents through Long-Horizon Reflective Tasks
Problem
An LLM agent is “self-improving” if, given more rounds at test time, it produces monotonically better solutions. AREX-2 decomposes this into two capacities: reflection, which determines the average productive gain per round, and long-horizon execution, which determines how many rounds remain productive before the agent plateaus or regresses. The question is whether these are domain-agnostic meta-skills that can be instilled by imitation on trajectories collected in a few verifiable domains, and whether they transfer to open-ended tasks (deep research, agentic reasoning) that lack dense verifiable feedback at training time.
Formalization
An environment is e=(\sigma, S) with a task \sigma and scoring function S oriented so that higher is better (fraction of hidden tests passed, validation metric, etc.). A trajectory of n rounds is
\tau = (y_0, f_0, y_1, f_1, \ldots, y_n, f_n), \quad s_t = \max_{k \le t} S(y_k).
Per-round expected gain under \pi_\theta is r_t = \mathbb{E}_{\pi_\theta}[s_t - s_{t-1}], and the total expected improvement over a budget T decomposes as \sum_{t=1}^{T} r_t. Defining a productivity threshold \epsilon, the authors isolate
T^{\ast} = |\{t \le T : r_t > \epsilon\}|, \qquad \bar{r} = \frac{1}{T^{\ast}} \sum_{t \le T:\, r_t > \epsilon} r_t,
so total improvement is \bar{r} T^{\ast} up to an \epsilon T slack. \bar{r} measures reflection quality and T^{\ast} measures long-horizon execution; adding budget beyond T^{\ast} returns nothing. This is the explicit object the training data is designed to extend.
Method
The pipeline (Figure 3) has three stages:
Environment synthesis. Environments are mined from GitHub repositories (ML tasks, with validation metrics as S) and competitive programming judges (algorithmic tasks, with hidden-test pass rates as S). Each candidate environment is executed and validated; environments that cannot reliably be scored, or whose scoring is trivially saturated, are dropped. These two domains are chosen because S is cheap and automatic, and because the ceilings are high enough that many rounds remain productive.
Trajectory collection. A base agent is run in each environment over many rounds. Within a round the agent reads code and problem statements, edits files, runs tests, retrieves operational knowledge on demand (library APIs, algorithmic idioms, failure modes), and finally submits y_t to receive f_t. The behaviors the authors want to transfer — grounding on feedback f_t, incremental operational-knowledge acquisition, recovery from regressions — appear naturally when the environment’s score is informative and the horizon is long.
Supervised training. Trajectories are filtered to retain those exhibiting sustained improvement in s_t (not merely activity) and are converted into supervision for imitation learning. The backbone is Qwen3.8-27B. Because the training target is the behavior pattern rather than any single domain’s content, the hope is that \bar{r} and T^{\ast} learned on ML/algorithmic tasks apply to browsing-based research as well.
A notable design choice: since s_t is a running max, individual submissions can underperform without lowering s_t. This permits exploratory submissions during training trajectories and discourages conservative “do not regress” behavior that would cap \bar{r}.
Results
On the two source domains, AREX-2 reaches 81.8 Any Medal on MLE-bench Lite (averaged over three seeds) and 70.7 on Frontier-CS. Transfer to deep research is the more interesting claim: 84.0 on BrowseComp, 52.6 on HLE, 92.2 on GAIA, and 93.8 F1 on DeepSearchQA, all without domain-specific training data for those benchmarks. The GAIA and DeepSearchQA numbers in particular suggest the long-horizon-execution component T^{\ast} is doing work in multi-step tool-use settings that resemble the training trajectories’ structure (iterative submit → feedback → revise) even though the surface task differs.
Figure 2 reports that the 27B model matches or exceeds substantially larger closed and open models on these benchmarks, which is consistent with the paper’s framing that self-improvement is a learnable behavior rather than a capacity that only emerges with scale. The authors also note that performance keeps rising as the round budget T is extended, i.e. empirically T^{\ast} for this policy is large relative to the evaluation budgets used.
Limitations and open questions
The paper presents imitation on filtered trajectories only; there is no RL stage, so \bar{r} is bounded by the demonstrator’s reflection quality on the collected trajectories. The transfer claim rests on four deep-research benchmarks whose evaluation protocols vary (F1 vs. accuracy), and the paper does not isolate how much of the gain comes from long-horizon execution versus simply better single-shot reasoning induced by the ML/code data. The \epsilon-productive-round framework is used to motivate design but is not directly measured per benchmark, so claims about T^{\ast} transferring to browsing tasks remain indirect. Finally, environment filtering (“kept only if they pass execution and validation”) is an opaque step whose selection pressure likely matters: trajectories where S is noisy or saturates early would train the wrong meta-skill.
Why this matters
If reflection and long-horizon execution are genuinely domain-agnostic meta-skills, then verifiable-feedback domains like competitive programming and ML engineering can serve as factories for agent-training data applicable to open-ended tasks where supervision is otherwise unavailable. AREX-2’s deep-research numbers from a 27B base support this route as an alternative to scaling or to RL with sparse task-specific rewards.
Source: https://arxiv.org/abs/2609.38288
EvoDuet: Bilevel Co-Evolution of Web Searching and Task Solving for Scientific Discovery
Problem
Evolutionary search with a frozen LLM as mutation operator (OpenEvolve, AlphaEvolve, FunSearch) stalls when progress requires knowledge the model does not possess. Bolting on a web search tool is insufficient: as the current solution evolves, static or naively re-issued queries keep returning the same documents and the retrieval loop decouples from the optimization trajectory. The authors show in a controlled oracle study (Figure 3) that supplying relevant documents does raise average Normalized Discovery Gain (NDG) — e.g., Qwen3.5-9B gains 10.3% with oracle documents — yet weaker backbones cannot replicate this gain when they must themselves decide what to search for. The research question is therefore how to couple query evolution and solution evolution tightly, without finetuning.
Method
EvoDuet casts discovery as a bilevel optimization with shared objective \mathcal{E}:
x^{\star}=\argopt_{x\in\mathcal{X}}\mathcal{E}(x) \quad \text{s.t.}\quad q_t^{\star}=\argopt_{q\in\mathcal{Q}_t}\mathcal{E}\bigl(x_{t+1}(q)\bigr),\quad x_{t+1}\sim \mathcal{M}_\theta(I,c_t,\mathcal{S}_t(q_t^{\star})).
The outer loop is the standard scaffold: policy \phi selects parent x_t with history \mathcal{H}_t from population \mathcal{D}_e, forms context c_t=[\mathcal{H}_t;x_t], and samples a candidate conditioned on retrieved docs \mathcal{S}_t. The inner loop evolves queries, but because the true inner objective \mathcal{E}(x_{t+1}(q)) is only observable post-generation, the authors use the LLM itself as a score predictor \widehat{\mathcal{E}}_\theta to approximate \hat q_t=\argopt_q \widehat{\mathcal{E}}_\theta(I,c_t,\mathcal{S}_t(q)). Documents are retained when their hypothetical evidence score exceeds the parent’s evaluator score, i.e., \hat s_t(d) > \mathcal{E}(x_t).
The two loops are coupled by a knowledge-gap retrieval gate with three actions: retrieve (issue a new query), look-up (reuse the stored document pool), or no-op (proceed without documents). The gate is driven by the model’s self-assessment of its knowledge gap for the current parent and history. Documents promoted during inner-loop ranking are logged with their outcomes, so later gate decisions can condition on past retrieval utility.
Results
Across 21 paired tasks with budget T and N\in\{1,8\} candidates per iteration, EvoDuet raises OpenEvolve’s overall NDG from 74.1% to 78.0% (+3.9) with GPT-5.6-Luna, and from 61.3% to 82.3% (+21.0) with Gemini-3.8-Flash at N=1. Qwen3.5-9B regresses by 14.4% at N=1 and 4.7% at N=8, despite being the model that benefited most from oracle documents (+10.3%). A manual audit of 50 Qwen revisions found 6% unused methods and 20% incorrect implementations (26% combined), suggesting the gating and application demands exceed its capability.
Scaling the parallel candidate count helps uniformly: for GPT-5.6-Luna and Gemini-3.8-Flash on 8 tasks, average NDG grows monotonically with N\in\{1,8,16\}, reaching 95.7% and 89.6% at N=16 (from 89.6% and 84.5% at N=1). Mathematics is the strongest domain, with an average +7.1% NDG across six model/budget settings; even Qwen3.5-9B gains 5.5% on math at N=8. The best runs surpass previously reported SOTA on 8 of 21 tasks (including Swap Reduction on Q20 and Rosetta) and match SOTA on 3 more, at mean compute cost $45.56 per reported run.
The inner-loop surrogate holds up empirically: across 4,324 retrievals, predicted and evaluated candidate scores correlate at Spearman \rho=+0.86, with per-task positive correlation on all 21 tasks (median +0.74). When retrieve retains at least one promising document (\hat s_t(d) > \mathcal{E}(x_t)), the candidate improves on its parent in 67.1% of iterations and sets a new run-best in 14.1%, versus 52.1% and 9.6% under no-op. look-up falls in between (61.2% / 10.1%). When retrieval returns no promising document (36.5% of the time), parent improvement drops to 38.3%, so the hypothetical scoring is doing real filtering work rather than being a rubber stamp.
Behaviorally, among 82 GPT-5.6-Luna runs (8,200 iterations), method transfer dominates (55 runs), followed by using published scores as targets (40), unsuccessful idea transfer (29), and public artifact reuse (6). On Erdős’s minimum overlap C_5 bound, the model locally optimizes a retrieved published construction (0.380859 → 0.380859, matching but not improving), while on Rosetta it refines a published trajectory — only 2 of 11 SOTA results actually depend on reused artifacts in the final program.
Limitations
The gate and query-rewriting demand nontrivial self-reflection: a 9B model fails to exploit retrieved evidence even when it is available, and the method actively hurts in that regime. The surrogate \widehat{\mathcal{E}}_\theta is the same frozen LLM producing the solutions, so systematic predictor biases are not externally calibrated. N=1 Qwen remains below baseline, meaning EvoDuet is not scaffold-neutral in practice. Open questions: how to make the gate robust to weak backbones (fine-tuning the gate alone, or score calibration), how to prevent public-artifact reuse from inflating “discovery” claims on benchmarks whose SOTA is on the open web, and whether co-evolution extends to multi-tool scaffolds beyond web search.
Why this matters
EvoDuet is a concrete demonstration that retrieval and solution search must be jointly optimized rather than stacked: a trainable-parameter-free bilevel loop with an LLM-predicted inner objective yields SOTA on 8 tasks across five scientific domains at modest cost. The strong \rho=0.86 between predicted and realized scores suggests frozen LLMs are already serviceable surrogate critics for retrieval ranking, opening a cheap alternative to learned rerankers in agentic discovery pipelines.
Source: https://arxiv.org/abs/2609.40340
EVOKE: Eliciting World Knowledge in Agents for Transferable Decision-Making
Problem
LLM agents trained with standard behavior cloning or RL on multi-step decision tasks typically overfit to the training environment: they transfer poorly to novel digital environments even when the required world knowledge (what a “Settings” menu does, what clicking “Submit” implies, how a shell command mutates state) is demonstrably present in the base model. World-model agents attack this by learning an explicit predictor p_\theta(o_{t+1} \mid o_{\le t}, a_t) and planning against it, but this reintroduces the two pathologies the LLM should obviate: (i) extra training to re-learn facts already in pretraining, and (ii) compounding rollout error when planning uses model predictions.
The paper reframes the task. For an LLM agent in a digital environment, world knowledge does not need to be acquired; it needs to be elicited. Typical post-training fails to elicit it because every visited state s is paired with a single goal g, so the gradient on \pi(a \mid s, g) has no incentive to disentangle “what the environment is” from “what to do given this specific g.” Policies therefore collapse onto contextual shortcuts — surface features of the trajectory prefix — that happen to correlate with the demonstrator’s action under the training goal.
Method
EVOKE is a post-training procedure that applies pressure for elicitation through goal diversity at fixed state. The motivating theorem (informal) is standard: an agent that is simultaneously competent across a sufficiently diverse family of goals \mathcal{G} at the same state s must encode a world model recoverable from its action preferences, because action rankings under distinct goals constrain the latent transition structure.
Operationally, for each (s, h) in the training buffer (state and interaction history), EVOKE constructs a set of alternative goals \{g_1, \dots, g_K\} and a shared candidate action set \mathcal{A}_s = \{a_1, \dots, a_M\}. The policy is then trained so that the ranking
\pi(a \mid s, h, g_k) \quad \text{varies with } k
in a way consistent with the goal. Concretely, EVOKE uses a preference-style objective where the positive action under goal g_k is the one that advances g_k from s, and negatives include actions that would be positive under a different g_{k'} at the same state. The loss has the form
\mathcal{L}(s, h) = -\sum_k \log \frac{\exp \beta \, r_\theta(a^+_k \mid s, h, g_k)}{\sum_{a \in \mathcal{A}_s} \exp \beta \, r_\theta(a \mid s, h, g_k)},
where r_\theta is the log-likelihood of the action under the policy. Because (s, h) is held fixed while g_k varies, any policy that routes through a goal-agnostic contextual feature of h incurs loss on at least one g_k. The only way to drive the loss down is for the policy to condition action preferences on an internal representation that is simultaneously consistent with the environment dynamics and the current goal — i.e., to use a world model.
A key design choice is how to synthesize the alternative goals. EVOKE generates g_k by prompting the base LLM to propose goals that are achievable from s but distinct from the trajectory goal; this keeps the training signal grounded in states the agent actually visits, rather than counterfactual states that would require a learned transition model.
Results
EVOKE is evaluated as a post-training method on top of standard SFT and preference-optimization baselines on multi-step digital-agent benchmarks involving transfer to unseen environments. The headline findings:
- EVOKE improves transfer success rates substantially over SFT and DPO-style baselines, with gains concentrated on held-out environments rather than in-distribution tasks — consistent with the elicitation hypothesis rather than a generic capacity increase.
- Ablating goal diversity (training with a single goal per state) removes most of the gain, confirming that the goal-variation signal, not merely the additional ranking loss, is responsible.
- Comparisons against world-model baselines that explicitly train a next-observation predictor show EVOKE matches or exceeds their transfer performance without any environment-prediction training and without planning rollouts, avoiding compounding prediction error.
- Scaling the number of alternative goals K per state shows monotonic improvement up to a saturation point, consistent with the theoretical argument that larger |\mathcal{G}| tightens the world-model identifiability constraint.
Limitations and open questions
The approach assumes the base LLM can propose meaningful alternative goals grounded in the current state; in environments far from the pretraining distribution (unusual GUIs, custom DSLs), the generated g_k may be degenerate or redundant, weakening the elicitation pressure. The method also presumes that correct action rankings under g_k can be derived without executing the environment — true for digital agents where consequences are often syntactically evident, but less clear for environments with hidden state. Finally, the paper treats “elicitation vs. acquisition” as a clean dichotomy; in practice, the boundary depends on pretraining coverage, and there is no diagnostic for when EVOKE will fail because the knowledge is genuinely absent rather than merely unexpressed.
Open questions: can the alternative-goal distribution be learned adversarially to maximize elicitation pressure? Does the induced policy expose a probeable world model (i.e., can one recover p(s' \mid s, a) by inverting action preferences, as the theorem suggests constructively)?
Why this matters
EVOKE reframes a central problem in LLM agent training: much of what world-model methods try to learn is already latent in the base model, and the real bottleneck is a post-training objective that forces the policy to use that knowledge rather than paper over it with contextual shortcuts. Goal diversity at fixed state is a cheap, training-only intervention that gives a principled handle on this, with no inference-time overhead.
Source: https://arxiv.org/abs/2609.38334
Hacker News Signals
A Privacy Analysis of Web and Mobile Conversational AI Agents
The paper “Prompt like a butterfly, sting like a tracker” performs a systematic privacy audit of conversational AI agents embedded in commercial web and mobile products. The authors instrument a test environment to intercept network traffic from roughly 30 agents across categories (customer service, health, finance, retail) and analyze what data leaves the client before, during, and after a conversation.
Key findings: a substantial fraction of agents exfiltrate typed input to third-party analytics endpoints before the user submits — the classic pre-submit keystroke leak pattern, now applied to chat UIs. Several mobile agents send device fingerprint signals (IDFA/GAID, screen resolution, battery state) bundled with conversation metadata. The paper introduces a taxonomy distinguishing primary data flows (user-to-agent-to-LLM provider) from secondary flows (session telemetry to ad-tech or CRM platforms), and finds secondary flows are often undisclosed in privacy policies.
The methodology uses mitmproxy for TLS interception, combined with a static analysis pass on Android APKs to identify SDK inclusions (Amplitude, Braze, Segment, etc.). They also test prompt injection resilience: adversarial user inputs that attempt to extract system prompts or manipulate agent behavior succeed in a non-trivial subset of tested agents, with some leaking operator-configured instructions verbatim.
The regulatory angle is GDPR/CCPA compliance: sensitive categories (health queries) are flowing through pipelines without explicit consent capture in several cases. The paper recommends on-device inference for sensitive domains, strict CSP headers to block third-party script access to chat widget DOM, and contractual data processing agreements between operators and LLM API providers.
Limitations: the sample is not randomly drawn, and the authors do not name specific vendors. Reproducibility depends on access to the same agent deployments, which change frequently.
NAND-16: a computer built from 277,248 NAND gates
NAND-16 is a physical 16-bit computer constructed entirely from discrete NAND gates — no microcontrollers, FPGAs, or PLDs. The gate count (277,248) is achieved using 74HC00 quad-NAND ICs on a large PCB array. The architecture is a custom 16-bit RISC-style design with a register file, ALU, program counter, and memory interface, all synthesized by hand from NAND primitives.
The technical interest is in how standard digital building blocks decompose: a 1-bit full adder requires 9 NANDs, a 16-bit ripple-carry adder around 144, and a simple register file with 8 registers at 16 bits each costs roughly 2,000 gates before control logic. The stated 277K figure is consistent with a machine that includes an ALU with basic arithmetic and logic ops, a small instruction set decoder, and enough datapath to run simple programs.
Clock speed is low — on the order of kilohertz — because propagation delay accumulates across long NAND chains on PCB traces rather than silicon. The project is in the tradition of Ben Eater’s 8-bit breadboard CPU and the Megaprocessor (James Newman, ~42K transistors), but at larger scale and with a wider datapath.
What makes this technically instructive: it concretely demonstrates the universality of NAND completeness, forces explicit reasoning about fan-out (74HC logic can drive ~10 standard loads), and makes visible the area/power tradeoffs that VLSI synthesis handles automatically. Power consumption at this gate count with TTL-family logic is non-trivial — possibly tens of watts — which itself illustrates why transistor density and CMOS idle-low characteristics matter.
Source: https://somethingbig.ai/computer
PSSA: A non-transformer language model written from scratch in Rust
PSSA (Positional State Space Architecture, based on the naming) is a from-scratch Rust implementation of a non-transformer sequence model, apparently drawing on SSM ideas (Mamba-style or similar). The codebase is entirely in Rust with no Python bindings, targeting both the model definition and training loop natively.
The technical substance is in the implementation choices. Rust lacks the mature autograd ecosystem of PyTorch/JAX, so the author implements reverse-mode autodiff manually, maintaining explicit computation graphs or using operator overloading with dual numbers depending on the pass. Matrix operations rely on either ndarray or manual BLAS calls, with no GPU backend at current stage — training runs on CPU.
The SSM core computes hidden state recurrences of the form h_t = A h_{t-1} + B x_t, y_t = C h_t, with learned A, B, C matrices, avoiding the O(n^2) attention cost. Without a parallel scan kernel (which requires CUDA or similar), the recurrence runs sequentially, so training throughput is limited. The project does not yet include the selective scan mechanism that distinguishes Mamba from vanilla S4 (input-dependent B, C, \Delta).
For the HN audience the interest is less about SOTA performance and more about the systems exercise: Rust’s ownership model interacts awkwardly with mutable graph nodes during the backward pass, requiring either Rc<RefCell<>> patterns or arena allocation. The repo shows the author navigating this. Character-level language modeling on small corpora is the demonstrated task.
This is primarily a learning/research artifact rather than production tooling, but non-trivial as a demonstration that Rust can host a complete training pipeline without FFI.
Source: https://github.com/Sparticle62ops/pssa
You said no MCP
This post documents a concrete failure mode with Model Context Protocol (MCP) server configurations: a user explicitly configures an AI coding assistant to not use a specific MCP server, and the agent uses it anyway. The author captures the session transcript and the reasoning trace, showing the model either misreading its tool manifest, ignoring a negative instruction in the system prompt, or having the client-side routing layer bypass the stated constraint.
The technical substance is about MCP’s trust and enforcement model. MCP is a JSON-RPC-based protocol where a host (the AI client) connects to servers that expose tools, resources, and prompts. The spec places responsibility for tool invocation decisions on the model, mediated by the client. The failure described is in that mediation layer: the client is not enforcing the user’s negative capability declaration before presenting tools to the model or before executing a model-requested tool call.
This surfaces a broader architectural problem: LLM-based agents that route tool calls through a model’s judgment cannot provide hard capability guarantees, because the model’s instruction-following is probabilistic. A robust implementation would enforce negative capability lists at the client/router level — never presenting the disallowed server’s tools in the tool manifest at all — rather than relying on the model to honor a natural-language prohibition.
The comments on HN discuss whether MCP needs a formal capability/permission layer with cryptographic or at least deterministic enforcement, and whether the current spec’s reliance on model compliance is adequate for production use. The post is a useful minimal reproduction case for a class of agent reliability bugs that will become more consequential as MCP adoption grows.
Source: https://earendil.com/posts/you-said-no-mcp/
MicroLLM Lab: Try 7 tiny LLMs in the browser
MicroLLM Lab runs seven small language models entirely client-side via WebAssembly and WebGPU, with no server-side inference. The models include variants in the sub-1B parameter range — likely quantized versions of models such as SmolLM, Qwen-0.5B, Phi-1.5, and similar, compiled via llama.cpp’s WASM target or Transformers.js (ONNX runtime in the browser).
The technical stack: WebGPU provides compute shader access for matrix multiplication on the device GPU, bypassing the CPU-only constraint of older WebAssembly ML demos. Transformers.js uses ONNX Runtime Web with WebGPU backend; llama.cpp’s Emscripten build falls back to WASM SIMD for CPU inference when WebGPU is unavailable. Models are quantized to 4-bit or 8-bit to fit within browser memory limits (typically < 2GB usable before tab pressure on most devices).
The interesting engineering constraint is weight delivery: a 500M parameter model at 4-bit is roughly 250MB, which must be fetched and cached in the browser. The demo uses the Cache API for persistence across sessions. First-load latency is high; subsequent loads from cache are fast. Token generation throughput on a mid-range GPU via WebGPU reaches roughly 10-30 tokens/second for sub-1B models, which is usable for interactive demos.
This is a useful benchmark for the current state of browser-native inference — the gap between WebGPU compute throughput and native CUDA/Metal is shrinking but remains roughly 3-5x on equivalent hardware. The demo is also practically useful for developers evaluating whether a given small model is viable for fully private, zero-server deployment.
Source: https://stateofutopia.com/experiments/microllmlab/
Jeeves: Reasoning improves Jev-like decision models
Jeeves is PostHog’s open-source system for automated feature flag and product decision-making, inspired by the Jev (Judgmental Experimentation via Values) framework. The core idea: instead of a fixed rules engine or a pure ML classifier, Jeeves queries an LLM with structured reasoning to decide whether a feature flag should be enabled for a given user segment, based on product metrics and user cohort data piped in as context.
The architecture exposes a decision API: each call provides the LLM with a structured context block (current metric values, experiment results, rollout percentage, user properties) and asks it to reason step-by-step before emitting a structured JSON decision. The chain-of-thought step is explicitly retained and logged, making decisions auditable — a requirement for product decisions that affect revenue metrics.
The technical claim is that reasoning (chain-of-thought or scratchpad generation before the final answer) measurably improves decision quality over direct classification, consistent with the broader CoT literature. The repo includes evals comparing direct-answer prompts versus reasoning prompts on a synthetic benchmark of feature flag scenarios.
Implementation details worth noting: the system uses structured output (JSON schema enforcement at the API level) to guarantee parseable decisions, and includes a retry/fallback layer for when the LLM output fails schema validation. PostHog connects this to their existing feature flag infrastructure, so Jeeves decisions can directly trigger flag changes via their API.
Open questions: how the system handles adversarial or out-of-distribution metric patterns, and whether the LLM’s reasoning is genuinely causally relevant to the decision or post-hoc rationalization. The eval benchmark is synthetic and may not capture real product decision complexity.
Source: https://github.com/PostHog/jeeves
Magnitude (YC S25): Self-optimizing inference engine for agents
Magnitude is an inference routing layer specifically targeted at agentic workloads, where a single user request triggers many sequential or parallel LLM calls with heterogeneous latency/quality requirements. The self-optimizing claim refers to runtime adaptation of model selection and batching strategy based on observed task characteristics.
The technical approach, as described in the repo: each “step” in an agent trajectory is classified by a lightweight router into a difficulty tier, which then maps to a model selection policy (e.g., smaller/faster model for retrieval formatting steps, larger model for multi-step reasoning). The router itself is a small classifier trained on task embeddings and historical quality signals (user feedback, downstream step success). This is similar in spirit to FrugalGPT and similar cascade/routing papers, but with explicit agentic step structure as a first-class concept.
Batching is handled by grouping independent agent steps (parallel tool calls, map operations over document sets) into single inference requests where the underlying API supports it. The engine tracks a dependency graph of agent steps to identify parallelism opportunities the application code does not explicitly expose.
The “self-optimizing” loop: quality signals from completed agent runs feed back into the router’s model selection policy via a lightweight online update. This is a bandit-style optimization over the model selection action space, with task embedding as context.
Current limitations from the repo: the feedback loop requires task outcome labels, which are not always available in production; the dependency graph inference is heuristic and can misclassify sequential steps as parallel. GPU-side batching optimization is deferred — the current engine operates above the inference server level.
Source: https://github.com/magnitudedev/magnitude
SDF vs. MSDF vs. Slug vs. Rive: GPU Text Rendering
This post is a technical comparison of four GPU text rendering approaches, covering the core algorithmic tradeoffs in detail.
SDF (Signed Distance Fields): Pre-rasterize each glyph into a distance field texture. At render time, threshold the sampled distance value with anti-aliasing via smoothstep. Artifacts appear at high zoom (rounded corners on sharp features) because the distance field is a band-limited approximation. Resolution of the SDF texture is the limiting factor.
MSDF (Multi-channel SDF): Valve/Chlumsky’s technique encodes three independent pseudo-distance fields across RGB channels, using median-of-three to reconstruct corners. Sharp right-angle features are preserved at much higher zoom levels than single-channel SDF without a proportional increase in texture size. The tradeoff is more complex shader logic and a preprocessing step to generate the MSDF atlas.
Slug: Eric Lengyel’s approach stores the actual Bezier curve data in GPU buffers and evaluates the coverage analytically in the fragment shader. No pre-rasterization — each fragment computes its exact signed distance from the nearest curve segment. This is analytically correct at any zoom level, eliminates atlas management entirely, but has higher per-fragment compute cost (curve intersection tests in the shader). Suited for vector UI at variable scales.
Rive: Uses a GPU-side tessellation approach for vector rendering broadly (not just text), computing coverage via a winding-number algorithm in compute shaders. More general than Slug (handles fills, strokes, animations) but with corresponding overhead.
The article benchmarks these on WebGL/WebGPU contexts, finding MSDF dominates for static text at predictable sizes (lowest GPU cost, acceptable quality), Slug wins on quality at arbitrary scales, and Rive has overhead justified only when animated vector content is present.
Source: https://alphapixeldev.com/sdf-vs-msdf-vs-slug-vs-rive-gpu-text-rendering/
Noteworthy New Repositories
TokenRhythm/NeoHorse
NeoHorse-1 targets recursive self-improvement for LLMs via agentic post-training. The core idea is a routing harness: rather than a single monolithic training loop, the system routes generated outputs through a hierarchy of verification and refinement agents that score, filter, and re-queue trajectories for further training. This creates a feedback cycle where the model’s own agentic outputs become training signal — closer in spirit to STaR/ReST than to RLHF, but with explicit routing logic controlling which paths get amplified. The “recursive” framing means the post-training pipeline itself is subject to modification by the agents it trains, though how far that recursion actually goes in the current release warrants scrutiny. The repository includes training configs, routing harness code, and checkpoint infrastructure. It is relevant to anyone working on self-play, iterative preference optimization, or bootstrapping reasoning capability without human annotation at each step. The routing harness design is the differentiating piece: rather than uniform sampling, it applies task-type and difficulty-aware dispatch to allocate compute to the most informative training examples. Worth examining if you are building iterative fine-tuning pipelines on top of open-weight models and want structured trajectory selection beyond naive rejection sampling.
Source: https://github.com/TokenRhythm/NeoHorse
ruc-datalab/EvoOntology
EvoOntology implements a self-evolving ontology layer designed to sit between a data agent (Claude Code, OpenAI Codex) and an underlying codebase or database. The ontology captures domain concepts, entity relationships, and schema semantics in a structured graph, and the “evolving” part means the layer updates its own concept graph as the agent encounters new entities or relationships during task execution. Mechanically, this is a plugin that intercepts agent tool calls, extracts named entities and relational assertions from intermediate outputs, and merges them into a maintained ontology store using a reconciliation procedure that handles concept drift and synonym resolution. The practical value: agents operating on large, poorly documented codebases suffer from context fragmentation across turns. EvoOntology maintains a persistent semantic index that survives context window resets, giving subsequent turns access to accumulated structural knowledge. The graph is queryable so the agent can ask “what modules handle authentication?” and get grounded answers rather than hallucinating structure. It is built as a lightweight plugin rather than a full framework, which limits adoption friction. Primary limitation is that ontology quality depends on agent output quality — garbage in, garbage out applies directly to the concept extraction step.
Source: https://github.com/ruc-datalab/EvoOntology
shadcn-ui/lint
This is an agent-first linter for Tailwind-based design systems, built on the observation that design systems expressed purely in documentation or storybook stories are invisible to coding agents. The approach: design system rules are written in a declarative DSL (extending standard lint rule format) that both humans and agents can read and verify. Rules can express things like “never use arbitrary color values outside the palette,” “spacing must use the 4px grid tokens,” or “this component variant pattern is forbidden.” The linter runs statically over JSX/TSX and Tailwind class strings, but crucially the rule format is structured so an agent can query which rules a proposed change violates before committing it — closing the loop between code generation and design constraint enforcement. This is architecturally different from ESLint plugins because the rule definitions are first-class data, not imperative JavaScript, making them consumable by an LLM as grounded policy. The implementation hooks into existing Tailwind tooling and outputs structured violation reports suitable for agent consumption. Useful for teams where AI-assisted frontend development is producing visual drift from an established design system, and where purely human review of Tailwind class strings is not scaling.
Source: https://github.com/shadcn-ui/lint
youngyangyang04/llm-master
A structured Chinese-language curriculum covering the full LLM application stack, from prompt engineering through RAG, agent frameworks, MCP (Model Context Protocol), fine-tuning, and production deployment. The repository is organized as a learning path rather than a toolkit, with each section containing explanations, annotated code examples, and pointers to interview preparation material targeting roles at Chinese tech companies. The technical content covers Transformer architecture internals, LoRA/QLoRA fine-tuning procedures, vector database integration for RAG, and agent loop implementation patterns. While it does not present novel research, its value is as a single coherent reference that connects foundational ML concepts to production engineering concerns in a way that most English-language resources treat separately. The MCP coverage is notable given how recently that protocol has gained traction. For non-Chinese readers the language is a barrier, but the code examples are largely self-documenting. Useful as a benchmark for what full-stack LLM engineering curricula look like in 2025, and for Chinese-speaking practitioners who want a structured path from ML theory to deployment without assembling resources from disparate sources.
Source: https://github.com/youngyangyang04/llm-master
0xNatoshi/jev-codex-router
A per-turn model and reasoning router for OpenAI Codex sessions, built on top of a type-safe rule engine called Jev (described as “System One”). Each turn in a Codex session is classified by task type, complexity, and latency requirements, then dispatched to an appropriate model variant with a corresponding thinking depth (e.g., o1 vs. o3-mini vs. standard GPT-4o) and speed mode. The routing logic is expressed as typed rules rather than heuristics in code, which means routing policy can be audited, tested, and modified without touching dispatch infrastructure. The practical motivation: using maximum reasoning depth uniformly across all turns wastes compute and increases latency on simple turns (autocomplete, trivial refactors) while potentially under-provisioning on complex architectural decisions. The type-safe framing via Jev means routing rules carry compile-time guarantees about which model capabilities they reference — if a referenced model capability is removed or renamed, the type system catches it. This is a narrow but well-scoped engineering tool for teams running high-volume Codex integrations who want cost and latency optimization without sacrificing quality on turns that need it.
Source: https://github.com/0xNatoshi/jev-codex-router
nanaism/yomiyasu
An agent skill targeting a specific and underserved problem: AI-generated Japanese text reads as unnatural to native speakers because LLMs default to patterns that are grammatically correct but stylistically mechanical — overuse of certain connectives, unnatural topic-comment structure, excessive formality mixing. Yomiyasu implements a refinement agent that takes AI-generated Japanese prose and rewrites it toward natural colloquial or contextually appropriate register. The skill is structured as a composable agent module rather than a standalone tool, meaning it can be inserted as a post-processing step in any agent pipeline that produces Japanese text output. Technically it wraps an LLM with a carefully constructed system prompt and few-shot examples encoding specific naturalness heuristics (validated against native speaker judgments, per the documentation). The narrow focus on Japanese-specific linguistic patterns rather than generic “improve this text” prompting is what differentiates it — generic improvement prompts tend to produce different problems rather than fixing naturalness. Relevant for applications targeting Japanese-speaking users where AI-generated content quality affects user trust: customer service bots, documentation generation, content pipelines.
Source: https://github.com/nanaism/yomiyasu
Qiuner/birdview
Birdview addresses a concrete failure mode in AI-assisted development: coding agents modify files without visibility into the broader architectural context, producing changes that are locally correct but architecturally incoherent. The tool generates a structural map of a codebase — module dependency graph, key abstraction boundaries, data flow paths — before the agent begins making changes. This map is injected into the agent’s context, giving it explicit architectural grounding. The implementation performs static analysis over the project (language-agnostic at the file/import level, with deeper analysis for supported languages) and produces a structured summary that fits within a context window without reproducing full source. The key design choice is that the map is generated fresh before each change session rather than maintained incrementally, trading staleness risk for simplicity. This is a pragmatic alternative to full codebase indexing systems like tree-sitter-based semantic search. Useful for mid-size projects (tens to low hundreds of files) where an agent repeatedly loses track of module responsibilities. The limitation is that static import graphs miss runtime architectural patterns, so domain-specific layering conventions may not surface.
Source: https://github.com/Qiuner/birdview
ejfkdev/ddc
DDC is a DEX-to-Java decompiler written in Rust, targeting Android’s Dalvik Executable format. The pipeline takes .dex bytecode and produces readable Java source, implementing the full decompilation chain: DEX parsing, Dalvik bytecode lifting to an IR, control flow reconstruction, type inference, and Java AST emission. The Rust implementation is the differentiating choice: existing decompilers (jadx, cfr) are JVM-based and carry GC pause and startup overhead that matters for large APKs or toolchain integration. The “progressive analysis” description refers to the ability to partially decompile — emit results for already-analyzed methods while continuing analysis on the rest — which improves interactivity for large inputs. The bilingual CLI (Chinese/English) is a surface-level feature but signals the primary target audience. From an engineering standpoint, the interesting challenges are Dalvik-specific: the register-based ISA versus JVM’s stack-based model complicates SSA construction, and try/catch region reconstruction from Dalvik’s exception table format requires care. A Rust decompiler also opens the door to embedding decompilation in security tooling without JVM dependencies — useful for CI-integrated APK analysis pipelines. Primary limitation at this stage is likely coverage of obfuscated or edge-case bytecode patterns.
Source: https://github.com/ejfkdev/ddc