Daily AI Digest — 2026-08-05
arXiv Highlights
AURORA-LM: Autoencoding Unified Representation for Continuous-Latent Diffusion Language Modeling
Problem
Continuous latent diffusion has become the default for images, video, and audio, but text generation remains stubbornly discrete. Attempts to port continuous latent diffusion to language have taken two routes, both unsatisfying:
- Diffuse over token embeddings that were never designed as a joint generation/decoding target — the geometry is discrete-friendly but not diffusion-friendly, yielding poor sample quality.
- Aggressively compress autoencoded latents (few latents per many tokens) so diffusion is tractable — but the resulting latents lose token-level fidelity, and reconstruction ceilings become the bottleneck.
AURORA-LM argues the right decomposition is to keep a high-capacity, decodable text latent and, separately, build a diffusion model powerful enough to fit that harder distribution — not to lobotomize the representation for the diffusion model’s convenience.
Method
There are two components, trained in stages.
Query-based Encoder-Decoder (the latent). Text is encoded into a prefix-aligned latent sequence via cross-attention against learned queries. “Prefix-aligned” means the latent at position i is a function only of tokens up to (roughly) position i, preserving a causal structure that lets the diffusion stage generate left-to-right in blocks. The decoder is autoregressive over tokens conditioned on the latent. Unlike heavily compressed VAE-style text latents, AURORA-LM does not force strong information bottlenecking; the latent is high-capacity so decoding is near-lossless. The tradeoff — and the paper’s central claim — is that this shifts difficulty to the diffusion model, which is where the paper concentrates its architectural effort.
Block-causal Diffusion Transformer (the distribution model). The diffusion model is trained by flow matching over the continuous latent sequence. Generation proceeds block-causally: blocks are produced left to right, and within a block all positions are denoised in parallel. Formally, if z is partitioned into blocks z_{1:B}, then block b is sampled from p_\theta(z_b \mid z_{<b}) by integrating a learned velocity field v_\theta(z_b^t, t, z_{<b}) from t=0 (noise) to t=1 (clean) under the flow-matching objective \mathcal{L}_{\text{FM}} = \mathbb{E}_{t, z_1, z_0}\, \| v_\theta(z_t, t, z_{<b}) - (z_1 - z_0) \|^2, with z_t = (1-t)z_0 + t z_1 under linear interpolation.
The key architectural choice is that only the noisy-input pathway is restricted; the clean-latent prediction task is retained in full. In practice this means the model still sees, and is asked to predict, the full clean latent structure — the causal/blockwise restriction is imposed on how noisy inputs feed into attention, not on the supervision target. This preserves signal from the high-capacity latent while regularizing the input distribution the diffusion transformer must integrate over. It is analogous in spirit to asymmetric encoder/decoder capacity in masked models: give the model the hard prediction task, but restrict what noisy context it can lean on.
Sampling is standard block-wise: draw z_0 \sim \mathcal{N}(0, I), integrate the velocity field for block b conditioned on already-sampled z_{<b}, then decode with the autoregressive token decoder.
Why this design
The two failure modes of prior continuous LMs — bad representation for diffusion, or good diffusion target that cannot decode faithfully — are treated as orthogonal problems. The encoder-decoder is tuned purely for decodability with a causal structure; the diffusion transformer is tuned purely for distribution-matching over that fixed representation. Block-causal generation preserves the left-to-right factorization that makes language models composable with prefixes, KV-cache-like acceleration, and long-context extension, while parallel within-block denoising recovers most of the throughput advantage of non-autoregressive/diffusion decoding.
Results and limitations
The abstract as provided is truncated and the paper’s tables and figures were not supplied here, so I cannot cite specific perplexity, MAUVE, or throughput numbers verbatim. From the framing, the load-bearing empirical claims are (i) that a high-capacity prefix-aligned latent can be modeled directly by flow matching without the usual latent-compression crutch, and (ii) that restricting only the noisy-input pathway measurably improves sample quality relative to symmetric restriction. Any comparison against discrete AR baselines, discrete diffusion (SEDD, MDLM), and prior continuous-latent LMs (Plaid, TESS, LD4LG) will hinge on whether the reconstruction ceiling of the AE is high enough that diffusion errors, not decoding errors, dominate the loss.
Open questions worth flagging:
- How does the block size interact with sample quality and compute? Larger blocks recover more parallelism but make each conditional harder to fit.
- Does the prefix-aligned latent hurt bidirectional-context tasks (infilling, editing) where the appeal of diffusion LMs is strongest?
- Is the AE trained jointly, frozen, or staged? Latent drift during diffusion training is a well-known pitfall.
- Scaling: continuous latent LMs have historically failed to match AR transformers past ~1B params; the paper’s story needs a scaling curve to be persuasive.
Why this matters
If continuous latent diffusion can match autoregressive transformers on language without compressing the latent into a low-fidelity code, it opens a genuine third path between discrete AR and discrete diffusion — one that composes naturally with the continuous-latent stacks already used for other modalities. That is the precondition for unified any-to-any generative models where text is not the awkward outlier.
Source: https://arxiv.org/abs/2608.02602
MerchantBench: Benchmarking LLM Agents for Long-Term Coherence in E-Commerce Operations
Problem
Most agent benchmarks measure success on bounded tasks with prompt reward: browse the web, close a ticket, finish a coding challenge. They leave a capability under-tested that is central to any deployed autonomous system: long-term coherence, meaning the maintenance of a purposeful strategy across a horizon long enough that (i) earlier actions constrain later feasible sets, (ii) feedback returns at heterogeneous delays, and (iii) incoherent local optimization compounds into measurable losses. Seller-side e-commerce is a natural stress test because procurement, listing, pricing, and cash management are recurrent and interdependent, and because order lifecycles couple immediate liquidity pressure with delayed quality signals.
As Figure 1 makes explicit, when an order is placed the agent must commit cash before settlement, while refunds, chargebacks, or rating hits from that order can surface much later — after the agent may have already sunk more capital into related SKUs.
Environment and formulation
MerchantBench is a 365-day, order-level simulator grounded in 98,843 real product records, exposing 26 tools to the agent. It is cast as a finite-horizon POMDP \mathcal{M} = \langle \mathcal{S}, \mathcal{A}, P, \mathcal{O}, Z, R, \mu_0, H_c\rangle. The simulator advances hourly, giving
H_c = 8{,}760 \text{ steps},
but agent activations occur only every 12 hours, so the policy issues ~730 decision windows per run. Between activations the environment executes a null action while demand, supplier states, and order lifecycles continue to evolve. The latent state s_t bundles the clock, per-product demand profiles, supplier conditions, listings, finances, active orders, and pending events. The observation kernel Z(o_{t+1}\mid s_{t+1}, a_t) deliberately hides demand distributions, latent risk parameters, and pending outcome timings, so the policy must condition on observation and tool-result history rather than s_t.
Figure 2 shows the four coupled decision components — Product Sourcing, Listing and Pricing Control, Cash-Flow Management, and Mixed-Latency Feedback Adaptation — connected via a fast upstream supplier channel and a delayed downstream order channel.
Initial conditions are tight: RMB 2,000 cash, a RMB 1,000 security deposit, and 50 listing slots. Unpaid fines are drawn from the deposit, and the run terminates the moment the deposit is exhausted, which turns cash management into a hard survival constraint rather than a soft objective. Rewards are zero at all intermediate steps; the objective is expected terminal net assets
J(\pi) = \mathbb{E}_\pi[R(s_T)], \qquad R(s_T) = B_T + D_T + I_T + Q_T,
with B_T cash, D_T remaining deposit, I_T funds in transit, and Q_T receivables. Since t = H_c halts new demand but active orders continue to T \ge H_c, terminal settlement forces the agent to reason about pipeline value, not just balance sheet at the last activation.
Product diversity is not superficial: the 98,843 SKUs are calibrated to real demand and risk profiles.
Figure 3 shows the wide interquartile spread across products, meaning any coherent policy has to distinguish thin-margin high-volume goods from lumpy high-risk items when allocating the 50-slot listing budget.
Evaluation protocol
Eight contemporary LLMs are evaluated — GPT-5.6 Sol, Claude Opus 4.8, Qwen3.7-Max and Qwen3.7-Plus, GLM-5.2, DeepSeek-V4-Pro and DeepSeek-V4-Flash, and Kimi K2.6 — each under two agent frameworks. ReAct pairs the model with a minimal controller over the 26 tools, isolating planning, reasoning, and tool use. Hermes uses its default stack with code execution, planning, memory, and skill management on top of the same tools. Because interaction histories over 8,760 hours vastly exceed any usable context, both frameworks compress history, and each evaluated model summarizes its own trajectory — a design choice that entangles summarization fidelity with policy performance, but reflects deployment reality.
The protocol runs three trials per (model, framework) pair, yielding 48 runs. A rule-based baseline performs daily housekeeping (remove inactive or supplier-affected products, refill empty slots from the daily market report), and three inexperienced human participants provide a floor for human non-expert operation.
Limitations and open questions
Several design choices merit scrutiny. First, terminal-only reward eliminates any credit-assignment scaffolding; this is faithful to real merchant P&L but makes it hard to attribute failure modes to specific decision components. Second, self-summarization confounds long-horizon reasoning with a model’s ability to compress its own trajectory — a stronger baseline would fix a shared summarizer across models. Third, the 12-hour activation cadence is fixed; agents cannot request more frequent attention during liquidity crises, though such adaptive polling is a plausible operational skill. Fourth, the observation kernel hides demand profiles but exposes daily market reports; the boundary between “should be inferred” and “given” shapes the difficulty in ways not fully ablated in the shown sections. Finally, the excerpt does not report the actual J(\pi) numbers across the eight models, so cross-model coherence rankings and the gap to the rule-based and human baselines remain to be examined in the full paper.
Why this matters
MerchantBench operationalizes long-term coherence as a measurable quantity — terminal net assets under hard cash constraints, delayed feedback, and 730 decision windows — rather than as a qualitative virtue. If frontier LLMs cannot beat a housekeeping rule set on a bounded merchant simulator, claims of autonomous multi-week agentic deployment need considerable revision.
Source: https://arxiv.org/abs/2607.28956
JoyAI-Video-Edit: Real-Time Open-Ended Video Editing with Autoregressive Diffusion
Problem
Streaming video editing imposes constraints that offline diffusion editors sidestep: no access to future frames, unbounded stream length, and a fixed compute budget per frame. Naively running a bidirectional video DiT on a rolling window either violates causality or blows up latency; distillation to few steps introduces source-fidelity loss; and long-horizon rollouts accumulate temporal drift because training uses clean history while inference consumes model-generated history. JoyAI-Video-Edit targets a concrete operating point: 720p, ~30 FPS, open-ended duration, on a single GPU, with quality competitive against offline systems.
Method
The system is a 16B-parameter stack of an MLLM (condition encoder over first frame + edit instruction), a causal video VAE with 8\times 24\times 24 spatiotemporal compression (one latent frame = 8 video frames), and an MM-DiT backbone.
Chunk-wise autoregressive adaptation. The bidirectional DiT is retrofitted to a causal chunked schedule. Videos are split along time into aligned source/target chunks of one latent frame each (i.e., 8 raw frames). Attention is bidirectional within a chunk and causal across chunks. To bound per-step cost, cross-chunk attention is restricted to a sliding window over the K most recent history chunks plus the first chunk, which is retained as a persistent global sink — the same “attention sink” trick that stabilizes long-context autoregressive decoding, here repurposed as a long-horizon visual anchor.
During training, each sequence packs: noised active chunk, source tokens S_t, condition tokens C_t, optional reference tokens R (globally visible), and clean history tokens H_{<t}. Each target chunk gets an independent noise level under a masked flow-matching objective à la Diffusion Forcing. The active chunk attends bidirectionally to S_t, C_t and causally to the in-window history plus the sink.
Resampling forcing. Teacher forcing on clean H_{<t} mismatches the drifting, model-generated history seen at inference. Following Resampling Forcing, clean history chunks are replaced by an on-policy single-step denoising rollout, detached from gradients, aligning the training history distribution with deployment.
SA-DMD and LHAD. Two additional distillation stages target the two remaining failure modes for a real-time model: Source-Anchored Distribution Matching Distillation (SA-DMD) preserves fidelity to the source under aggressive two-step generation, and Long-Horizon Autoregressive Distillation (LHAD) reduces drift over long rollouts. The abstract states these are the levers that let the system stay competitive with offline editors while running few-step.
Deployment mechanics
At inference, each incoming 8-frame chunk is VAE-encoded, denoised by the few-step DiT with cached KV states, and immediately VAE-decoded. The KV cache retains the sink chunk plus a sliding window. The VAE operates in a (1+8)-frame formulation with a pseudo encoder providing the single context frame. FP8 quantization, operator fusion, and graph compilation are applied throughout.
Per-chunk stage timings on a single Nvidia B200:
- VAE encode: 22 ms
- DiT denoise: 185 ms
- VAE decode: 19 ms
- Clean KV-cache construction: 31 ms
- Pseudo encoding: 9 ms
Request-to-response latency is 226 ms; the full cycle is 266 ms, i.e., ~30.1 FPS at 720p.
Data
Because paired video-editing supervision is scarce, edits are transferred from JoyAI-Image’s I2I and R2I data via two pipelines: (1) edit a representative keyframe with an image editor, then propagate via an image-and-video-to-video model that preserves motion and unedited regions; (2) latent-shared I2V generation from an original/edited image pair, sharing early denoising latents to lock motion and composition, then diverging on late-stage conditioning to inject the edit. Outputs are filtered by visual quality, edit correctness, content preservation, and temporal consistency, then an MLLM rewrites instructions from the source/edited pair. Resulting coverage: local edits (subject, background, region), global edits (style, tone, motion), and subject addition/replacement/removal.
Results
The paper compares against a wide slate of streaming editors (StreamDiffusionV2, SANA-Streaming, LiveEdit, XMax-X2.0) and offline systems (VACE, OpenVE-Edit, UniVideo, OmniWeaving, Kiwi-Edit, VInO, Bernini-R, PixVerse V6, Runway Aleph, Kling-3.0 Omni, Kling-O1). The abstract summarizes the outcome: automatic and human evaluations show substantial gains over streaming baselines and competitive standing against strong offline systems on both short and long videos. The concrete numeric claim reproduced in the provided sections is the deployment result — 720p editing at ~30 FPS on a single B200, with 226 ms request-to-response latency — which is the primary system-level contribution.
Limitations and open questions
The sections provided do not include the quantitative tables, so per-metric deltas against baselines cannot be verified here. Several design choices invite scrutiny: (i) a single-frame sliding window plus one sink chunk is a strong bet that long-horizon coherence can be carried by the first chunk alone — behavior on scene cuts or long shots where the sink becomes semantically stale is unclear; (ii) resampling forcing uses single-step rollouts, which likely under-represents multi-step drift dynamics; (iii) SA-DMD trades source fidelity against the two-step generator, and the exact fidelity/steps Pareto is not shown here; (iv) the editing-data pipeline inherits biases from JoyAI-Image and from the I2V propagation model, so edits requiring genuinely new motion (as opposed to appearance edits over preserved motion) may be underrepresented; (v) the 30 FPS number is B200-specific and depends on FP8 kernels — deployment on lesser hardware is not characterized.
Why this matters
Real-time, open-ended video editing at 720p/30 FPS from a 16B diffusion model is a nontrivial systems result, and the combination of sink-anchored sliding-window causal attention, resampling forcing, and two-stage distillation (SA-DMD + LHAD) is a reusable recipe for turning bidirectional video DiTs into streaming generators without collapsing quality.
Source: https://arxiv.org/abs/2608.03974
Hunyuan3D-Buffalo 1.0: A Unified Multimodal Model for Scalable 3D Generation, Understanding, and Editing
Problem
Unified multimodal models on the image side (Qwen-Image, GPT-4o-style systems) have consolidated understanding, generation, and editing under a single architecture, but the 3D analogue lags because of a data bottleneck: there is no large corpus of (source asset, edited asset, instruction) triplets with geometric consistency, nor is there a well-aligned pairing of language, part-level annotation, and 3D shape supervision at scale. Hunyuan3D-Buffalo 1.0 tackles this by (i) building an 87M-sample multimodal 3D corpus and (ii) coupling a 3D-aware VLM with a diffusion transformer initialized from Hunyuan3D-2.1, so that one system handles 3D QA, grounding, text-to-3D, instruction-guided editing, and text-grounded part generation.
Data engine
The training corpus decomposes into three streams (Table 1): ~25M understanding samples (captioning, QA, grounding, edit-related dialogue, interleaved with general text and 2D image-text data to preserve prior multimodal skills), ~50M text-to-3D pairs, and ~12M editing pairs, further split into ~7M human edits, ~3M object edits, and ~2M part-generation samples.
The text-to-3D pipeline is fully automated: compositional prompts are synthesized, assets are generated and rendered, and multi-tier geometry-grounded captions are attached under quality filtering.
The editing corpus is produced by Nano3D-v2, which yields geometrically consistent (source, edited, instruction) triplets refined by VLM-based annotation and filtering. This is the key novelty at the data level, since paired edit supervision has been the main missing ingredient for instruction-following 3D editors.
Architecture
The system has two modules bridged by a lightweight MLP connector:
Hunyuan3D-VLM, a decoder-only LLM extended with 3D perception. Colored point clouds are processed along two pathways: a structural pathway over XYZ + surface normals, and a semantic pathway over RGB appearance. A VecSet encoder turns these into latent tokens, which a Q-Former compresses to a fixed 512-token sequence for fusion with text and image tokens.
Hunyuan3D DiT, initialized from Hunyuan3D-2.1, functions as the generative backbone. VLM hidden states are projected by the MLP connector into the DiT’s conditioning space, so semantic reasoning steers diffusion without overwriting pretrained priors. For editing and part generation, the DiT additionally conditions on a source-object latent to preserve unedited regions.
To make grounding and part reasoning autoregressively expressible, the VLM vocabulary is augmented with 133 special tokens following Part-X-MLLM: <|point_start|>, <|point_end|>, <|point_pad|> delimit the point-cloud token stream, <boxs>/<boxe> delimit boxes, and 128 discrete coordinate tokens <box-0> … <box-127> quantize coordinates over [0,127]. A 3D axis-aligned bounding box is thus six quantized tokens between delimiters, so 3D captioning, QA, grounding, edit-instruction synthesis, and edit-outcome captioning all reduce to instruction-following sequence prediction.
Concretely, given a fused input token stream x = (t_{\text{struct}}, t_{\text{sem}}, t_{\text{img}}, t_{\text{text}}), the VLM factorizes
p(y \mid x) = \prod_i p(y_i \mid y_{<i}, x)
where y_i ranges over both natural-language and coordinate tokens. For generation, the VLM’s hidden states h are mapped by \phi (the MLP connector) to conditioning c = \phi(h), and the DiT samples latent shape z_0 by reverse diffusion conditioned on c (and, for editing, on the source latent z^{\text{src}}).
Results
Evaluation on UniPart-Bench (part-centric 3D perception and language understanding, with coarse Q1 and fine-grained Q2 part granularities, using RGB point clouds and axis-aligned part boxes) compares against GPT4Point, PointLLM, ShapeLLM, ShapeLLM-Omni, Part-X-MLLM, and UniVerse3D. The paper reports state-of-the-art or comparable performance across understanding, text-to-3D, and editing, though the excerpted sections do not enumerate the full per-metric table. The reported scale — 25M/50M/12M across the three capabilities and 512 compressed 3D tokens per asset — is the practical claim: it is the first 3D unified system trained at image-model-like corpus sizes, particularly for edit-pair supervision, which prior work has been unable to obtain at more than ~10^5 scale.
Limitations and open questions
The evaluation window in the excerpts is narrow (UniPart-Bench for understanding); how the editing corpus’s synthetic Nano3D-v2 provenance affects out-of-distribution real edits is not quantified here. The 512-token Q-Former bottleneck likely limits fine-grained geometric grounding for high-genus or highly articulated shapes, and axis-aligned box quantization to [0,127] caps localization precision at roughly 1/128 of the object extent, which is coarse for small parts. Finally, conditioning the DiT on the source latent preserves unedited regions but the trade-off between edit locality and global coherence under compositional multi-step instructions is not analyzed.
Why this matters
The main obstacle to unified 3D foundation models has been paired edit data, not architecture — Hunyuan3D-Buffalo shows that a Nano3D-v2-style synthetic pipeline can produce edit triplets at 12M scale, and that a VLM-plus-DiT split analogous to Qwen-Image transfers cleanly to 3D once point clouds are tokenized with structural and semantic pathways. If the data pipeline holds up under external evaluation, this becomes the template for scaling 3D instruction-following.
Source: https://arxiv.org/abs/2608.02711
PCSD: Persistent Consistency for Self-Distillation in Agentic Reinforcement Learning
Problem
Agentic RL for LLMs suffers from extreme reward sparsity: a multi-turn trajectory of hundreds of tokens may terminate with a single binary outcome. On-policy self-distillation (OPSD) mitigates this by using a privileged teacher (e.g., one with access to skills, tool traces, or oracle context) to provide dense token-level supervision to a student that lacks such privileges at inference. The catch is that the teacher, while stronger overall, is not uniformly reliable at every token position. Two dominant strategies exist: (i) weight distillation by isolated per-token teacher–student log-probability gaps, which is noisy; or (ii) apply a single step- or trajectory-level scalar weight, which ignores intra-step positional variation. PCSD aims to interpolate between these by deriving continuous token-level weights from persistence of teacher-favoring signals across a local window.
Method
Let \delta_{k,i} = \log \pi_T(y_{k,i}\mid\cdot) - \log \pi_S(y_{k,i}\mid\cdot) be the teacher–student log-probability gap at token i of trajectory k on the student-sampled token y_{k,i}. Positive \delta_{k,i} means the teacher would have reinforced this token more strongly than the student.
Persistent-consistency estimate. Rather than trust a pointwise \delta_{k,i}, PCSD aggregates over a forward window of size N with exponential decay:
\bar{\delta}_{k,i}^{(N)} = \frac{\sum_{j=0}^{N-1} \alpha^{j} m_{k,i+j}\,\delta_{k,i+j}}{\sum_{j=0}^{N-1} \alpha^{j} m_{k,i+j}}, \quad \alpha\in(0,1),
where m_{k,i} is the response mask (context and pad tokens excluded), with truncation-and-renormalization near the end of the response. This produces a position-specific summary of teacher relative support that is robust to sampling-level noise but retains locality.
Adaptive short/long interpolation. PCSD computes both a short-window and long-window estimate and interpolates between them based on local variability of \delta: when the gap sequence is locally volatile, the long window damps noise; when it is stable, the short window preserves position-specific detail.
Trend modulation and gating. A one-sided trend modulator attenuates \bar\delta where teacher support is locally declining (so the method does not chase peaks that are collapsing), and a sigmoid gate maps the modulated estimate to a continuous token weight w_{k,i}\in(0,1). These weights scale an auxiliary distillation loss that is added to the standard GRPO objective, yielding a hybrid of dense teacher guidance and sparse environmental feedback.
Importantly, the teacher is used only during training. At inference, the student agent operates without privileged skills or tools.
Results
Experiments use Qwen2.5-3B-Instruct on ALFWorld (six household task categories) and WebShop (128 validation instances from the 1,000-task split, following Feng et al. 2026).
The abstract claims best ALFWorld Overall among all compared baselines without inference-time skills. The radar plot indicates gains are distributed across categories (Pick, Look, Clean, Heat, Cool, Pick2) rather than driven by a single subtask, suggesting the persistence signal is not overfitting to categories where teacher advantage is strongest.
Generalization to the ALFWorld unseen split shows PCSD retains an edge over both plain GRPO (no teacher) and SDAR-style step-weighted self-distillation:
The unseen-split result is the more informative one: it separates “teacher leakage into student parameters” from actual policy improvement. That PCSD dominates in the transfer regime supports the claim that persistence-weighted distillation targets tokens where the teacher’s inductive advantage is genuinely learnable, rather than positions where the teacher’s advantage stems from privileged context that the student cannot recover at test time.
Limitations and open questions
- The method assumes a privileged teacher is available and cheap to score against student rollouts every step. For frontier-scale students, teacher forward passes over full trajectories are a nontrivial cost.
- Hyperparameters — decay \alpha, short/long window sizes, gating temperature, and trend threshold — are not obviously transferable across domains; sensitivity is not shown here.
- The forward-looking window presumes trajectories are collected then scored offline within the training loop; it is not applicable to fully streaming RL.
- No comparison is given to alternative dense-signal schemes such as return decomposition, off-policy value bootstrapping, or process reward models trained on teacher trajectories. Those are natural competitors, not only step-weighted OPSD variants.
- Only a 3B student is evaluated. Whether persistence weighting still helps when the student–teacher gap is smaller (e.g., 32B student, same teacher) is unresolved: if teacher support becomes locally near-random, the persistence filter may simply gate out most tokens.
- ALFWorld and WebShop are relatively short-horizon and have low-diversity action spaces; the argument that persistence stabilizes noisy per-token gaps is strongest in long-horizon settings that were not tested (e.g., SWE-bench-style tool use).
Why this matters
Agentic RL needs credit assignment that is denser than outcome rewards but more selective than blanket teacher imitation. PCSD is a clean instantiation of the idea that temporal persistence of a teacher’s local advantage is a better selector than its instantaneous magnitude, and it plugs into GRPO without changing the RL machinery. If the persistence-versus-magnitude distinction holds up at larger scales and longer horizons, it becomes a general recipe for combining privileged teachers with on-policy RL.
Source: https://arxiv.org/abs/2608.01837
PAST-Bench: Benchmarking the Foundations of Recursive Self-Improvement in Personal Agents
Problem
Recursive self-improvement in agents requires that accumulated experience — memories, skills, corrections, references — actually change future behavior for the better. Existing “persistence-aware” benchmarks conflate two distinct effects: (i) genuine retrieval from a persistent substrate (memory store, skill file, edited rule), and (ii) in-context propagation, where prior content simply remains visible in a long context window or a growing dialogue history. Both maharana2024evaluating / letta2025benchmarking-style long-context setups and streaming benchmarks like evo/lifelongagentbench inherit this ambiguity. PAST-Bench isolates the persistent-substrate pathway by enforcing a strict context-clearing protocol between episodes: any cross-episode improvement must flow through an explicitly stored artifact, not through residual prompt overlap.
Benchmark design
The unit of evaluation is a task family: an ordered sequence of fresh-session episodes sharing a latent rule, artifact, correction, or pre-seeded reference. Between episodes, the framework’s volatile context is wiped. The benchmark covers four capabilities that correspond to distinct persistence pathways:
- Memory — declarative lookup-and-apply of a single read-mostly clause (preferences, constraints, one-line policies). The trigger phrase is stripped from later prompts, forcing retrieval from store.
- Procedural reuse — imperative re-execution of a multi-step technical workflow (SOPs, build/deploy pipelines, incident triage). Order errors, skipped steps, and wrong-tool substitutions count as failures. Revision is deferred to Update.
- Information gathering — a reference is pre-seeded before the family; later episodes test whether the agent knows when to consult it.
- Update — the agent must overwrite an obsolete value or procedure with a corrected one.
Every family carries matched controls: no-retention controls remove the earlier state; distractor controls inject superficially similar irrelevancies; stale controls surface obsolete memories; wrong-mechanism controls plant incorrect skills or evidence sources. The full suite is 26 scenarios / 204 episodes, distributed across the four capabilities as shown below.
Evaluation protocol
Each family is run under paired conditions: persistence-off (no retained state, only the current episode’s prompt) and persistence-on (memory, skills, profile, or session history available). The headline number is the persistence-on score plus the family-balanced gap
\Delta = \text{score}_{\text{on}} - \text{score}_{\text{off}}.
Because \Delta > 0 can arise from confounds (e.g., a distractor happening to help), PAST-Bench also computes a mechanism-evidence score (Eq. 2, Appendix B) from saved artifacts and runtime telemetry: was the specific memory/skill/rule actually written, retrieved, and applied along the intended pathway? Task score and \Delta describe behavior; the mechanism score attributes it.
Findings across models and frameworks
Across seven base models and four agent frameworks, retained experience does produce improvement, but two facts stand out:
- Gains are uneven across capabilities. Memory and update pathways behave differently from procedural reuse and information gathering, and no framework dominates uniformly.
- Two agents with identical \Delta can have very different mechanism-evidence scores. Some frameworks improve for the “right” reason (writing and retrieving an artifact); others improve incidentally, without evidence that the intended save/retrieve/update pathway was traversed. This dissociation is the paper’s central methodological point: behavioral gain is not attribution.
Hermes+ interventions
Guided by the diagnostic breakdown, the authors extend the Hermes framework with five targeted runtime interventions, one per stage of the agent loop:
- E1 Plan — persistence-aware planning at prompt-context construction.
- E2 Render — structured rendering of retrieved memory into the working context.
- E3 Route — routing between memory, skill files, and session history when tools are selected.
- E4 Gate — retrieval gating to suppress stale/distractor content.
- E5 Close — episode closeout logic that decides what to persist and where.
Hermes+ raises the average \Delta over base Hermes (the abstract is truncated on the exact endpoint number, but the ablations confirm each of E1–E5 contributes on a distinct capability slice, consistent with the diagnosis that memory and procedural pathways require different interventions).
Limitations and open questions
The authors are candid about scope. Task families are synthetically constructed and evaluated in isolation, so cross-family interference and long-horizon accumulation are untested. The capability set (memory, procedural reuse, information gathering, update) covers foundations but not stronger recursive behaviors: acquiring new tool-use strategies, revising long-horizon plans, multi-agent experience sharing, or improving the meta-mechanism that decides what to store. The mechanism-evidence score is consistency-based, not causal; genuine attribution requires counterfactual interventions (delete/corrupt the candidate artifact and measure behavioral change) and needs to admit multiple semantically valid pathways, since different agents may encode the same experience as memory, skill, or edited policy. Finally, Hermes+ shows capability- and model-dependent effects, indicating that persistence mechanisms are not uniformly composable — an adaptive router that decides which persistence surface owns a given piece of experience is the natural next step.
Why this matters
PAST-Bench operationalizes a distinction the field has been eliding: whether agents learn across sessions versus whether they merely benefit from prompts staying in context. By pairing context-clearing controls with a mechanism-evidence score, it turns “self-improving agent” claims into falsifiable measurements about specific save/retrieve/update pathways — and shows that headline gains routinely lack pathway evidence.
Source: https://arxiv.org/abs/2608.04003
LLaDA MoE v2: Scaling Mixture-of-Experts Diffusion Language Models
Problem
Scaling laws for autoregressive (AR) transformers are well-characterized (Chinchilla, DeepSeek LLM), but diffusion language models (dLLMs) trained with a masked-denoising objective differ mechanically: each update supervises only a sampled subset of positions, so the nominal batch size overstates the number of effective prediction targets (under uniform timestep sampling, ~50% of tokens are targets in expectation). This alters gradient noise and learning-rate sensitivity, and the situation is further complicated by Mixture-of-Experts (MoE) design axes — activation ratio, expert granularity, and shared-expert fraction. The paper systematically re-derives the compute–hyperparameter, compute–data, and compute–architecture laws for MoE dLLMs, and uses them to train a 30B-A3B model from scratch.
Hyperparameter scaling
The authors sweep batch size B and learning rate \eta over model sizes 158M–3.6B and compute budgets 10^{18}–3\times 10^{20} FLOPs, then fit
B^{*}=0.374\cdot C^{0.3481}, \qquad \eta^{*}=64.8\cdot C^{-0.2447}.
Compared with DeepSeek LLM’s AR laws, the dLLM batch-size exponent is steeper and the learning-rate exponent decays faster, i.e. at high compute dLLMs prefer larger nominal batches and smaller learning rates than AR models at matched C. The authors interpret this as compensation for the reduced effective supervision per token: to keep the effective target count aligned with AR gradient statistics, the nominal batch must grow faster. Extrapolating from the 3\times 10^{20} fit to a 6\times 10^{20} joint grid (Figure 2) puts the fitted recommendation adjacent to the best observed cell, supporting extrapolation.
Compute allocation (IsoFLOP)
Using IsoFLOP curves at multiple C (Figure 3), the compute-optimal split shows a data-side tilt: the optimal token budget D^{*} scales faster with C than the activated non-embedding FLOPs-per-token M^{*}. Concretely, dLLMs prefer proportionally more data per unit of activated model than the roughly M\propto D Chinchilla balance seen for AR models. This is again consistent with the masked-denoising objective having lower supervisory density per token.
MoE architecture decomposition
The activated-parameter budget is factorized into (A, G, S): activation ratio A (activated / total experts including shared), granularity G (relative expert width), and shared-expert fraction S. Two findings:
- At fixed activated capacity, larger scales favor smaller A — i.e. larger expert pools with fewer active experts per token.
- Moderate G and a stable shared-expert share (S \approx 1/3) are optimal across scales.
For LLaDA MoE v2 this yields (A,G,S)=(9.09\%, 8, 33.3\%), realized as 128 fine-grained routed experts with top-8 routing plus one shared expert of width 4 d_{\text{expert}}: A=(8+4)/(128+4)=9.09\%, S=4/(8+4)=33.3\%.
Training and results
LLaDA MoE v2 is 30B total / 3B activated, trained from scratch on 23.5T tokens in five stages: two 10T pretraining stages, a 2T annealing stage, a 500B stage with RoPE base raised 10{,}000\to 500{,}000 and context extended 4\text{K}\to 32\text{K}, and a 1T long-context annealing stage.
On 15 benchmarks it averages 58.60, beating SDAR-Sci (an MoE dLLM obtained by continued pretraining from Qwen3 on 37.05T tokens) by 3.78 points despite training on 63% as many tokens and from scratch. Gains over SDAR-Sci are largest on coding: HumanEval +16.46, BigCodeBench +7.98, MultiPL-E 53.78 vs 33.66. Against AR Qwen3 30B-A3B trained on 36T tokens (65% more), it trails on Chinese knowledge (CEval 76.11 vs 87.50, CMMLU 77.99 vs 86.35) and some coding tasks (LiveCodeBench v6 31.86 vs 49.18) but is close on OlympiadBench (-2.22), HumanEval (-2.44), MMLU (78.01 vs 81.38), and MATH (54.72 vs 59.04). Against smaller dLLMs (LLaDA 8B, Dream 7B, LLaDA MoE 7B-A1B), the gap is \geq 12.44 points.
Limitations and open questions
- The scaling fits are calibrated up to 6\times 10^{20} FLOPs; the 30B-A3B run is well beyond this range and relies on power-law extrapolation.
- The gap to Qwen3 on Chinese benchmarks and LiveCodeBench suggests either data-mix or objective-side deficits that scaling laws alone do not close.
- Effective-token accounting is treated indirectly via nominal B; a first-principles reformulation in terms of expected targets per step could produce a cleaner law and remove the AR-vs-dLLM exponent gap by change of variables.
- The (A,G,S) sweeps are at moderate scale; whether the “smaller A at larger scale” trend continues into the 100B-activated regime is untested.
Why this matters
This is the first systematic scaling-law study for MoE diffusion LLMs, and it produces prescriptive numbers — batch-size and LR exponents, a data-tilted IsoFLOP allocation, and a concrete (A,G,S) — that let a 30B-A3B dLLM approach a strong AR MoE (Qwen3) with 65% of its tokens. It substantially narrows the empirical case that dLLMs are competitive at scale, and provides a re-usable recipe for others training MoE dLLMs from scratch.
Source: https://arxiv.org/abs/2608.03457
Hacker News Signals
Inside vLLM: Anatomy of a High-Throughput LLM Inference System (2025)
Source: https://www.aleksagordic.com/blog/vllm
A deep technical walkthrough of vLLM’s internals, covering the full request lifecycle from HTTP ingress to token emission. The post dissects PagedAttention — the core memory management primitive that partitions the KV cache into fixed-size blocks (analogous to OS virtual memory pages), eliminating the need to pre-allocate contiguous memory per sequence. This allows the scheduler to pack more concurrent sequences and dramatically reduces KV cache fragmentation, which is otherwise the dominant bottleneck in batched inference.
The anatomy covers the scheduler’s continuous batching loop: rather than waiting for all sequences in a batch to finish, vLLM’s scheduler preempts and resumes requests at the token level, keeping GPU utilization high. The block manager tracks a logical-to-physical block mapping per sequence; copy-on-write semantics handle beam search and parallel sampling without duplicating physical blocks until writes diverge.
The post also covers the async engine architecture (AsyncLLMEngine wrapping LLMEngine), the tokenization pipeline, and how sampler parameters (temperature, top-p, top-k, repetition penalties) are applied after logit computation. Notably, it explains how prefix caching — reusing KV blocks for common prompt prefixes — integrates into the block allocator without changing the scheduling interface.
On the distributed side, the write-up addresses tensor parallelism via Megatron-style column/row splits and pipeline parallelism, and how vLLM uses NCCL for inter-GPU communication during attention and MLP layers.
The post is genuinely useful for anyone needing to extend vLLM (custom samplers, new attention backends, disaggregated prefill) or debug latency anomalies. The block table mechanics and scheduler preemption logic are explained with enough specificity to map directly to the source code. No benchmarks are presented; this is purely architectural exposition, which is appropriate given the scope.
When AI Benchmarks Plateau: A Systematic Study of Benchmark Saturation
Source: https://arxiv.org/abs/2602.16763
The paper formalizes benchmark saturation — the point at which model scores cluster near ceiling, making further differentiation unreliable — and provides a systematic methodology for detecting and characterizing it. The authors define saturation operationally: a benchmark is saturated when the variance across top models is dominated by measurement noise rather than genuine capability differences, i.e., when the signal-to-noise ratio of the leaderboard ranking falls below a threshold.
The study surveys saturation across dozens of standard NLP and reasoning benchmarks (MMLU, HellaSwag, ARC, GSM8K, HumanEval, and others) and fits item-response theory (IRT) models to characterize per-item difficulty distributions. A key finding is that saturation is not a single event but a process: benchmarks first saturate at the easy tail (items with near-universal correct responses), then progressively toward harder items. Standard accuracy metrics mask this structure.
The authors propose a saturation score based on effective rank of the model-by-item score matrix — when this rank approaches 1, all models are behaving nearly identically on the benchmark. They also quantify “leaderboard instability”: the probability that rank ordering reverses under bootstrap resampling, which rises sharply post-saturation.
Practical implications are direct. The paper recommends retiring or stratifying benchmarks once the top-k model cluster’s pairwise accuracy differences fall within two standard errors of zero, and advocates for continuously replenishing benchmarks with out-of-distribution items. The IRT-based difficulty calibration is reproducible and doesn’t require access to model internals.
Limitations: the saturation criteria are somewhat threshold-dependent, and the framework doesn’t directly address contamination (training data overlap), which is a separate but compounding problem. The interaction between saturation and contamination deserves more attention.
Zero-Mem: Zero-Token Memory Operations for LLM Agents
Source: https://arxiv.org/abs/2607.29377
Zero-Mem addresses a specific inefficiency in LLM agent memory systems: every read or write to external memory currently requires consuming context tokens, either to encode a query or to inject retrieved content. At high operation frequency, memory I/O becomes a significant fraction of total token budget, and retrieved content displaces reasoning context.
The proposed approach introduces memory operations as side-channel actions that do not occupy the token stream. Concretely, the agent produces structured memory commands (store, retrieve, update, delete) via a parallel head trained to emit discrete operation codes and key/value payloads at each decoding step, bypassing the autoregressive token budget. The memory itself is an external key-value store; the retrieval results are injected via a cross-attention adapter layer rather than prepended to the context.
The adapter is a lightweight module added after each transformer block’s self-attention, taking retrieved embeddings as keys/values and the residual stream as queries. This is architecturally similar to cross-attention in encoder-decoder models, but conditioned on dynamic external memory contents rather than a fixed encoder output.
Training uses a two-stage procedure: first supervised fine-tuning on synthetic agent trajectories with annotated memory operations, then RL fine-tuning with task-completion reward. The operation head is trained jointly with the adapter.
Reported results on multi-hop QA and long-horizon agent tasks show improved task success rates compared to RAG-style token-prepending baselines, with lower effective token usage. The specific gains on HotpotQA and a custom agent benchmark are meaningful but the comparisons are against relatively simple retrieval baselines, not optimized RAG pipelines.
Open question: how the operation head degrades gracefully when the memory store grows large, and whether the cross-attention injection interferes with the base model’s learned representations without careful regularization.
Beating GPT-5.6 Sol on Retrieval with 100x Cheaper Open Models
Source: https://neon.com/blog/how-castform-neon-beats-frontier-models-on-price-and-efficiency
Neon describes Castform, their retrieval system built on top of Postgres with pgvector, that outperforms frontier model retrieval APIs on their internal benchmark at roughly 1/100th the cost. The technical content is more interesting than the headline suggests.
The core claim is that embedding quality for domain-specific retrieval degrades with general-purpose frontier embedders relative to fine-tuned smaller models. Castform uses a fine-tuned bi-encoder (based on an open model in the ~100M–500M parameter range, likely a sentence-transformers derivative) trained on domain-specific query-document pairs via contrastive loss. The fine-tuning data comes from synthetic query generation over their document corpus using a smaller LLM, then filtered by round-trip consistency.
On the infrastructure side, the post details how they use Neon’s branching to maintain separate vector index snapshots per tenant without full data copies — relevant for multi-tenant SaaS where index freshness differs per customer. HNSW indexing is used via pgvector with tuned ef_construction and m parameters; they report index build time and recall tradeoffs at specific settings.
The benchmark is proprietary (Neon’s own customer workloads), which limits external validity. The comparison against “GPT-5.6 Sol” presumably refers to OpenAI’s embedding API. The cost differential is primarily compute: their fine-tuned model runs on smaller hardware, and pgvector queries stay in-database without an API round-trip.
The deeper point — that fine-tuning a small domain-specific embedder beats general-purpose frontier embeddings for specialized retrieval — is well-established in the literature (e.g., BEIR benchmark work), but the Postgres-native deployment story and branching-based index management are operationally novel.
Humans Missed 1 in 3 Threats Approving AI Agent Commands Across 40k Game Runs
Source: https://scalex.dev/blog/ai-agent-permissions-stats/
ScaleX ran a controlled study using a game environment where human participants acted as permission-granting supervisors for AI agents executing action sequences. Over roughly 40,000 runs, humans failed to flag malicious or out-of-scope commands approximately 33% of the time. The setup is effectively a human-in-the-loop security evaluation for agentic AI systems.
The game environment encodes simplified versions of real-world agent permission scenarios: file access, network calls, data exfiltration analogs, privilege escalation. Threats were injected at varying positions in command sequences and with varying syntactic disguise (benign-looking names, obfuscated intent). The 33% miss rate is a population average; miss rates varied by threat position (later in a sequence = higher miss rate, consistent with attention fatigue), obfuscation level, and time pressure.
The data raises a concrete systems problem: human oversight of AI agents does not scale and is not reliable enough to serve as a primary security control. The miss rate is comparable to known human performance on phishing detection and code review for subtle vulnerabilities — roughly the same failure regime.
The post does not propose a technical solution, but the implicit argument is for automated policy enforcement (capability-scoped sandboxing, formal permission models) rather than relying on human approval flows. This connects to ongoing work on least-privilege agent architectures and the debate over whether HITL (human-in-the-loop) approval is security theater for high-velocity agent systems.
Caveats: the game environment may not faithfully represent the cognitive load or threat distribution of real deployments. Participant demographics and instructions are not fully specified. Still, 40k runs is a substantial sample, and the directional finding — humans are unreliable threat detectors for agent command streams — is credible and practically important.
Why Erdos Problems Are Falling to AI
Source: https://www.quantamagazine.org/why-the-legendary-erdos-problems-are-falling-to-ai-20260803/
The Quanta piece covers recent progress on combinatorics problems from the Erdos problem list, specifically cases where AI-assisted search has produced new constructions or proofs. The technical substance centers on two modes of AI contribution: exhaustive combinatorial search guided by learned heuristics, and automated conjecture verification.
The most concrete example discussed is work on Ramsey multiplicity and related extremal graph theory problems, where the search space for counterexamples or extremal constructions is combinatorially large but locally structured. AI systems (primarily large-scale tree search with learned value functions, similar in spirit to AlphaZero-style MCTS) have found constructions that human mathematicians missed, not because the AI understands the mathematics more deeply, but because it explores the search space more systematically and doesn’t anchor on aesthetic biases.
A second contribution mode is the use of LLMs as proof-sketch generators: given a partial argument, the model proposes the next lemma or technique. Mathematicians then verify or refute the suggestion. This accelerates the conjecture-refinement loop without requiring the model to produce correct proofs end-to-end.
The article is careful to note that the AI contributions so far are in the construction/verification layer, not in generating genuinely novel proof strategies. Erdos problems that require deep structural insight (rather than clever construction) remain untouched. The distinction matters: combinatorial existence proofs often reduce to search, which is where learned heuristics provide the most leverage.
The harder open question is whether these tools will penetrate problems that require conceptual innovation — new algebraic structures, unexpected reductions. Current evidence suggests they will not in the near term, but the construction-search layer is now effectively automated for a meaningful subclass of combinatorics problems.
Goodhart’s Law Comes for Every Benchmark You Trust
Source: https://cacm.acm.org/blogcacm/goodharts-law-comes-for-every-benchmark-you-trust/
This CACM blog post is a conceptual piece making the case that Goodhart’s Law — when a measure becomes a target, it ceases to be a good measure — applies structurally and inevitably to ML benchmarks, not just as an occasional empirical failure but as a consequence of how the field’s incentive gradients work.
The argument proceeds in three parts. First, benchmark adoption creates publication incentives that select for optimization pressure on the specific benchmark rather than the underlying capability. Second, training data contamination is not a bug but an expected outcome given that benchmark data is public and training corpora are large and loosely filtered. Third, even without explicit contamination, architectural and hyperparameter choices in the field converge toward what works on established benchmarks, creating a form of indirect overfitting at the community level.
The post cites the progression of BLEU, ImageNet top-5 accuracy, GLUE/SuperGLUE, and more recently MMLU as case studies. In each case, the benchmark was a useful proxy until it wasn’t, and the failure mode was not random but directional: models optimized for the benchmark diverged from the underlying capability in predictable ways (e.g., texture bias in ImageNet models, surface-pattern exploitation in NLU benchmarks).
The recommended response is a combination of held-out evaluation (benchmarks that are never released publicly until after a model freeze), adversarial benchmark construction (dynamic leaderboards where items are replaced as they saturate), and multi-benchmark triangulation rather than single-number reporting.
The post doesn’t introduce new theory or experiments — it’s an editorial argument — but it’s a useful framing for why the saturation paper above and the contamination literature are not independent problems but facets of the same structural issue.
Noteworthy New Repositories
giannisanni/pulsar
Pulsar is a Rust+CUDA inference engine designed specifically for massive mixture-of-experts (MoE) models that cannot fit in GPU VRAM. The core problem it solves is heterogeneous memory placement: rather than requiring the entire model on-device, Pulsar measures PCIe bandwidth at startup and then statically assigns attention layers and the hottest experts to GPU memory while streaming cold experts from SSD via DMA. No configuration file is needed — the placement decisions are automatic.
On two consumer 16 GB GPUs, reported throughput is 2 tok/s for GLM 5.2 (743B parameters) and 7 tok/s for Hy3 (295B parameters). These numbers are modest in absolute terms but represent the difference between running and not running such models at all on non-datacenter hardware. The multi-GPU path is zero-config: Pulsar enumerates devices, benchmarks inter-device links, and partitions accordingly.
The Rust layer handles orchestration, memory management, and scheduling; CUDA kernels cover compute. The SSD-streaming design means latency is bottlenecked by NVMe read bandwidth for cold experts rather than by compute, which makes the approach most effective on PCIe 4/5 NVMe drives. This is a practical engineering target: the bottleneck for hobbyist MoE inference is not FLOPS but memory, and Pulsar attacks that directly without requiring model sharding configuration from the user.
Source: https://github.com/giannisanni/pulsar
drumih/turbo-fieldfare
Turbo-fieldfare demonstrates that Gemma 4 26B-A4B — a 26B-parameter MoE model with 4B active parameters per forward pass — can run within approximately 2 GB of RAM on Apple M-series MacBooks. The key enabler is aggressive quantization of the inactive expert weights combined with exploiting the MoE sparsity: only the activated expert weights need to be hot in memory at any given forward pass.
The implementation targets Apple’s Metal/MLX stack, taking advantage of unified memory architecture where CPU and GPU share the same physical DRAM. Because M-series chips have high memory bandwidth relative to their DRAM capacity, streaming quantized weights into active buffers is less penalizing than on discrete GPU setups. The 2 GB figure refers to the working set, not the total model size on disk.
This matters for local inference use cases where privacy or offline operation is required and the host machine is a standard developer laptop. The 26B nominal parameter count would normally require 13–26 GB of float16/bfloat16 VRAM; the 4B active-parameter MoE structure plus quantization reduces the practical memory requirement by roughly an order of magnitude. The repo provides runnable scripts rather than a library, making it a demonstration and starting point rather than a production framework.
Source: https://github.com/drumih/turbo-fieldfare
FareedKhan-dev/kimi-k3-in-c
This repository implements inference for Kimi K3, a 2.78-trillion-parameter model, in portable C99 with no external dependencies — no BLAS, no CUDA, no framework of any kind. The stated working set is 8.24 GB of RAM on a single CPU, achieved through aggressive quantization (the weights are not stored at full precision) and a minimal runtime that allocates only what is strictly necessary for the active forward pass.
The C99 constraint is significant: it means the code compiles on virtually any target with a C compiler, including embedded-adjacent systems and environments where Python or CUDA toolchains are absent. The implementation covers tokenization, attention (likely using a grouped-query or multi-head variant matching K3’s architecture), feedforward layers, and sampling, all from scratch.
The 8.24 GB figure for a 2.78T-parameter model implies roughly 3-bit average quantization across the weight tensors. At these bit depths, quality degradation on reasoning-heavy benchmarks is non-trivial, so this is primarily a portability and existence proof rather than a production inference path. The value is demonstrating that trillion-parameter models are not categorically inaccessible without specialized hardware when the right compression is applied. Useful as a reference implementation and for understanding the minimal machinery required to run large models.
Source: https://github.com/FareedKhan-dev/kimi-k3-in-c
Paritok-official/paritok-4b-v1
Paritok is a token-compression middleware for AI coding agents. It sits between the agent and the underlying LLM API, rewriting context to reduce token count before transmission. The compression ratio scales with session length: the claim is 25% reduction on the first turn, rising to 85%+ in long or context-saturated sessions, which translates to fitting roughly 3x more conversation turns within a fixed context window.
The compression is powered by a 4B-parameter model trained specifically on code-adjacent text, enabling it to apply semantic compression rather than purely lexical deduplication. “Code-native” here means the model understands that whitespace, variable names, and syntactic structure carry meaning differently than prose, and compresses accordingly without corrupting semantics.
Integration is via BASE_URL substitution — any agent that accepts a configurable API endpoint (Claude Code, Cursor, Codex, OpenHands) can route through Paritok without code changes. The “non-destructive” framing means the original context is preserved on the Paritok side and only the compressed representation is forwarded; the agent sees normal responses.
The economic case is straightforward: at high token volumes, a 4B inference cost that yields 50-80% reduction in LLM API spend is a positive trade. The open question is fidelity loss in the compressed representation, particularly for long-range code references where compression of earlier context can break later reasoning.
Source: https://github.com/Paritok-official/paritok-4b-v1
Quantova/QCore.js
QCore.js is the JavaScript and WebAssembly client library for Quantova’s post-quantum cryptographic stack. It exposes post-quantum signing primitives and Q1 address generation, with the cryptographic core compiled from Rust to WebAssembly. This architecture provides near-native performance for the computationally expensive lattice or hash-based operations while remaining deployable in browsers and Node.js without native addon compilation.
The “post-quantum signing” likely refers to NIST-standardized algorithms (ML-DSA/Dilithium or SLH-DSA/SPHINCS+), though the repository description does not specify which scheme. Q1 addresses are Quantova’s address format derived from post-quantum public keys, which are substantially larger than elliptic-curve keys (Dilithium public keys are ~1.3 KB vs. 32 bytes for Ed25519), making serialization and hashing choices architecturally important.
The Rust-core/WASM-binding pattern is the correct engineering choice here: it allows the cryptographic primitives to be audited and tested as a single Rust codebase while the JS layer handles API ergonomics and browser compatibility. The main practical concern for WebAssembly deployments is the WASM module size from large post-quantum key material and the latency of key generation and signing operations relative to classical alternatives. Useful for developers building blockchain or secure messaging applications that need quantum-resistant signatures without a native binary dependency.
Source: https://github.com/Quantova/QCore.js
dinosn/fastjson-jsontype-rce-lab
This repository provides reproducible Docker lab environments and a defensive scanner for remote code execution vulnerabilities in both fastjson 1.x and fastjson2. Two distinct attack surfaces are covered. The first is CVE-2026-16723 affecting fastjson 1.2.66–1.2.83, exploited via @JSONType resource probing to trigger remote class loading. The second targets fastjson2 2.0.57 and demonstrates that autoType being disabled does not fully prevent exploitation: polymorphic type annotations (@JSONType(seeAlso) and Jackson’s @JsonSubTypes) can be used to reach loadClass through a chain that the autoType blocklist does not intercept.
The payloads are marker-only — they demonstrate reachability and class loading without delivering a destructive payload, making the labs safe to run for defensive research. The lab also tests the two main mitigations: safeMode (fastjson’s strict mode that disables autoType entirely) and running under JDK 17, which restricts the JNDI/RMI remote class loading paths that these attacks rely on.
For security engineers, the fastjson2 finding is the more significant result: it demonstrates a bypass of the documented mitigation path. The Docker setup makes it straightforward to verify whether a specific application configuration is vulnerable before deploying a patch. The included scanner can probe running services for the vulnerability indicators.
Source: https://github.com/dinosn/fastjson-jsontype-rce-lab
domaup/coldcard-poc
This repository is a proof-of-concept tool for reconstructing BIP39 seed phrases from Coldcard Mk3 hardware wallets, tied to the Block security disclosure published July 2026. The vulnerability is in the Mk3’s random number generator: a flaw in the RNG implementation produces seeds with insufficient entropy, making the seed space smaller than the nominal 128 or 256 bits implied by BIP39.
The PoC takes whatever observable information is available about a target wallet (creation metadata, address patterns, or partial seed words depending on the attack model) and searches the reduced-entropy seed space to reconstruct the mnemonic. The existence of such a tool in public form is standard practice after a coordinated disclosure — it validates the vulnerability claim and establishes that affected devices require immediate key migration.
Coldcard Mk3 was a consumer hardware wallet with significant deployment. The Mk4 and Mk5 use a different hardware RNG. Users with Mk3 devices who have not already migrated funds should treat this as a critical action item. The technical detail that matters most — the specific RNG defect and the resulting entropy bound — would be in the linked Block security advisory. The repository itself is primarily a sweep tool rather than an exploit explainer. Do not use against wallets you do not own.
Source: https://github.com/domaup/coldcard-poc
openai/codex-security
Codex Security is OpenAI’s CLI and TypeScript SDK for automated security vulnerability detection, validation, and remediation in codebases. It is distributed as an npm package (@openai/codex-security) and targets integration into CI pipelines and developer workflows rather than as a standalone SAST tool.
The architecture wraps LLM-powered analysis with structured output schemas: the model identifies candidate vulnerabilities, a validation step attempts to confirm exploitability (distinguishing true positives from noise), and a fix generation step produces patches. The TypeScript SDK exposes these three phases programmatically, allowing callers to intercept results between stages or integrate with issue trackers and PR workflows.
Compared to traditional SAST tools (Semgrep, CodeQL), the LLM-based approach trades precision and determinism for coverage of novel patterns and the ability to reason about multi-file data flow without requiring a complete program analysis framework. The tradeoff is false positive rate and non-determinism between runs. The validation step is presumably intended to address the false positive problem, though the quality of that validation is the critical unknown.
With 9,225 stars at listing, this has attracted substantial attention. The primary questions for adopters are: what vulnerability classes it covers reliably, how the validation step works mechanically, and whether the fix generation produces patches that pass existing test suites. The CLI path makes it straightforward to evaluate on an existing repository.