Daily AI Digest — 2026-07-24
arXiv Highlights
AREX: Towards a Recursively Self-Improving Agent for Deep Research
Problem
Deep research queries — the kind exemplified by BrowseComp or GAIA — demand answers that jointly satisfy a bundle of constraints (temporal, numerical, relational, evidentiary). The core observation motivating AREX is the discovery–verification asymmetry: producing a candidate answer requires expensive multi-hop search, but checking whether a candidate satisfies each constraint decomposes into cheap constraint-wise verifications. A search agent that only “thinks longer” or extends its trajectory linearly fails to exploit this asymmetry. AREX instead runs a bi-level loop where verified sub-claims are frozen and unresolved constraints seed new, targeted retrieval passes.
Method
AREX operates as two nested loops around a research state. The inner loop derives an objective q^{(t)} from the query x, executes tool calls (search, browse, paper retrieval), integrates evidence, and emits a provisional answer with a self-reported confidence score s^{(t)}. The outer loop consumes (q^{(t)}, \text{answer}, s^{(t)}) and either (i) accepts the answer if s^{(t)} > \tau, (ii) audits the answer against the constraint set \mathcal{C}(y), preserves verified evidence, and constructs a refined objective q^{(t+1)} targeting unresolved constraints, or (iii) restarts if the trajectory is deemed unrecoverable.
A key engineering piece is an autonomous context-update tool: rather than concatenating raw histories or delegating summarization to an external model, AREX learns to emit a compressed “improvement state” containing (a) verified evidence, (b) still-unresolved constraints, and (c) the next research objective. This is what makes recursion viable over long horizons — the state grows sub-linearly and preserves the invariants the outer loop needs to reason about progress.
Task synthesis follows a constraint-first construction. Given a latent answer y, human templates define a constraint set
\mathcal{C}(y) = \{c_1, c_2, \ldots, c_n\},
each c_i representing a verifiable research objective. Constraints are transformed into indirect descriptions \mathcal{C}' (to prevent keyword matching) and the query is generated as
x = f(y, \mathcal{C}').
Validity requires: y is not directly inferable from x; every c_i \in \mathcal{C}' is verifiable from accessible evidence; and \mathcal{C}' jointly identifies y uniquely. Independent rollouts filter tasks that are either trivially retrievable or unsolvable, producing \mathcal{D}_{\text{task}} = \{(x, y)\} across three regimes: browse-intensive, reasoning-intensive, and scientific-literature.
Training proceeds in two agentic mid-training stages plus long-horizon RL. Stage 1 progressively acquires capabilities: browse-intensive trajectories first (tool use, navigation, evidence acquisition, query reformulation), then expert-reasoning trajectories (long-form deduction, hypothesis comparison). Because reasoning specialization degrades browsing behaviors, stage 2 does mixed-capability consolidation — targeted replay of difficult intermediate decisions from browse trajectories interleaved with capability-expanding tasks (academic-paper research, knowledge-intensive reasoning) and, crucially, verification-driven transitions where a provisional answer is audited, verified evidence is retained, and the next objective is formulated. Backbones are Qwen3.5-4B (AREX-Turbo) and Qwen3.5-122B-A10B (AREX-Base).
Results
The paper evaluates on six benchmarks spanning four regimes: deep research (BrowseComp, DeepSearchQA), agentic completion (GAIA, xbench-2510), broad-coverage retrieval (WideSearch English), and tool-augmented high-level reasoning (HLE with tools). Reported metrics are Item-F1 (WideSearch), F1 (DeepSearchQA), accuracy elsewhere.
The confidence calibration analysis is central to the design: because the outer loop gates acceptance on s^{(t)} > \tau, the confidence signal must be discriminative between correct and incorrect outputs. Figure 3 shows the normalized distributions.
Meaningful separation is what allows the outer loop to preferentially refine wrong provisional answers rather than expending budget on ones already correct.
Limitations and open questions
The provided text lacks concrete per-benchmark numbers in the excerpted sections, so we cannot verify the magnitude of improvement over strong baselines (e.g., ReAct-style browsing agents, search-augmented o1-class models) from these excerpts alone. Several methodological questions remain open. First, the confidence score is model-generated; robustness to distributional shift outside the synthetic constraint-based training tasks is untested — real research queries rarely decompose so cleanly into n independent verifiable constraints. Second, the “trajectory recoverability” decision is a learned meta-judgment; the cost of a false-negative restart (throwing away a nearly correct trajectory) versus a false-positive continuation is not quantified. Third, the autonomous context-update tool is trained end-to-end but its compression fidelity — whether verified evidence remains faithfully retrievable after multiple compression cycles — needs ablation. Finally, RSI here is within a single query; the framework does not (yet) close the loop across queries so that the agent’s policy improves over deployment.
Why this matters
Constraint-wise verification is a genuinely cheaper primitive than end-to-end discovery, and AREX operationalizes that asymmetry with a concrete state-preservation mechanism rather than treating self-improvement as a vague prompting pattern. If the calibration and recovery decisions hold up outside synthetic constraint tasks, the bi-level design plus learned context compression is a reusable blueprint for long-horizon agentic systems beyond browsing.
Source: https://arxiv.org/abs/2607.21461
Self-Supervised Learning of Structured Dynamics from Videos
Video representation learning typically conflates two distinct sources of frame-to-frame change: ego-motion (camera) and scene dynamics (object motion). Single-token latent-action models and dense transition tokens both entangle these factors, which hurts downstream discriminability when the goal is to reason about object motion invariant to camera motion (or vice versa). The paper asks whether this decomposition can be recovered by a lightweight predictor operating on frozen features of a pretrained image ViT, without training a video encoder from scratch.
Setup and structured prediction
Let \mathcal{E} be a frozen ViT. For each frame x_t, features are
f_t = \mathcal{E}(x_t) \in \mathbb{R}^{H\times W\times D}.
SDM predicts f_t from f_{t-1} in feature space. Crucially, the model is non-causal in its access to f_t when extracting a transition token, but autoregressive over time in its motion tokens. Prior latent-action approaches (Genie-style) squeeze all inter-frame change into a single low-rank token; CroCo/SiamMAE-style cross-view conditioning uses a dense target-view feature. Neither imposes structure on the transition itself.
SDM’s core assumption is that temporal change decomposes into a dominant low-dimensional factor (usually camera or one global scene motion) and a residual accounting for the remainder. It therefore extracts two motion tokens per transition:
- a primary token p_t from (f_{t-1}, f_t), which produces a primary-compensated feature map f'_{t-1 \to t};
- a residual token r_t that predicts the leftover error against f_t.
Both tokens are recurrent across time; the predictor is trained by feature-space regression to f_t. The token bottleneck is what forces the split: since p_t is a small vector that must survive the recurrence and explain most of f_t - f_{t-1}, it preferentially latches onto the global, low-dimensional cause of change, leaving spatially localized independent motion to r_t.
Training data and weak supervision
Training mixes self-supervised prediction on real videos with weakly labeled synthetic data. The corpus is:
- 180k Kubric sequences, split evenly between static-scene (moving camera only) and dynamic-scene videos; the dynamic half is further split evenly between moving- and static-camera settings.
- ~170k SSv2 clips and ~4k DL3DV clips, both without labels.
Kubric contributes scene-level binary labels (camera-static, scene-static) used as weak supervision to disambiguate which motion factor lands in p_t vs. r_t. Real videos provide only the self-supervised feature-prediction signal. This mixture matters: without the Kubric weak labels, the two tokens have a permutation symmetry (either could take camera or object motion in different clips), and the split becomes clip-dependent rather than semantically stable.
Stage-wise behavior
The two-stage compensation is directly visible in feature-space residuals.
On a DAVIS2017 sample, the primary stage removes background/edge motion attributable to the camera, but locally increases error at an independently moving foreground object — a signature that p_t is committed to a single global explanation. The residual stage then cleans up the object region. This is the qualitative behavior one would want from a factored dynamics model.
ProbeMotion evaluation suite
The paper introduces ProbeMotion, a linear-probe benchmark that separately targets camera and object motion:
- Kubric (cam.+obj.): 15k train / 5k test synthetic clips, 4 frames.
- DL3DV: 3.5k train, probing camera motion, 5 frames.
- CameraBench: 60/30 videos, camera motion, 4 frames.
- Static-camera DAVIS2017 and static-camera YouTubeVOS (built by filtering with VGGT camera estimates and using mask-centroid displacement as an object-motion target): 3.5k train (DAVIS) and 1k / 20k for YouTubeVOS, 4–5 frames, probing 2D object displacement.
- SSv2-110k: motion-heavy action classification, 7 frames.
Static-camera subsets are constructed by thresholding VGGT-estimated camera motion, giving a clean setting for isolating object dynamics. The suite thus covers controlled synthetic joint motion (Kubric), pure camera (DL3DV, CameraBench), pure object (static DAVIS/YTVOS), and mixed real semantics (SSv2). Probing targets are camera-motion class, object-displacement regression/classification, or action class, depending on dataset.
Limitations and open questions
The provided sections describe the setup but not final headline numbers; the strength of the primary/residual decomposition ultimately depends on Kubric’s weak labels, and it is unclear how the split behaves on scenes where “dominant motion” is genuinely ambiguous (multiple independently moving objects with a static camera, or camera and object motions of similar magnitude in feature space). The predictor operates entirely in frozen ViT feature space, so anything the backbone discards — fine-grained motion, small-object translations below patch resolution — is unrecoverable. The recurrent motion tokens are bottlenecked to force structure, but the paper as excerpted does not quantify how token dimensionality trades off primary/residual purity. Finally, evaluation is via linear probing; whether these tokens transfer to dense tasks (tracking, flow, segmentation) is not addressed here.
Why this matters
Factoring camera from object motion is a long-standing desideratum for video representations, and doing it on top of frozen image ViTs — rather than training a bespoke video encoder — is a cheap, composable recipe. ProbeMotion also fills a real gap: most video benchmarks conflate the two motion sources, making disentanglement claims hard to falsify.
Source: https://arxiv.org/abs/2607.21576
LLMs Get Lost in Evolving User Intent
Problem
Standard LLM evaluation assumes a user who states a complete, well-formed task in a single turn. Real interactions look nothing like this: users start vague, add constraints as they think, retract earlier requirements, and occasionally pivot to a related-but-different goal mid-conversation. The paper asks a direct empirical question: given that a model can solve task T when its full specification is presented atomically, can the same model still solve T when the specification is spread across turns, partially revised, or partially overwritten?
This matters because deployment increasingly assumes an “agent” reading iterative user messages, not a prompt-completion oracle. If intent-tracking degrades sharply under realistic multi-turn dynamics, then single-turn benchmark leaderboards overstate deployed capability.
Method
The authors propose a framework that converts existing single-turn benchmarks into multi-turn “evolving intent” conversations while preserving the original grading protocol, so no new annotation is needed. Formally, given a task with specification S = \{c_1, \dots, c_k\} (a set of constraints, sub-requirements, or clauses) and evaluator E(y, S) that scores an output y, they generate a conversation trajectory
U_1, A_1, U_2, A_2, \dots, U_T, A_T
where each user turn U_t reveals a subset S_t \subseteq S under one of several dynamics:
- Incremental disclosure: S_t strictly extends S_{t-1}, with \bigcup_t S_t = S.
- Revision: some c_i \in S_{t-1} is replaced by a modified c_i' at turn t, so the effective spec at turn t is (S_{t-1} \setminus \{c_i\}) \cup \{c_i'\}.
- Redirection: at some turn t^\ast, a subset of constraints is overwritten by a related but partially incompatible set, simulating a mid-conversation goal shift.
The final assistant output A_T is graded against the effective final spec using the original evaluator E, isolating the model’s ability to maintain a coherent, up-to-date internal representation of intent. Because E is unchanged, absolute scores in the evolving setting are directly comparable to the single-turn baseline on the same benchmark. The user side is simulated (an LLM instructed to reveal S piecewise according to the chosen dynamic), which lets the authors run controlled sweeps over dynamics, number of turns, and revision timing.
Key experimental knobs:
- Task suite spans multiple task families (instruction-following with verifiable constraints, code, and reasoning), each with clause-decomposable specifications.
- Model families are evaluated in both the original single-turn setting and the evolving-intent setting with identical grading.
- Ablations vary (i) whether revisions occur, (ii) placement of revisions early vs. late, and (iii) turn budget.
Results
The central empirical finding is that strong single-turn performance does not carry over. Across model families and task types, moving from the fully-specified single-turn setting to the evolving-intent multi-turn setting produces substantial accuracy drops. The degradation is consistent enough that the authors describe it as a phenomenon rather than a model-specific artifact: whichever model tops the static leaderboard is not guaranteed to top the evolving-intent version of the same benchmark.
Two mechanistic patterns emerge from the ablations:
Revisions are the dominant failure mode. Pure incremental disclosure (no retractions) causes moderate degradation, largely explained by the model committing early to a partial solution and failing to integrate later constraints. Once revisions or redirections are introduced, the drop is markedly larger, indicating that models tend to conflate the old and new specification rather than fully overwrite the revised clause.
Early commitment compounds. When the model produces a substantive A_t before the full spec is revealed, subsequent turns rarely fully repair the trajectory; errors introduced by acting on an incomplete spec persist even after the missing constraints arrive. This is consistent with a “lost in the middle”-style effect but on the intent representation rather than retrieval: later contradicting information does not reliably displace an earlier committed interpretation.
The paper frames both effects as evidence that current LLMs approximate intent via accumulating context rather than by maintaining a revisable belief over user goals.
Limitations and open questions
Several caveats are worth flagging. The user is itself an LLM following a scripted disclosure policy; while this enables controlled reuse of existing evaluators, real users are noisier, use pronouns and ellipsis more aggressively, and sometimes signal revisions ambiguously. The framework also inherits any weaknesses of the underlying evaluators E: if E scores partial constraint satisfaction leniently, some intent-tracking failures may be masked. Finally, the paper documents the gap but does not resolve it — the diagnosis (early commitment, revision conflation) suggests remedies such as explicit intent state tracking, delayed answering, or training with revision-heavy trajectories, but these interventions are not evaluated here.
Open questions include whether RL on multi-turn revision trajectories can close the gap without harming single-turn performance, whether explicit “current spec” scratchpads help, and how the degradation scales with model size and long-context training. It also remains unclear whether the failure is fundamentally representational or merely a decoding-time behavior (over-eager commitment) that prompting can mitigate.
Why this matters
Static single-turn benchmarks are the primary signal driving model development, yet the paper shows that ranking on those benchmarks does not predict behavior under the interaction pattern actual users produce. If intent-tracking under revision is the binding constraint for agentic deployment, then both evaluation and training pipelines need first-class support for evolving specifications rather than treating multi-turn as a decorative wrapper around single-turn tasks.
Source: https://arxiv.org/abs/2607.20734
SANA-Video 2.0: Hybrid Linear Attention with Attention Residuals for Efficient Video Generation
Problem
Video DiTs scale poorly because self-attention over spatiotemporal token grids is O(N^2) in sequence length, and at 720p/8s the token count reaches ~19K per frame batch. Pure linear attention fixes the asymptotic cost but is rank-deficient: its kernel-feature Gram matrix cannot recover the full-rank token mixing that softmax provides, which degrades long-range consistency and prompt adherence. Prior work has typically linearized pretrained softmax DiTs post-hoc, inheriting distributional mismatch. SANA-Video 2.0 asks whether a hybrid attention stack, trained from scratch, can match full-softmax quality while retaining linear-attention scaling, at model scales up to 14B.
Method
The backbone is a video DiT operating on LTX-VAE 2.3 latents with per-layer cross-attention into Gemma-2-2B-IT text features, trained with flow matching. Two mechanisms constitute the contribution.
Hybrid Linear–Softmax Attention. Layers alternate between gated linear attention (GLA) and gated softmax attention at a 3:1 ratio, i.e., 25% of layers act as softmax “anchors.” GLA layers give O(N)-dominated mixing; the periodic softmax layers restore full-rank token interactions that a pure linear stack cannot express. The 25% ratio was selected by reduced-resolution proxies (depth-28, width-3072, 256p/81f), reading validation MSE per-timestep because the scalar random-t mean masks 3× variation across the noise axis.
Block Attention Residuals (AttnRes). Layers are grouped into eight-layer blocks. A shared-query router aggregates the current input with completed summaries from earlier blocks and feeds this into the self-/cross-attention branch of subsequent linear layers. This lets linear layers reuse refreshed anchor features from downstream in the block hierarchy, raising the effective rank of deep-layer representations by ~12%.
Each hybrid layer applies AttnRes routing first into the attention branch (self + cross), then into a SwiGLU FFN, with AdaLN-style modulation inside each branch and a final aggregation before the output head. The local path is convolution-free—removing SANA-Video 1’s temporal-convolution FFN saves 20–29% overhead at scale and keeps the attention ratio as the sole sequence-scaling knob. Two instantiations share the design: 5B (32 layers, width 2560) and 14B (40 layers, width 4096, 14.25B params trained on 384×B200).
The training recipe is treated as part of the method. A six-stage funnel scores clips on separated quality and motion axes (rather than a collapsed aggregate) to avoid selecting for clean-but-static footage. The recipe passes clips through pre-training, continual training, SFT, and preference-based post-training combining DPO and ReFL, with resolution/duration curriculum and quantized motion descriptors conditioning captions.
Results
On VBench with 81-frame outputs, the 5B hybrid model scores 84.30 total (85.61 quality, 79.05 semantic), placing above HunyuanVideo 13B (83.43), Wan 2.1 14B (83.69), Cosmos-3 Nano 16B (83.13), and Wan 2.2 A14B MoE (84.23), and marginally below Bernini-R 14B MoE (84.64). Quality subscore (85.61) is the highest among reported models. At 40 sampling steps, 480p generation runs in 13.2s on a single H100.
At 720p/8s (736×1280×193, 19.3K tokens) on B200, the deployment pipeline compresses end-to-end latency stepwise: 62.65s baseline → 30.74s with kernel/execution fusion (2.04×) → 20.89s after residual reuse skipping 17 of 50 steps (3.00×) → 17.52s with sparse attention restricted to the softmax anchors (3.58×). On H100 the same stack goes 95.08s → 33.43s (2.84×). Since softmax anchors dominate module time at long sequences, sparsifying only those layers is the natural intervention.
The scaling curves show the hybrid layer’s linear regime widens the gap over full-softmax as either resolution or clip length grows; the crossover with 50% softmax is unfavorable, motivating the 25% choice.
Limitations and open questions
The hybrid ratio and AttnRes block size were selected jointly with the recipe via proxy studies, not fully ablated at 5B/14B scale, so it is unclear how much of the quality gain comes from architecture versus data funnel or DPO+ReFL post-training. Diffusion-cache step skipping and anchor sparsification are approximations whose fidelity is validated only qualitatively (Figure 8) rather than through VBench under acceleration. The semantic subscore (79.05) trails MoE competitors (Bernini-R 82.49, SANA-Video 2B linear 81.46), suggesting the hybrid may be underexploiting text conditioning despite per-layer cross-attention. Finally, from-scratch training at these scales is expensive; whether the AttnRes mechanism can be grafted onto pretrained softmax DiTs without the 12% effective-rank gain collapsing is untested.
Why this matters
SANA-Video 2.0 provides a concrete recipe for training video DiTs from scratch with a mostly-linear attention stack that matches or beats full-softmax models at 3–4× the parameter count, and it identifies periodic softmax anchors plus cross-block residual routing as the mechanism that closes the rank gap. The engineering result—720p/8s in 17.52s on one B200—brings long-form generation into single-GPU territory without exotic sparsity outside the anchor layers.
Source: https://arxiv.org/abs/2607.21553
Sample-Efficient Learning from Agent Experience
Problem
LLM agents deployed in real environments (software engineering, scientific experimentation, human-in-the-loop settings) face a hard budget on environment interactions: each rollout may involve running a test suite, executing an experiment, or querying a human. Two paradigms exploit collected experience differently. In-context learning (ICL) is extremely sample-efficient — an agent conditions on its own trial-and-error trajectories and improves immediately — but the gain evaporates the moment those trajectories fall out of context. Context distillation, conversely, internalizes contextual information into weights, but naive application to agent histories tends to require substantial extra rollouts, defeating the purpose. The paper formalizes the gap as Experience Distillation: given a fixed pool of collected interaction trajectories, produce a model whose non-in-context behavior matches the in-context-augmented behavior, without any further environment queries.
Why this matters concretely: prior work on distilling instructions or reasoning traces assumes cheap or unlimited on-policy sampling. In agent domains where each interaction has non-trivial cost (compilation, evaluation harnesses, API tokens for external tools, human raters), the sample budget for distillation itself is the bottleneck. Standard SFT on the collected trajectories — the obvious baseline — turns out to recover almost none of the ICL gains.
Method
The setup: an agent collects a batch of trajectories \tau_i by interacting with an environment (potentially using ICL from earlier trajectories in the batch). Let \pi_{\text{ICL}}(a \mid s, \mathcal{C}) denote the policy conditioned on retrieved experience \mathcal{C}, and \pi_\theta(a \mid s) the target weight-internalized policy. Experience Distillation minimizes a divergence between the two on states drawn from the collected experience, without producing new environment interactions:
\mathcal{L}_{\text{ED}}(\theta) = \mathbb{E}_{s \sim \mathcal{D}}\left[ D_{\text{KL}}\big(\pi_{\text{ICL}}(\cdot \mid s, \mathcal{C}) \,\Vert\, \pi_\theta(\cdot \mid s)\big) \right]
Crucially, the target distribution \pi_{\text{ICL}} is computed by re-running the base model with \mathcal{C} in context on the existing states — a within-model, offline operation. Compared to SFT, which trains \pi_\theta on the observed actions a_t from \tau_i directly, Experience Distillation trains on the full teacher distribution induced by ICL, which contains the corrective signal that ICL provides over the raw behavior policy. This is the essential asymmetry: the collected actions were often suboptimal (they were part of trial-and-error), whereas the ICL-conditioned distribution reflects what the model would do having seen those trials as evidence.
The recipe uses no additional environment steps beyond the initial experience collection. Trajectories serve dual duty: they populate \mathcal{C} as retrieved context, and they provide the state distribution \mathcal{D} on which the teacher/student divergence is evaluated.
Results
Evaluation spans two domains: 749 curated software-engineering tasks and six text-adventure games. The headline numbers:
- Experience Distillation retains at least 64.8% of the gains that ICL provides over the base agent, averaged across both domains.
- Direct SFT on the same collected experience retains only 3.8% of ICL gains — nearly two orders of magnitude worse.
- Against classical RL baselines, the pipeline (ICL during collection + Experience Distillation) matches their performance while using at least 9.6× fewer environment interactions.
The SFT-vs-ED gap is the most informative result. Both methods see identical trajectories; the difference is entirely in the training target. SFT imitates the behavior policy, which for a trial-and-error agent includes many failed and exploratory actions. Experience Distillation instead imitates the counterfactual policy the base model would follow if it could retrospect on those trials — extracting the lesson rather than the behavior. The 64.8% retention figure indicates that most of what ICL “knows” is representable in the base model’s weight space and can be surfaced by matching the induced action distribution.
The 9.6× sample-efficiency multiplier versus RL is consistent with the general observation that on-policy RL wastes samples exploring; here the exploration is done once by an ICL-augmented agent, and the resulting competence is compressed into weights.
Limitations and open questions
Several issues are worth flagging. First, the method’s ceiling is bounded by what ICL itself can extract from the base model — Experience Distillation cannot teach genuinely new skills absent from the pretraining prior, only surface latent ones. Second, the KL target requires the teacher \pi_{\text{ICL}} to be evaluable on the same states as the student; for very long horizon tasks where the retrieved context \mathcal{C} approaches or exceeds the context window, the teacher computation becomes expensive or infeasible. Third, the paper’s ~35% residual gap to full ICL is unexplained: it could reflect optimization limits, capacity limits of the student policy head, or genuinely context-dependent behaviors that resist weight internalization. Fourth, the domains — SWE tasks and text adventures — are both symbolic and language-heavy; extension to embodied or continuous-control agents where the teacher’s action distribution is not naturally represented as token logits is non-obvious.
An open question is compositionality across distillation rounds: can experience be repeatedly collected and distilled to yield monotonic improvement, or does the process saturate at the base model’s ICL ceiling? The RL comparison also invites a hybrid: use Experience Distillation as a warm start for policy-gradient methods, potentially inheriting sample efficiency while breaking the ICL ceiling.
Why this matters
Experience Distillation identifies a clean mechanistic reason why SFT on agent trajectories underperforms: imitating behavior is not the same as imitating the retrospective policy that behavior induces. Framing distillation as matching the ICL-conditioned distribution rather than the observed actions offers a practical recipe for turning expensive interaction data into weight-level competence at nearly no additional environment cost.
Source: https://arxiv.org/abs/2607.21051
Predictive Divergence Masks for LLM RL
Problem
PPO-style RL for LLMs uses two trust-region tests on each sampled token: a proximity criterion (is the training policy \pi_\theta too far from the behavior policy \pi_b?) and a direction criterion (would the next update push it further away?). Both are conventionally computed from the sampled-token importance ratio r_t = \pi_\theta(a_t|s_t)/\pi_b(a_t|s_t): proximity via |r_t - 1|, direction via \operatorname{sign}(\hat A_t(r_t-1)).
DPPO (Qi et al., 2026) already upgraded the proximity criterion to a distributional divergence D_t between \pi_b and \pi_\theta over the full vocabulary (in practice, a truncated top-K KL, since production rollout engines only expose top-K logprobs). But its direction criterion still comes from PPO’s single-sample ratio. This paper’s observation: when the trust region is defined by a distributional quantity D_t, the ratio-based sign can disagree with \operatorname{sign}(\Delta D_t), so tokens the mask “keeps” may in fact push the policy further outside the trust region.
Method
The fix is to replace the direction test with the first-order change of the same divergence used by the proximity test. Let \pi_\eta be the training policy after a logit step of size \eta along the surrogate gradient. Then
D_t(\pi_\eta) = D_t + \eta \cdot \left.\frac{d}{d\eta} D_t(\pi_\eta)\right|_{\eta=0} + O(\eta^2),
and the mask is driven by the sign of the first-order coefficient. A token outside the trust region (D_t > \delta) is clipped when this coefficient is positive (update would grow D_t) and kept when it is negative (update would shrink D_t).
For discrete softmax policies the directional derivative decomposes in closed form into (i) a local term at the sampled token that reproduces the ratio-based sign, and (ii) a global term arising from softmax coupling across the full vocabulary. Because rollout engines only return top-K logprobs, the paper estimates the global term from two tail models: an aggregated-tail estimator (Eq. 10) that lumps the residual 1-\sum_{i \le K} \pi(i) mass into a single bucket, and a uniform-tail estimator (Eq. 11) that spreads it uniformly over the remaining vocabulary. Eq. 12 shows the two differ only by a small correction, predicting near-identical behavior — which is what is observed empirically.
The resulting predictive divergence mask is a drop-in replacement for the direction criterion in DPPO-style objectives; no additional network passes are needed since everything is computed from the same top-K statistics the rollout already emits.
Results
Training uses filtered DAPO-Math-17k (~13k problems); evaluation is avg@16 on AIME24 and AIME25. Backbones are Qwen3-4B-Base, Qwen3-8B-Base, and Qwen3-30B-A3B-Base under two FP8 modes (rollout-only and E2E), giving four settings. The primary baseline is DPPO-TopK-KL with K=20; GRPO with clip-higher (\epsilon_{\text{low}}=0.2, \epsilon_{\text{high}}=0.28) is included as a ratio-clipping reference.
At the recommended \delta = 0.15, GRPO clip-higher collapses in both Qwen3-30B-A3B-Base FP8 settings, consistent with the intuition that ratio clipping alone is fragile when FP8 widens the rollout/training numerical gap. All divergence-based methods remain stable. Within that family, both predictive divergence masks — aggregated-tail and uniform-tail — dominate DPPO-TopK-KL across all four settings. Because the only difference from DPPO-TopK-KL is the direction criterion (same top-K KL proximity, same \delta), the improvement isolates the value of making the direction test distributional. The two tail estimators track each other closely throughout training, confirming the small-correction prediction of Eq. 12.
At \delta = 0.05 the trust region is overly restrictive and all methods degrade, but the predictive masks still beat DPPO-TopK-KL, indicating better robustness to the \delta hyperparameter.
The mechanistic check in Figure 3 restricts attention to tokens outside the trust region (D_t > \delta) on which the two criteria disagree, and measures the “unsafe-keep” rate — fraction of kept tokens whose divergence actually increases after the update (\Delta D_t > 0). The divergence-based criterion has a substantially lower unsafe-keep rate than the ratio-based one, directly supporting the central claim that its sign is better aligned with the realized \Delta D_t.
Limitations
The predictive test is a first-order local approximation at a single token. Real optimizer steps aggregate gradients over all tokens in a batch, and the resulting parameter update introduces cross-token interactions through the shared backbone that the per-token directional derivative ignores. The top-K tail models are also heuristic; while the two variants agree here, this may not hold when K is very small or when the tail distribution is heavy. Finally, evaluation is limited to math reasoning (AIME24/25) and to Qwen3 backbones; behavior on non-math RLHF regimes with denser reward is untested.
Why this matters
Once you move the trust-region proximity test from a sampled ratio to a distributional divergence, keeping PPO’s ratio-based direction test is inconsistent — and, as Figure 3 shows, empirically produces mask decisions that let D_t grow. Making the direction criterion track the same divergence recovers stability under FP8 rollout/training mismatch, where GRPO-style ratio clipping collapses, at essentially zero additional cost since everything is computed from the top-K logprobs the rollout already returns.
Source: https://arxiv.org/abs/2607.10848
TableVerse: A Large-scale Tabletop Dataset with Real-world Grounded Layouts for Generalizable Manipulation
Problem
Manipulation policies that generalize across scenes need training data whose spatial distribution matches real tabletops: dense clutter, plausible object co-occurrence, correct metric scale, and physically valid contacts. Existing synthesis pipelines either (i) hallucinate layouts from text via an LLM, which produces implausible geometry and unrealistic co-occurrence statistics, or (ii) use procedural generators that are too sparse and stereotyped. Real robot data is expensive to scale. TableVerse sidesteps both by reconstructing simulation-ready tabletop scenes directly from single unstructured internet images — a Real2Sim pipeline whose layouts are deterministic projections of real photographs rather than samples from a generative prior.
Method
The pipeline (Fig. 2) is a four-stage perception-to-physics workflow.
1. Instance extraction. Rather than chain an MLLM with GroundingSAM-v2 (which compounds detection error), the authors use Seed-1.8 for open-vocabulary detection directly on the input image. Detections are typed as either regular objects or composite objects (a container plus nested contents); non-meshable substances such as liquids fall back to being treated as single entities. For clusters of interior items the detector emits one representative box plus an instance count n, avoiding per-item box ambiguity. Boxes are passed to SAM2 for instance masks.
2. Composite asset deconstruction. Container and contents are reconstructed as separate meshes by SAM3D and dropped into an isolated MuJoCo scene for a brief free-fall settle (Fig. 3). This preserves independent rigid-body properties for each internal item — critical if a downstream task requires picking a single object out of a bowl — while still yielding a physically valid resting configuration.
3. 6-DoF pose registration. Depth Anything 3 provides a metric point cloud from the single view. The segmented table/floor mask defines a gravity-aligned frame via a plane fit; this transform is applied to the global point cloud before per-object registration, so all meshes share a physically consistent up-axis. A coarse-to-fine registration then places each SAM3D mesh into the scene at metric scale.
4. Layout-Consistent Collision Rectification (LCCR). Monocular reconstruction produces meshes whose alignment noise causes interpenetration when instantiated in MuJoCo. LCCR resolves penetrations while constraining displacements to preserve the macroscopic layout — the constraint that distinguishes this pipeline from generic collision resolution, which would otherwise drift the scene toward an arbitrary local minimum.
Convex decomposition and validation. All meshes are passed through CoACD for approximate convex decomposition to keep MuJoCo contact stable. Multi-view orthographic renders are then scored by Gemini 2.5 Pro for scene plausibility, category consistency, and confidence, with task instructions generated in the same pass.
Task-conditioned trajectory synthesis. Given a validated digital twin, the pipeline produces collision-free pick-and-place demonstrations in joint space from high-level task specifications (e.g., “place the mug into the tray”). This yields interaction data paired with each scene rather than static assets alone.
Scale and quantitative results
The released TableVerse-100K contains 100,000 physically consistent scenes, roughly 10^6 distinct object instances, and more than 35,000 semantic categories (Fig. 1). Every scene passes MLLM validation and MuJoCo stability checks, and each is paired with generated manipulation trajectories. Compared to procedurally generated benchmarks — which typically saturate at 10^2–10^3 categories — the category count is one to two orders of magnitude larger, driven by the diversity of the underlying in-the-wild image sources rather than a fixed asset catalog.
Limitations and open questions
Several caveats follow directly from the design choices. First, single-view reconstruction inherits the failure modes of monocular depth and SAM3D: heavily occluded objects and thin structures (utensils, wires) will have poor backside geometry, and the pipeline’s convex decomposition further smooths concavities that matter for grasping. Second, non-meshable substances are collapsed into rigid entities, so liquid-pouring and granular manipulation are out of scope. Third, LCCR preserves the macroscopic layout but cannot correct systematic depth-scale bias from Depth Anything 3; absolute metric errors on distant objects will propagate to contact geometry. Fourth, validation is Gemini-based rather than human — the false-negative rate on subtle physical implausibilities (floating objects behind occluders, misaligned support surfaces) is not reported. Finally, the paper does not present downstream policy-transfer numbers in the provided sections; the empirical claim that TableVerse-100K improves sim-to-real generalization over prior synthetic corpora needs external verification once policy training results are available.
Why this matters
Shifting tabletop scene synthesis from “imagine a layout” to “reconstruct one that already exists” grounds the training distribution in the joint statistics of real human environments — object co-occurrence, clutter density, and support relations that generative layout models systematically miss. If the pipeline’s automation holds, scaling from 100K to 10^7 scenes is a matter of ingesting more images, which is the first plausible route to internet-scale manipulation training data with physically valid contacts.
Source: https://arxiv.org/abs/2607.21017
Hacker News Signals
Flux 3
Black Forest Labs released Flux 3, the next iteration of their image generation model family. The release maintains the flow-matching backbone from the original Flux.1 architecture but pushes further on prompt adherence, text rendering, and photorealism. Technically, the Flux line uses a rectified flow formulation where the forward process linearly interpolates between noise and data, and the model learns a velocity field v_\theta(x_t, t) that is simpler to train than the DDPM epsilon-parameterization. Flux distinguishes itself architecturally by using a hybrid transformer design with separate streams for text and image tokens that cross-attend before being merged into a unified representation for the later layers — a departure from standard DiT which concatenates modalities from the start. Flux 3 reportedly improves on the prior Flux.1 [pro] on structured text generation inside images (a notoriously hard task requiring the model to lay out glyphs spatially) and on fine-grained instruction following for complex compositional prompts. The model is offered in tiered API SKUs. On internal benchmarks, it outperforms Flux.1 [pro] and claims competitive positioning against Imagen 3 and DALL-E 3 on human preference evaluations, though no third-party reproducible benchmark numbers are given in the blog. The architecture retains the guidance-distilled variant structure (a separate “dev” distilled model for lower-step inference), keeping the inference cost practical. Limitations: the evaluation methodology is opaque, all numbers are self-reported, and no model weights are released for this tier. Whether the gains over Flux.1 [pro] are primarily from scale, data curation, or architectural changes is not disclosed.
Source: https://bfl.ai/blog/flux-3
Flux 3 X Mimic: The Next Generation of Video-Action Models
Mimic is Black Forest Labs’ video generation model, and this post announces Flux 3 X Mimic, a joint image-video system focused on “action” — meaning the model is trained to produce temporally coherent motion given an image or text prompt. The technical substance centers on extending the rectified flow framework from static image generation into the temporal domain. Rather than independently sampling frames, the model operates on a spatiotemporal latent where temporal consistency is enforced through 3D attention or causal temporal attention mechanisms (the blog is not fully explicit, but the architecture follows the pattern established by video diffusion transformers like CogVideoX or Open-Sora). The “X Mimic” designation implies the Flux 3 image model backbone is used as a spatial prior, with temporal layers fine-tuned or added on top — a common efficient strategy that leverages existing high-quality spatial representations. Key claimed properties: high motion fidelity, prompt-driven action control (e.g., “a person throwing a ball” produces plausible physics), and consistency of identity across frames. The “action model” framing suggests training data or loss functions specifically targeting dynamic scenes rather than static vignettes. This is relevant because most video diffusion models trained on general web video tend to produce slow, drift-heavy clips; action-focused training data and potentially optical-flow-guided losses can sharpen dynamic coherence. No architecture diagrams, training details, or public weights are provided. Quantitative comparisons against Sora, Kling, or Runway Gen-3 are absent. The primary open question is how temporal length scales — most such models degrade significantly beyond a few seconds.
Source: https://bfl.ai/blog/flux-3-mimic
Meta Garbage Collection: Using OCaml’s GC to GC Rust
This post describes a technique for managing Rust memory lifetimes by delegating ownership of certain allocations to OCaml’s garbage collector. The context is interop between Rust and OCaml via the ocaml-rs or similar FFI bindings, where Rust creates values that need to remain live as long as OCaml holds references to them. The core idea: wrap a Rust heap allocation inside an OCaml custom block. OCaml custom blocks allow registering a finalize callback in C that is called when the GC collects the block. By storing a raw pointer (or a Box<T>) inside a custom block’s data payload and registering a finalizer that calls Box::from_raw to drop it, you effectively make OCaml’s tracing GC responsible for determining when the Rust value is no longer reachable from OCaml code. This sidesteps the need to manually track lifetimes across the FFI boundary. The “meta” framing refers to using a GC that the Rust code itself does not own as a foreign memory manager. Mechanically: the OCaml custom block carries a pointer-sized field; the finalizer is a C function pointer stored in a static struct custom_operations; OCaml’s minor/major heap promotion rules mean the finalizer fires on major collection. Gotchas are significant: the finalizer runs on OCaml’s GC thread, so Rust destructors called from it must be thread-safe and must not touch OCaml values (risk of re-entrant GC). Also, OCaml’s GC is not aware of cycles that span the two heaps, so mixed-heap cycles leak. The technique is genuinely useful for binding Rust libraries into OCaml runtimes without requiring explicit lifetime annotations on every returned value, but the safety invariants require care.
Source: https://soteria-tools.com/blog/meta-garbage-collection
Making
Beej Jorgensen (of “Beej’s Guide” fame) writes a measured technical post on AI-assisted coding, specifically examining what it means to “make” something when a large portion of the implementation is generated. The argument is not philosophical hand-wringing but a practical taxonomy: he distinguishes between (1) using AI as a code search/autocomplete accelerator, where the programmer retains full understanding of the output; (2) using AI to generate code the programmer could write but chooses not to, with spot-checking; and (3) using AI to generate code the programmer could not independently write or verify. The third category is where authorship and responsibility questions become non-trivial, not for moral reasons but for engineering ones — a programmer who cannot read the generated output cannot debug it, cannot reason about its failure modes, and cannot maintain it. He grounds this in concrete examples from his own use of LLMs for C and systems code. The technical concern is real: LLMs produce syntactically plausible but semantically subtle bugs, especially around memory safety, integer overflow, and API contract violations, that require domain knowledge to catch. His implicit recommendation: treat AI output the same way you treat code from an external dependency or a junior contributor — read it, test it, own it. The post resonates on HN partly because it refuses both “AI is useless” and “AI replaces programmers” framings and instead asks the operational question: what verification discipline does AI-assisted development require? No experiments, no benchmarks — this is a practitioner essay, but technically grounded.
Source: https://beej.us/blog/data/ai-making/
DARPA, U.S. Air Force Fly AI-Controlled F-16
DARPA’s Air Combat Evolution (ACE) program completed flights of an AI agent controlling a full-scale F-16 (designated X-62A VISTA) in within-visual-range combat maneuvering against a crewed F-16. This is a milestone because prior AI dogfighting demonstrations (e.g., the 2020 AlphaDogfight trials) were simulation-only. The technical approach under ACE uses a hierarchy of learned policies trained in simulation with domain randomization, then transferred to the real aircraft via a safety layer that monitors for constraint violations (structural load limits, altitude floors, proximity bounds). The AI agent operates at the flight control level — commanding roll rate, pitch rate, throttle — not at a waypoint planning level, meaning the neural policy directly maps sensor state (relative position, velocity, angle-of-attack) to control surface commands at high frequency. The sim-to-real gap in high-performance aircraft is severe: F-16 aerodynamics at high angle-of-attack involve nonlinear flow separation, and sensor noise at high g-loads differs from simulation. DARPA addressed this through iterative hardware-in-the-loop testing and by keeping a safety pilot in the back seat able to override. The program’s open question is not whether AI can fly aggressive maneuvers — it demonstrably can — but whether the policy generalizes to adversarial edge cases beyond the training distribution, and how certification of such systems would work under FAA/military airworthiness standards. The latter is likely the binding constraint on operational deployment, not the ML.
Source: https://www.darpa.mil/news/2026/darpa-us-air-force-fly-ai-controlled-f-16
Show HN: Palmier Pro – Open-Source macOS Video Editor Built for AI
Palmier Pro is a native macOS video editor written primarily in Swift/SwiftUI that exposes AI editing operations as first-class timeline actions. The GitHub repo shows it uses AVFoundation for video I/O and compositing, which is standard on macOS and gives access to hardware-accelerated H.264/HEVC encode/decode via VideoToolbox. The “built for AI” claim is mechanical: the editor integrates with external model APIs (Replicate, local inference via llama.cpp or similar) to perform operations like transcript-driven cut detection, auto-captioning via Whisper, background removal via segmentation models, and prompt-driven clip search over an embedded vector index of frame descriptions. The architecture separates the timeline engine (pure Swift, AVFoundation composition) from an inference bridge layer that calls models asynchronously and writes results back as timeline annotations or effects. Frame descriptions for vector search are generated by a vision-language model (likely CLIP or a BLIP-variant) run over keyframes. The vector store appears to be a simple local SQLite-backed approximate nearest neighbor index rather than a full vector database. Being open source (MIT license) and native macOS rather than Electron is a meaningful technical decision — it avoids the ~200ms input latency typical of Electron-based editors and integrates naturally with macOS accessibility and media APIs. Limitations: the AI integrations rely on paid API keys for most high-quality operations; local inference is available but slow without an M-series neural engine integration. The codebase is early-stage, with several listed features marked as in-progress.
Source: https://github.com/palmier-io/palmier-pro
Claude Cookbook
Anthropic published a cookbook of worked API examples for Claude, following the pattern of OpenAI’s cookbook. The content is technically instructive because it goes beyond toy “hello world” prompts and covers production patterns: structured output extraction with constrained JSON schemas using Claude’s tool-use API, multi-turn conversation state management, retrieval-augmented generation pipelines, and agentic loops where Claude invokes tools iteratively. A notable section covers the tool-use (function calling) API mechanics in detail — how to define a tool schema as a JSON Schema object, how Claude emits tool_use content blocks that the caller must execute and return as tool_result blocks, and how to handle multi-hop chains where Claude calls tools multiple times before producing a final answer. Another section addresses prompt caching: Claude’s API supports a cache_control parameter on large system prompts or document blocks, which stores the KV cache server-side and reduces latency and cost on repeated calls with the same prefix. This is architecturally significant — it means multi-turn sessions with large context (e.g., a 50k-token codebase loaded once) amortize the prefill cost across turns. The cookbook also includes streaming examples (server-sent events for incremental token delivery) and vision input patterns. The practical value is in the error handling patterns and the explicit JSON schemas, which are not always obvious from the reference docs. No novel research; this is documentation-as-engineering-guidance.
Noteworthy New Repositories
vshulcz/deja-vu
A purpose-built memory layer for coding agents, targeting the retrieval problem that most agent frameworks punt to a generic vector store. The core claim is 84.9% hit@1 on LongMemEval-S with no LLM involved in retrieval — meaning the recall path is purely deterministic/embedding-based, avoiding inference latency and cost on lookup. The system supports fifteen coding-agent integrations and exposes both retroactive search (finding relevant memories after the fact) and MCP (model context protocol) recall. Notably, it adds temporal indexing — search by when something happened — which matters for debugging sessions where recency is a strong prior. Trust scopes allow per-agent or per-project memory isolation, preventing cross-contamination in multi-agent pipelines. Curated notes with tags provide a structured layer on top of semantic search for cases where exact recall is needed. The entire thing ships as a single zero-dependency binary and runs fully locally, so there is no data leaving the machine and no API key management. For teams building autonomous coding agents where repeated problem-solving is expensive, this is a more targeted alternative to general-purpose RAG over a codebase.
Source: https://github.com/vshulcz/deja-vu
avifenesh/bw24
A from-scratch inference engine written in Rust with CUDA kernels, targeting a single known hardware configuration: one RTX 5090 Laptop (sm_120a). The design philosophy is bit-exact reproducibility — outputs are deterministic by construction, not by convention. It implements NVFP4 (NVIDIA’s 4-bit floating-point format introduced with Blackwell), mixture-of-experts routing, and MTP (multi-token prediction) speculative decoding. The speculative decoding path is particularly relevant: MTP generates multiple candidate tokens per forward pass, reducing the number of full-model evaluations needed per generated token. Tuning against “measured limits of one RTX 5090 Laptop” means the implementation targets actual memory bandwidth and compute throughput rather than theoretical peaks — an honest engineering constraint. Writing the engine in Rust rather than Python/C++ means memory safety without a garbage collector, which matters for the careful buffer management CUDA kernels require. This is primarily a research/learning artifact and a proof of concept for Blackwell-specific optimizations, but it is a concrete starting point for anyone wanting a clean, auditable inference stack without the complexity of vLLM or TensorRT-LLM.
Source: https://github.com/avifenesh/bw24
Skyvern-AI/rustwright
Rustwright reimplements Playwright’s API surface on top of a Rust-native Chrome DevTools Protocol engine, eliminating the Node.js subprocess that Playwright requires even when called from Python. The standard Playwright Python binding still communicates with a Node server process over stdio; Rustwright removes that hop by speaking CDP directly from a Rust core with Python and Node bindings compiled against it. In browser automation, the subprocess round-trip is a latency and reliability tax — each CDP command crosses a process boundary twice. A Rust CDP engine can pipeline commands and handle connection state more efficiently. The Playwright-compatible API means existing test suites or scraping code can migrate without rewriting selectors or page interaction logic. The project is explicitly alpha, meaning the API surface is incomplete and breakage is expected. The main reasons to watch it: lower overhead for high-concurrency automation workloads (e.g., large-scale web scraping, parallel test execution) and the possibility of embedding browser automation in Rust services without a Node dependency in the container. The no-driver-subprocess claim also simplifies deployment in locked-down environments where spawning auxiliary processes is restricted.
Source: https://github.com/Skyvern-AI/rustwright
Rhacknarok/hacksguard
A TUI malware analysis tool written in Rust, targeting the static analysis phase of incident response or malware triage. The core capabilities are deep PE (Portable Executable) format parsing, YARA rule scanning, and heuristic risk scoring — the standard triage trio before dynamic sandbox analysis. PE parsing covers the import table, section entropy, resource directory, and overlay data, which are the primary static indicators analysts check manually. YARA scanning runs against user-supplied or bundled rule sets, allowing classification against known malware families. The heuristic scoring layer aggregates signals (high entropy sections, suspicious imports, packed indicators) into a single risk value, enabling rapid triage across a directory of samples. Being Rust-native and multi-threaded means it can scan large sample collections quickly without the memory safety issues that plague C-based PE parsers when handling malformed headers — a real concern since malware frequently crafts malformed PE headers to crash analysis tools. The TUI (likely built with ratatui or similar) makes it usable over SSH without a GUI. Compared to tools like PEview, PE-bear, or running capa, this is a single-binary, scriptable option suitable for integration into automated pipelines.
Source: https://github.com/Rhacknarok/hacksguard
MIgHTy-alIeN/MEV-Arbitrage-Bot
An MEV (Maximal Extractable Value) arbitrage system consisting of two components: an on-chain smart contract that executes the arbitrage trade atomically, and an off-chain automation script that monitors DEX price feeds and triggers the contract when a profitable opportunity is detected. The architecture is standard for on-chain arbitrage: the contract atomically borrows, swaps across two or more pools, repays, and captures the spread — the atomicity guarantee means the transaction either profits or reverts with no capital at risk beyond gas. The off-chain script handles mempool monitoring, gas estimation, and opportunity detection, feeding calldata to the contract. This pattern is well-established in DeFi; the value of an open-source reference implementation is primarily educational — understanding how arbitrage bots interact with AMM pricing curves, how flashloan callbacks are structured, and how gas bidding interacts with block inclusion. Production MEV bots operate at latencies and with private mempool access (Flashbots, private RPCs) that a public repository cannot provide. Treat this as a learning reference for DeFi mechanics and Solidity contract design rather than a deployable edge.
Source: https://github.com/MIgHTy-alIeN/MEV-Arbitrage-Bot
jmerelnyc/Talos
A GPU worker client for the Talos distributed inference network. The client pairs a local GPU with a Talos account, receives open-model inference jobs over a WebSocket connection, executes them, streams results back, and reports uptime for payout tracking. The architecture is analogous to folding-at-home or Bittensor’s inference subnet: idle consumer or datacenter GPUs contribute compute to a shared inference pool, with uptime and throughput determining compensation. The WebSocket transport is reasonable for streaming token generation back to the coordinator. The “open-model” framing implies the network routes requests for publicly available model weights rather than proprietary ones, which is important for trust — workers need to know what they are running. Key engineering questions not answered by the description: how job isolation is enforced (preventing workers from logging prompts), how the coordinator verifies inference correctness, and what the scheduling policy is. For anyone with spare GPU capacity, this is a straightforward way to monetize idle compute, assuming the network has sufficient demand. The client code is the right starting point for understanding the job protocol and payout mechanics.
Source: https://github.com/jmerelnyc/Talos
oversecured/Samsung_Vulnerabilities
A structured disclosure repository from Oversecured documenting 176 vulnerabilities found in Samsung-preinstalled Android applications. Oversecured operates an automated Android app security scanner, and this represents their accumulated findings against Samsung’s preinstalled app surface — apps that ship on Samsung devices and typically run with elevated system permissions or handle sensitive data (contacts, SMS, camera, location). Preinstalled apps are a critical attack surface because they cannot be uninstalled by users, often hold privileged permissions that third-party apps cannot request, and receive OTA updates on manufacturer timelines rather than Play Store timelines. The vulnerability classes typically found in such audits include intent redirection (allowing privilege escalation), path traversal in content providers, insecure broadcast receivers, and SQL injection in local databases. Having 176 documented CVEs in a single repository makes this a useful reference for Android security researchers, penetration testers targeting Samsung devices, and developers building similar preinstalled app components who want to understand the failure modes. The disclosures are presumably coordinated (Samsung is listed as having been notified), making the repository a post-patch educational resource.
Source: https://github.com/oversecured/Samsung_Vulnerabilities
simonlin1212/investment-news
A locally-running news aggregation and summarization dashboard designed for investors in China A-share markets who need to track global supply chain signals. It maps 12 industry sectors — semiconductors, AI, robotics, new-energy vehicles, and others — to their corresponding A-share listed companies and then pulls from 100+ authoritative sources covering those global supply chains. The daily pipeline runs a local LLM (no external API key required) to distill each sector’s news into Chinese-language bullet points and translate foreign-language articles. The fully local architecture is significant: financial news aggregation with an external LLM API creates data leakage risk and ongoing cost; running inference locally with an open model (likely via Ollama or llama.cpp) eliminates both. The sector-to-stock mapping layer is the structural insight — rather than generic financial news, the system answers “what happened today in the global semiconductor supply chain that is relevant to the A-share semiconductor index.” For retail or quantitative investors focused on thematic A-share exposure, this provides a structured information advantage over manually reading English-language trade press. The codebase is a practical template for domain-specific news intelligence pipelines.